ROS Tutorial Learning

Preface:This article is written for a nifty girl who I cherish.

(0)General

(0.0)Attribution

Hardware-Operation system-ROS-Application

(0.1)Description

…

(1)Beginner Level

(1.0)Basic ROS instructions

#install a distribution
sudo apt-get install ros-<distro>-ros-tutorials
#find a package
#rospack find [package_name]
rospack find roscpp
#cd to a specific ros folder
#roscd <package-or-stack>[/subdir]
roscd roscpp/cmake

(1.0)Create a catkin Package

• Workspace organized frame

workspace_folder         -- WORKSPACE
  |-src                    -- SOURCE SPACE
    |-CMakeLists.txt        -- The 'toplevel' CMake file
    |-package_1
      |-CMakeLists.txt
      |-package.xml
      ...
    |-package_n
      |-CATKIN_IGNORE       -- Optional empty file to exclude package_n from being processed
      |-CMakeLists.txt
      |-package.xml
      ...
  |-build                  -- BUILD SPACE
    |-CATKIN_IGNORE         -- Keeps catkin from walking this directory
  |-devel                  -- DEVELOPMENT SPACE (set by CATKIN_DEVEL_PREFIX)
    |-bin
    |-etc
    |-include
    |-lib
    |-share
    |-.catkin
    |-env.bash
    |-setup.bash
    |-setup.sh
    ...
  |-install                -- INSTALL SPACE (set by CMAKE_INSTALL_PREFIX)
    |-bin
    |-etc
    |-include
    |-lib
    |-share
    |-.catkin             
    |-env.bash
    |-setup.bash
    |-setup.sh
    ...

• Package organized frame

my_package
  |-CMakeLists.txt
  |-package.xml

• Basic Instructions

#create a workspace
mkdir -p catkin_ws/src
cd catkin_ws
catkin_make
#create a package
# catkin_create_pkg <package_name> [depend1] [depend2] [depend3]
cd src
catkin_create_pkg beginner_tutorials std_msgs rospy roscpp
#add the workspace to your ROS environment
cd ../devel
. setup.bash
#inspect the dirct dependancies of a package, and these dependancies were declared in package.xml
rospack depends1 beginner_tutorials
#inspect the indirct dependancies of a package
rospack depends1 rospy
#inspect all indirct dependancies of a package
rospack depends beginner_tutorials

• Customizing the package
  One can customize either the ‘package.xml’ by editing ‘description tag’ ,‘maintainer tags’,‘license tags’ and ‘dependencies tags’ or the ‘CMakeLists.txt’ by add some CMake rules.

(1.1)Build a ROS package

• Basic instructions

#append source to environment if you didn't conduct
# For melodic for instance
source /opt/ros/melodic/setup.bash             
# In a catkin workspace, catkin_make is a junction of cmake and make, one performs in a folder containning 'src' folder
catkin_make
catkin_make install  # (optionally)
#Source files in a different folder
catkin_make --source my_src
catkin_make install --source my_src  # (optionally)

(1.2)Understanding ROS Nodes

• General
  Introduces ROS graph concepts and discusses the use of roscore, rosnode, and rosrun commandline tools.
• ROS graph system

#Nodes: A node is an executable that uses ROS to communicate with other nodes.
#Messages: ROS data type used when subscribing or publishing to a topic.
#Topics: Nodes can publish messages to a topic as well as subscribe to a topic to receive messages.
#Master: Name service for ROS (i.e. helps nodes find each other)
#rosout: ROS equivalent of stdout/stderr
#roscore: Master + rosout + parameter server (parameter server will be introduced later) 

• Basic instructions

#install a light simulator
# For melodic for instance
sudo apt-get install ros-melodic-ros-tutorials
#enable a roscore service at very first
roscore
#open a new terminal and type to see what running roscore did
rosnode list
#see additional information about a node
rosnode info /rosout
#rosrun, one can directly run a node within a package (without having to know the package path).
#rosrun [package_name] [node_name] 
#for example
rosrun turtlesim turtlesim_node
#or one can boringly run with changed name
rosrun turtlesim turtlesim_node __name:=my_turtle
#ping with rosnode
rosnode ping my_turtle

(1.3)The black box of ROS topics

• General
  The turtlesim_node and the turtle_teleop_key node are communicating with each other over a ROS Topic. turtle_teleop_key is publishing the key strokes on a topic, while turtlesim subscribes to the same topic to receive the key strokes. Let’s use ‘rqt_graph’ which shows the nodes and topics currently running.
