Backup diff of ROS integration(No. 2)

The added line is THIS COLOR.
The deleted line is THIS COLOR.
[[Tutorial]]

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


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.

#contents

*ROS installation [#ed1b8136]
To install ROS, use this [[tutorial:http://www.ros.org/wiki/groovy/Installation/Ubuntu]]


*Overview[#ed1b8322]

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 =

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]].



=== Installation ===

First, make sure your Debian package index is up-to-date:

  $ sudo apt-get update



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



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

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




Individual Package:

- You can also install a specific ROS package (replace underscores with dashes of the package name):

 $ sudo apt-get install ros-groovy-PACKAGE

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


To find available packages, use:

 $ apt-cache search ros-groovy


=== Initialize rosdep ===

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.


 $ sudo rosdep init
 $ rosdep update




=== Getting rosinstall ===

[[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: 


 $ sudo apt-get install python-rosinstall



*Creating SIGVerse Package [#ed1b8323]

- You need to create a new Ros Package to perform the ROS SIGverse integration

- Let’s create a new directory  named catkin_ws and let’s perform those few tasks

- 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 we have our workspace let’s create our SIGverse  Package 


-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: 

  $~/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:


   $source ~/catkin_ws2/devel/setup.sh 



-Now we can check our package by executing this command 
--Roscd Sigvers_Ros so we get the following result:



CMakeLists.txt
include
msg
package.xml
src


This shows that the Sigvers_Ros packages exists



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 )




 ## 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
     )



  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]

   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



**Node Initialization [#ed1b8137]

  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;
    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);
   }




**Robot Controller [#ed1b8138]

 double SendController::onAction(ActionEvent &evt)
 {
  my->setWheelVelocity(Weel_one,Weel_two);
  ros::spinOnce();
  return 1.0;
 }


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


**Command Node initialization ROS Side [#ed1b8139]

  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);
    
    }
- Initialization of the command Node's Parameters 

- The Node will send velocity information using mycommand_velocity Topic

- The Node will receive information using CommandMess Topic

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

**Main to execute the Node [#v1bef770]

 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);
  }

- this command creates and does initialization on 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:

** Robot Motion Command ROS Side [#ed1b8141]

   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]

To run the server you have to follow the following steps:

Go to catkin_ws and execute the follwing command :
 
-Run the ROS system:
 $ roscore
run the ros ROS node :

 $ 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
Backup diff of ROS integration (No. 2)
