[[Tutorial]]
Up:[[Tutorial]]

----

The aim of this tutorial is to explain how to integrate SIGVerse with ROS operating system.

First, we will show how to install ROS on your operating system, then we will explain step by step how to run SIGVerse controller in ROS node and how to communicate with another node.

Ros tutorial on SIGverse
-How to Use ROS with SIGverse
-User has to create A SIGverse node using the following code:
--In this tutorial two topics are used 
--Message Topic to send messages from SIGverse Node to Command Node and Velocity --format Topic to send the value of velocity to the SIGverse node.
The ROS part tutorial is based on the official [[ROS wiki:http://www.ros.org/wiki/]], you can check it for more details.

#contents

*Overview[#ed1b8322]

In order to integrate SIGVerse and ROS, we first need to create ROS package containing two nodes, SIGVerse controller node and ROS command node.
The first node, SIGVerse controller node, will receive data from the SIGViewer as messages, then publish them on the message topic, in the other part, ROS command node reads these data and subscribe the corresponding velocity on the velocity topic, the velocity command will be retrieved by the SIGVerse controller node to be used for controlling the robot.

*Overview[#ed1b8322]
&ref(Simple_Ros_.PNG,,80%);

In order to integrate SIGVerse and ROS You need to build the following basic system. You first have to install ROS on your computer then build two ROS packages.
-The first package will run with the SIGVerse Controller in order to perform the message reception from the SIGViewer and the robot motion with velocity command.
-the second package will receive the messages and perform the correct command
those two packages will contains nodes and will use two topics to perform comunication.
-the first topic is used to send messages.
-the second topic is used to feedback the command velocity.

////////////////////////////////////

&ref(Simple_Ros.PNG,,80%);


*Installing ROS [#ed1b8326]

= Ubuntu install of ROS Groovy =
To install ROS on your server please refer to the [[official web site:http://wiki.ros.org/ROS/Installation]].

We are building Debian packages for several Ubuntu platforms, listed below. These packages are more efficient than source-based builds and are our preferred installation method for Ubuntu.

If you need to install from source ('''not recommended'''), please see [[groovy/Installation/Source|source (download-and-compile) installation instructions]].
**Creating ROS workspace [#ed1b8324]
In our project we are using catkin, here are the steps to follow to create a ROS workspace:

Run the following command:
 $ source /opt/ros/groovy/setup.sh

To create a catkin workspace:

=== Installation ===
 $ mkdir -p ~/catkin_ws/src
 $ cd ~/catkin_ws/src
 $ catkin_init_workspace

First, make sure your Debian package index is up-to-date:
You can build even though no project is created yet, you just need MakeLists.txt:

  $ sudo apt-get update
 $ cd ~/catkin_ws/
 $ catkin_make

Run the setup.bash

 $ source devel/setup.bash

There are many different libraries and tools in ROS.  We provided four default configurations to get you started.  You can also install ROS packages individually.

  
   $ sudo apt-get install ros-groovy-desktop-full
 
////////////////////////////////////


   $ sudo apt-get install ros-groovy-desktop
*Creating the package [#ed1b8323]
We need to create a new package in the catkin_ws directory.
// containing two nodes.

- To create a new package, go to catkin_ws:
 $ cd ~/catkin_ws/src
 $ catkin_create_pkg sig_ros

//- Create two new cpp files named sig_controller.cpp and ros_controller.cpp
// $ cd ~/catkin_ws/sig_ros/src/
// $ vim sig_controller.cpp
// $ vim ros_controller.cpp

ROS-Base: (Bare Bones)
-ROS package, build, and communication libraries. No GUI tools.

 
  $ sudo apt-get install ros-groovy-ros-base

/////////////////////////////////////////



Individual Package:
*Download the project [#ed1b8232]

- You can also install a specific ROS package (replace underscores with dashes of the package name):
Please download the project file from here.~
https://github.com/SIGVerse/samples/tree/master/ROS_integration

 $ sudo apt-get install ros-groovy-PACKAGE
// To download the project from GIT repository, use the following link:
// git@socio4.iir.nii.ac.jp:~/SigverseGitServer/unstable/usersContribution/tafifet/ROS_SIG_Integration.git

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

////////////////////////////////////////

To find available packages, use:

 $ apt-cache search ros-groovy
* Compiling the project [#ed1b8353]

-After downloading the project from git, copy the "sig_ros" directory to ~/catkin_make/src.
-In "~/catkin_make/devel/lib" create a new directory named "libsig_ros" and copy the file "RobotInMove.xml"

=== Initialize rosdep ===
You need to have Cmake installed on your server.

Before you can use ROS, you will need to initialize `rosdep`. `rosdep` enables you to easily install system dependencies for source you want to compile and is required to run some core components in ROS.
Let's edit the CMakeLists.txt file to compile the project:


 $ sudo rosdep init
 $ rosdep update
Cmake parameters:

#highlight(cpp){{
 cmake_minimum_required(VERSION 2.8.3)
 project(Sigvers_Ros)
  find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs message_generation )
 ## Generate messages in the 'msg' folder
     add_message_files(
     FILES
     Velocity.msg
     )
  ## Generate added messages and services with any dependencies listed here
     generate_messages(
     DEPENDENCIES
     std_msgs
     )
  ## include libraries
  include_directories(include ${catkin_INCLUDE_DIRS})
  include_directories(/home/<username>/sigverse-2.2.0/include/sigverse/home/<username>/sigverse-2.2.0/include/sigverse/comm/controller)
}}


- These lines allow to generate the ros_controller node:

=== Getting rosinstall ===
 add_executable(ros_controller src/ros_controller.cpp)
 target_link_libraries(ros_controller ${catkin_LIBRARIES})
 add_dependencies(ros_controller sig_ros_gencpp)

[[rosinstall]] is a frequently used command-line tool in ROS that is distributed separately.  It enables you to easily download many source trees for ROS packages with one command.

- To install this tool on Ubuntu, run: 
- These lines allow to generate the sig_controller library:

 ADD_LIBRARY(sig_ros/sig_controller src/sig_controller.cpp)
 target_link_libraries(sig_ros/sig_controller ${catkin_LIBRARIES})
 add_dependencies(sig_ros/sig_controller sig_ros_gencpp)

 $ sudo apt-get install python-rosinstall

- To compile the package, run the following commands:
 $ cd ~/catkin_ws
 $ catkin_make

A new library will be generated in ~/catkin_ws/devel/lib/libsig_ros.

*Creating SIGVerse Package [#ed1b8323]

- You need to create a new Ros Package to perform the ROS SIGverse integration
Run the following command to add this package to ROS packages:

- Let’s create a new directory  named catkin_ws and let’s perform those few tasks
   $source ~/catkin_ws/devel/setup.sh 

- Create a new folder named src.

- Now let’s initialize our workspace by using the following command:

**Catkin Workspace initialization  [#ed1b8136]
  $catkin_init_workspace in the ~/catkin_ws folder  
-Now let's check if our package is recognized by ROS:
 & Roscd sig_ros

We must have the following output:

- Now we have our workspace let’s create our SIGverse  Package 
 $ CMakeLists.txt include msg package.xml src


-Firstable we need to make a new folder named SIGverse  then  edit the Cmake  file and  Sig_app.cpp in a new src folder which PATH is: 
This shows that the sig_ros package exists.

  $~/catkin_ws/src/Sigvers_Ros/src.

////////////////////////////////////

 $ cd ~/catkin_ws/src
 $ catkin_create_pkg Sigvers_Ros


-Now  make  Cmake file in order to create the wanted package.
Catkin_make will generate a /devel folder which contains /devel/lib folder and in there the Cmake file generated a libSig_app.so file which will be used by the xml world file to control the robot simulation.
Now let’s souce our package by using the following command:
*Testing the project [#ed1b4432]

**Running the server [#ed1b8132]

   $source ~/catkin_ws2/devel/setup.sh 
To run the server please follow the these steps:

Go to catkin_ws and and follow these steps :
 
-Run the ROS system:

 $ roscore

-Now we can check our package by executing this command 
--Roscd Sigvers_Ros so we get the following result:
-Go to ~/catkin_ws/devel/lib/libsig_ros, and run the sigverse controller:

 $ cd ~/catkin_ws/devel/lib/libsig_ros
 $ sigserver.sh -w ./RobotInMove.xml


CMakeLists.txt
include
msg
package.xml
src
**Client side [#ed1b8131]


This shows that the Sigvers_Ros packages exists
-Run SIGViewer and start the viewer to launch the two nodes.

-To make the robot move, click on the message button, select robot_000 as entity, and send one the following messages:
moveforward, movebackward, turnleft and turnright.


Cmake parameters:
For Sig.cpp:
 cmake_minimum_required(VERSION 2.8.3)
 project(Sigvers_Ros)
  find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs message_generation )
*Source Code understanding [#ed1b3329]

**SIGVerse controller node [#ed1b3669]

sig_controller.cpp


 ## Generate messages in the 'msg' folder
     add_message_files(
     FILES
     Velocity.msg
     )
- Let’s check this file step by step 

The following is the callback function which preforms the command on the velocity of the robot’s wheels:


***Message Sender [#ed1b8136]

  ## Generate added messages and services with any dependencies listed here
     generate_messages(
     DEPENDENCIES
     std_msgs
     )



  ADD_LIBRARY(Sig_app src/Sig_app.cpp)
  target_link_libraries(Sig_app ${catkin_LIBRARIES})
  add_dependencies(Sig_app Sigvers_Ros_gencpp)




- We use the target_link_libraries which generates the .so file 
  include_directories(include ${catkin_INCLUDE_DIRS})
  include_directories(/home/ericgt/sigverse-2.2.0/include/sigverse/home/ericgt/sigverse-2.2.0/include/sigverse/comm/controller)


- Here you include SiGverse .h files to compile our controller’s source code
Catkin Command:

-- catkin_make 

-we compile our code using Cmake parameters so we generate .so  file used by the xml world file to control the robot simulation.


*Creating ROS Package [#ed1b8324]

*Source Code understanding [#ed1b8324]

-Let’s study this example step by step 
Now let’s create the callback function which preforms the command on the velocity of the robot’s wheels:


**Message Sender [#ed1b8136]

#highlight(cpp){{
   void SendController::poseCallback(const Sigvers_Ros::VelocityConstPtr& vel)
   {     Wheel_one =  vel->linear;
         Wheel_two =  vel->angular;
      
         printf("Velocity 1!!!  %f\n", Wheel_one);
         printf("Velocity 2!!!  %f\n", Wheel_two);
      
   }
}}

- read from the Velocity Topic
- Printing the Velocity value applied on the robot
-Read from the Velocity Topic.
-Print the Velocity value applied on the robot.



**Node Initialization [#ed1b8137]
***Node Initialization [#ed1b8137]

#highlight(cpp){{
  void SendController::onInit(InitEvent &evt)
   { Wheel_one = 0.0;
    Wheel_two = 0.0;
    int argc =0;
    char** argv = NULL;
    my = this->getRobotObj(this->myname());
    my->setWheel(10.0, 10.0);
    ros::init(argc, argv, "Sigvers_controller_node");
    ros::NodeHandle n;
    ros::init(argc, argv, "sig_controller_node"); //Initialize ROS. This allows ROS to do name remapping through the command line
                                                  // -- not important for now. This is also where we specify the name of our node.
                                                  //Node names must be unique in a running system.
    ros::NodeHandle n;                            // Create a handle to this process' node. The first NodeHandle created will actually do the initialization
                                                  // of the node, and the last one destructed will cleanup any resources the node was using.
    velocity = 1;
    chatter_pub = n.advertise<std_msgs::String>("CommandMess", 1);
    pose_sub = n.subscribe<Sigvers_Ros::Velocity>("mycommand_velocity",    1,&SendController::poseCallback,this);
    ros::Rate loop_rate(10);
    chatter_pub = n.advertise<std_msgs::String>("command_message", 1);
    pose_sub    = n.subscribe<Sigvers_Ros::Velocity>("velocity_command",    1,&SendController::poseCallback,this);
    ros::Rate loop_rate(10); //A ros::Rate object allows you to specify a frequency that you would like to loop at. 
                             //It will keep track of how long it has been since the last call to Rate::sleep(),
                             //and sleep for the correct amount of time.In this case we tell it we want to run at 10hz.
   // Running the ros_command node
   system ("source ~/catkin_ws/devel/setup.sh");
   system ("rosrun sig_ros ros_controller &");
   }
}}

-In this part, we initialize the ROS node.
-Create two topics for publishing/reading data, command_message and velocity_command node.
-Launch the ros_controller node.



**Robot Controller [#ed1b8138]

***Robot Controller [#ed1b8138]
#highlight(cpp){{
 double SendController::onAction(ActionEvent &evt)
 {
  my->setWheelVelocity(Weel_one,Weel_two);
  ros::spinOnce();
  ros::spinOnce(); //
  return 1.0;
 }
}}

This function allows to control the robot using the appropriate velocity.

- Now let’s create a Node to control the robot’s velocity:

**ROS command node [#ed1b3779]

**Command Node initialization ROS Side [#ed1b8139]


This is the node that controls the robot’s velocity:

ros_controller.cpp:

#highlight(cpp){{
  CommandSig::CommandSig():
   linear_(0),
   angular_(0),
   l_scale_(2.0),
   a_scale_(2.0)
   {
    nh_.param("scale_angular", a_scale_, a_scale_);
    nh_.param("scale_linear", l_scale_, l_scale_);
    vel_pub_ = nh_.advertise<Sigvers_Ros::Velocity>("mycommand_velocity", 1);
    mess_sub =    nh_.subscribe("CommandMess",100,&CommandSig::chatterCallback,this);
    
    }
     nh_.param("scale_angular", a_scale_, a_scale_);
     nh_.param("scale_linear",  l_scale_, l_scale_);
     vel_pub_ = nh_.advertise<Sigvers_Ros::Velocity>("velocity_command", 1);
     mess_sub =    nh_.subscribe("command_message",100,&CommandSig::chatterCallback,this);
   }
}}

- Initialization of the command Node's Parameters 

- The Node will send velocity information using mycommand_velocity Topic
- The Node will send velocity information using velocity_command Topic

- The Node will receive information using CommandMess Topic
- The Node will receive information using command_message Topic

- And finally let’s write the main function which launches the command  node

**Main to execute the Node [#v1bef770]
***Main to execute the Node [#v1bef770]

 int main(int argc, char** argv)
#highlight(cpp){{
int main(int argc, char** argv)
  {
   ros::init(argc, argv, "Sigvers_Command_node");
   CommandSig Command_sig;
   ros::Rate loop_rate(10);
   ros::spin();
   return(0);
    ros::init(argc, argv, "ros_command_node");
    CommandSig Command_sig;
    ros::Rate loop_rate(10);
    ros::spin();
    return(0);
  }
}}

- this command creates and does initialization on the Sigvers_Command_node
Node 
- This part starts the Sigvers_Command_node Node.

**Message Sender [#ed1b8140]

-Now let’s create the callback function which receveces message from Sigverse - Node and  sends the right command to the robot:
***Message Sender [#ed1b8140]

** Robot Motion Command ROS Side [#ed1b8141]
- This is the callback function which receives messages from the SIGVerse controller node and publishes the corresponding velocity to be sent to the robot on the velocity_command topic:

#highlight(cpp){{
   void CommandSig::chatterCallback (const std_msgs::String::ConstPtr& msg)
   {
    Sigvers_Ros::Velocity vel;
    if(strcmp("go",msg->data.c_str())==0)
    {
    vel.angular = 3.0;
    vel.linear = 3.0;
    vel_pub_.publish(vel);
    }
    else if(strcmp("back",msg->data.c_str())==0)
   {
    vel.angular = -3.0;
    vel.linear = -3.0;
    vel_pub_.publish(vel);
    }
    else if(strcmp("left" ,msg->data.c_str())==0)
   {
   vel.angular = 0.78;
   vel.linear = -0.78;
   vel_pub_.publish(vel);
   sleep(1.8);
   vel.angular = 0.0;
   vel.linear = 0.0;
   vel_pub_.publish(vel);
   }
   else if(strcmp("right" ,msg->data.c_str())==0)
   {
   vel.angular = -0.78;
   vel.linear = 0.78;
   vel_pub_.publish(vel);
   sleep(1.8);
   vel.angular = 0.0;
   vel.linear =  0.0;
   vel_pub_.publish(vel);
   }
   else if(strcmp("stop",msg->data.c_str())==0)
  {
   vel.angular = 0.0;
   vel.linear = 0.0;
   vel_pub_.publish(vel);
  }
 ………
 .....
 }
}}

//////////////////////////////////////////////////////

*Running the server [#ed1b8132]
* World file [#ed1b8152]

To run the server you have to follow the following steps:
RobotInMove.xml:

Go to catkin_ws and execute the follwing command :
 
-Run the ROS system:
 $ roscore
run the ros ROS node :
#highlight(cpp){{
 <?xml version="1.0" encoding="utf-8"?>
 <world name="myworld1">
  <gravity x="0.0" y="-980.7" z="0.0"/>
 <instanciate class="WheelRobot-nii-v1.xml" type="Robot">
    <set-attr-value name="name"           value="robot_000"/>
    <set-attr-value name="language"       value="c++"/>
    <set-attr-value name="implementation" value="./libSig_app.so"/>
    <set-attr-value name="dynamics"       value="false"/>
    <set-attr-value name="x"              value="-100.0"/>
    <set-attr-value name="y"              value="30.0"/>
    <set-attr-value name="z"              value="-130.0"/>
    <set-attr-value name="collision"      value="true"/>
    <!--stereo camera right-->
    <camera id="1"
            link="REYE_LINK"
            direction="0.0 -1.0 1.0"
            position="0.0 0.0 3.0"/>
    <!--stereo camera left-->
    <camera id="2"
            link="LEYE_LINK"
            direction="0.0 -1.0 1.0"
            position="0.0 0.0 3.0"/>
    <!--distance sensor-->
    <camera id="3"
            link="WAIST_LINK0"
            direction="0.0 1.0 0.0"
            position="0.0 -5.0 20.0"/>
    <!--monitoring camera-->
    <camera id="4"
            link="WAIST_LINK2"
            direction="0 0 1"
            quaternion="0.0 0.0 -0.966 0.259"
            position="0.0 40.0 120.0"/>
  </instanciate>
 </world>
}}

 $ rosrun key_sig sig_app 
Go to ~/catkin_ws/devel/lib/libsig_app and run the sigverse controller:
$ cd ~/catkin_ws/devel/lib/libsig_app
$ sigserver.sh -w ./move_robot.xml
////////////////////////////////////////////////////

#counter
#highlight(end)

[[Tutorial]]
Front page   New List of pages Search Recent changes   Help   RSS of recent changes