• Basic instructions

#	install rqt_graph
# For melodic for instance
sudo apt-get install ros-melodic-rqt
sudo apt-get install ros-melodic-rqt-common-plugins
# type to see relation
rosrun rqt_graph rqt_graph
#The rostopic tool allows you to get information about ROS topics.
#seek for help comments
rostopic -h
#echo message
rostopic echo /turtle1/cmd_vel
#This displays a verbose list of topics to publish to and subscribe to and their type. 
rostopic list -v
#View the message type of communication
rostopic type /turtle1/cmd_vel
#messege detail
rosmsg show geometry_msgs/Twist
#send message with command
#rostopic pub [topic] [msg_type] [args]
rostopic pub -1 /turtle1/cmd_vel geometry_msgs/Twist -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]'
#-1:only send 1 message
#/turtle1/cmd_vel:name of topic
#geometry_msgs/Twist:This is the message type to use when publishing to the topic
#[2.0, 0.0, 0.0]' '[0.0, 0.0, 1.8]:linear and angula
#endless moving
rostopic pub /turtle1/cmd_vel geometry_msgs/Twist -r 1 -- '[2.0, 0.0, 0.0]' '[0.0, 0.0, -1.8]'
#Using rostopic hz
#see control rate, rostopic hz [topic]
rostopic hz /turtle1/pose
#Using rqt_plot
#open plot,type  /turtle1/pose/x in the blank to see the plot
rosrun rqt_plot rqt_plot

(1.4)ROS Services and Parameters

• General
  Services are another way that nodes can communicate with each other. Services allow nodes to send a request and receive a response.
• Service usage list

rosservice list         print information about active services
rosservice call         call the service with the provided args
rosservice type         print service type
rosservice find         find services by service type
rosservice uri          print service ROSRPC uri

(1.5)Creating a ROS msg and srv

Click to view

(1.6)Writing a Simple publisher and subscriber (C++), And compile them

• First you have to create 2 packages named like beginner_tutorials and beginner_tutorials2 with:

catkin_create_pkg beginner_tutorials std_msgs rospy roscpp

• mkdir msg in beginner_tutorials and touch an empty file named Num.msg, and mkdir srv in beginner_tutorials and touch an empty file named AddTwoInts.srv. Similarly, perform the same instructions in package beginner_tutorials2.
• then in beginner_tutorials

touch main.cpp
gedit main.cpp

filling with

#include "ros/ros.h"
#include "std_msgs/String.h"
#include <sstream>
/**
 * This tutorial demonstrates simple sending of messages over the ROS system.
 */
int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line.
   * For programmatic remappings you can use a different version of init() which takes
   * remappings directly, but for most command-line programs, passing argc and argv is
   * the easiest way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, "talker");

  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;

  /**
   * The advertise() function is how you tell ROS that you want to
   * publish on a given topic name. This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing. After this advertise() call is made, the master
   * node will notify anyone who is trying to subscribe to this topic name,
   * and they will in turn negotiate a peer-to-peer connection with this
   * node.  advertise() returns a Publisher object which allows you to
   * publish messages on that topic through a call to publish().  Once
   * all copies of the returned Publisher object are destroyed, the topic
   * will be automatically unadvertised.
   *
   * The second parameter to advertise() is the size of the message queue
   * used for publishing messages.  If messages are published more quickly
   * than we can send them, the number here specifies how many messages to
   * buffer up before throwing some away.
   */
  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);

  ros::Rate loop_rate(10);

  /**
   * A count of how many messages we have sent. This is used to create
   * a unique string for each message.
   */
  int count = 0;
  while (ros::ok())
  {
    /**
     * This is a message object. You stuff it with data, and then publish it.
     */
    std_msgs::String msg;

    std::stringstream ss;
    ss << "hello world " << count;
    msg.data = ss.str();

    ROS_INFO("%s", msg.data.c_str());

    /**
     * The publish() function is how you send messages. The parameter
     * is the message object. The type of this object must agree with the type
     * given as a template parameter to the advertise<>() call, as was done
     * in the constructor above.
     */
    chatter_pub.publish(msg);

    ros::spinOnce();

    loop_rate.sleep();
    ++count;
  }
  return 0;
}

editing CMakefiles with:

