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

 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:
void SendController::poseCallback(const Sigvers_Ros::VelocityConstPtr& vel)
{
 
    Wheel_one =  vel->linear;
    Wheel_two =  vel->angular;
// read from the Velocity Topic
   printf("Velocity 1!!!  %f\n", Wheel_one);
   printf("Velocity 2!!!  %f\n", Wheel_two);
//Printing the Velocity value applied on the robot
}
#contents



*Overview[#ed1b8322]

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


ros::init(argc, argv, "Sigvers_controller_node");
ros::NodeHandle n;
velocity = 1;
*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]].

chatter_pub = n.advertise<std_msgs::String>("CommandMess", 1);


=== Installation ===

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

pose_sub = n.subscribe<Sigvers_Ros::Velocity>("mycommand_velocity", 1,&SendController::poseCallback,this);
  $ 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.

ros::Rate loop_rate(10);
}
  
   $ sudo apt-get install ros-groovy-desktop-full
 


   $ sudo apt-get install ros-groovy-desktop


double SendController::
onAction(ActionEvent &evt)
{

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

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


my->setWheelVelocity(Weel_one,Weel_two);
ros::spinOnce();


Individual Package:

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

  return 1.0;
}
 $ sudo apt-get install ros-groovy-PACKAGE

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


To find available packages, use:

Now let’s create a Node to control the robot’s velocity:
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_);
 // this part will give parameters will be given to the node
 $ 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.

   vel_pub_ = nh_.advertise<Sigvers_Ros::Velocity>("mycommand_velocity", 1);
  // The Node will send velocity information using mycommand_velocity Topic 

 $ sudo rosdep init
 $ rosdep update



   mess_sub = nh_.subscribe("CommandMess",100,&CommandSig::chatterCallback,this);
   // The Node will receive information using CommandMess Topic 
 }

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

And finally let’s write the main function which launches the command  node
int main(int argc, char** argv)
 {
   ros::init(argc, argv, "Sigvers_Command_node");
   // this command creates and does initialization on the Sigvers_Command_node Node 
   CommandSig Command_sig;
   
   ros::Rate loop_rate(10);
   ros::spin();
   return(0);
 }

 $ sudo apt-get install python-rosinstall



Now let’s create the callback function which receveces message from Sigverse Node and  sends the right command to the robot:
void CommandSig::chatterCallback (const std_msgs::String::ConstPtr& msg)
{
 Sigvers_Ros::Velocity vel;
*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.

if(strcmp("go",msg->data.c_str())==0)
{
vel.angular = 3.0;
vel.linear = 3.0;
vel_pub_.publish(vel);
- 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 

}
    else if(strcmp("back",msg->data.c_str())==0)
    {
vel.angular = -3.0;
vel.linear = -3.0;
vel_pub_.publish(vel);

-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




    }








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




                     }
………
}




Create a new ROS Package :
We 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_init_workspace in the ~/catkin_ws folder  




Now we have our workspace let’s create our SIGverse ROS Package 




Firstable we have to make a new folder named SIGverse and then  edit the Cmake  file and  Sig_app.cpp in a new src folder which PATH is ~/catkin_ws/src/Sigvers_Ros/src.




Now  make  Cmake file in order to create the wanted package.
Catkin_make will generate a /devel folder with 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  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 


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:



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


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

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 )
- read from the Velocity Topic
- Printing the Velocity value applied on the robot



**Node Initialization [#ed1b8137]

## Generate messages in the 'msg' folder
 add_message_files(
   FILES
   Velocity.msg
)
  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);
   }




## Generate added messages and services with any dependencies listed here
 generate_messages(
   DEPENDENCIES
   std_msgs
 )
**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);
  }

ADD_LIBRARY(Sig_app src/Sig_app.cpp)
target_link_libraries(Sig_app ${catkin_LIBRARIES})
add_dependencies(Sig_app Sigvers_Ros_gencpp)
- 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]

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

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


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