cmake_minimum_required(VERSION 2.8.3)
project(beginner_tutorials)
## Find catkin and any catkin packages
find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)
## Declare ROS messages and services
add_message_files(DIRECTORY msg FILES Num.msg)
add_service_files(DIRECTORY srv FILES AddTwoInts.srv)
## Generate added messages and services
generate_messages(DEPENDENCIES std_msgs)
## Declare a catkin package
catkin_package()
#specify the c++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
add_executable(beginner_tutorials src/main.cpp)
target_link_libraries(beginner_tutorials ${catkin_LIBRARIES})
add_dependencies(beginner_tutorials beginner_tutorials_generate_messages_cpp)
include_directories(include ${catkin_INCLUDE_DIRS} )

• then in beginner_tutorials2

touch main.cpp
gedit main.cpp

filling main.cpp with:

#include "ros/ros.h"
#include "std_msgs/String.h"
/**
 * This tutorial demonstrates simple receipt of messages over the ROS system.
 */
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
  ROS_INFO("I heard: [%s]", msg->data.c_str());
}

int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line.
   * For programmatic remappings you can use a different version of init() which takes
   * remappings directly, but for most command-line programs, passing argc and argv is
   * the easiest way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, "listener");

  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;

  /**
   * The subscribe() call is how you tell ROS that you want to receive messages
   * on a given topic.  This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing.  Messages are passed to a callback function, here
   * called chatterCallback.  subscribe() returns a Subscriber object that you
   * must hold on to until you want to unsubscribe.  When all copies of the Subscriber
   * object go out of scope, this callback will automatically be unsubscribed from
   * this topic.
   *
   * The second parameter to the subscribe() function is the size of the message
   * queue.  If messages are arriving faster than they are being processed, this
   * is the number of messages that will be buffered up before beginning to throw
   * away the oldest ones.
   */
  ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);

  /**
   * ros::spin() will enter a loop, pumping callbacks.  With this version, all
   * callbacks will be called from within this thread (the main one).  ros::spin()
   * will exit when Ctrl-C is pressed, or the node is shutdown by the master.
   */
  ros::spin();

  return 0;
}

editing CMakeLists.txt with:

cmake_minimum_required(VERSION 2.8.3)
project(beginner_tutorials2)

## Find catkin and any catkin packages
find_package(catkin REQUIRED COMPONENTS roscpp rospy std_msgs genmsg)

## Declare ROS messages and services
add_message_files(DIRECTORY msg FILES Num.msg)
add_service_files(DIRECTORY srv FILES AddTwoInts.srv)

## Generate added messages and services
generate_messages(DEPENDENCIES std_msgs)

## Declare a catkin package
catkin_package()
#specify the c++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
add_executable(beginner_tutorials2 src/main.cpp)
target_link_libraries(beginner_tutorials2 ${catkin_LIBRARIES})
add_dependencies(beginner_tutorials2 beginner_tutorials2_generate_messages_cpp)
include_directories(include ${catkin_INCLUDE_DIRS} )

• compile

#cd to workspace root foleder
roscore
#new a terminal in the same place
source ./devel/setup.bash
rosrun beginner_tutorials beginner_tutorials
#new a terminal in the same place
source ./devel/setup.bash
rosrun beginner_tutorials2 beginner_tutorials2

(1.7)Writing a Simple publisher and subscriber (python), And compile them

• basic

#create package first
cd src
mkdir scripts
touch scripts/main.py

• CMakeLists.txt

#append at last line of this file
catkin_install_python(PROGRAMS scripts/main.py 
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

(1.8)Writing a Simple Service and Client , And compile them

click to view

• remember to edit the AddTwoInts.srv file in beginner_tutorials package

• run with

rosrun beginner_tutorials add_two_ints_server     #(C++)
rosrun beginner_tutorials add_two_ints_server.py  #(Python) 
rosrun beginner_tutorials add_two_ints_client 1 3     #(C++)
rosrun beginner_tutorials add_two_ints_client.py 1 3  #(Python) 

(1.9)Recording and playing back data

roscore
#new terminal
rosrun turtlesim turtlesim_node
#new terminal
rosrun turtlesim turtle_teleop_key
#new terminal and a specific folder
mkdir bagfiles
cd bagfiles
#start record, use ctrl+c to end record
rosbag record -a
#show info information
rosbag info <your bagfile>
#run
rosbag play <your bagfile>
#and one can also run 2 times fast,or just record 1 pose

(1)Intermediate Level

…