ROS tutorial (publisher / subscriber)

Writing the Publisher Node in C++

 

source ~/catkin_ws/devel/setup.bash

- To let the OS to know where ROS files are. 

roscd beginner_tutorials

- Make src/talker.cpp

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

}

Building the nodes- Modify CMakeLists.txt

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

)

## Declare a catkin package

catkin_package()

## Specify additional locations of header files

## Your package locations should be listed before other locations

include_directories(

# include

  ${catkin_INCLUDE_DIRS}

)

add_executable(talker src/talker.cpp)

target_link_libraries(talker ${catkin_LIBRARIES})

add_dependencies(talker beginner_tutorials_generate_messages_cpp)

add_executable(listener src/listener.cpp)

target_link_libraries(listener ${catkin_LIBRARIES})

add_dependencies(listener beginner_tutorials_generate_messages_cpp)

add_executable(talker src/talker.cpp)

target_link_libraries(talker ${catkin_LIBRARIES})

add_dependencies(talker beginner_tutorials_generate_messages_cpp)

add_executable(listener src/listener.cpp)

target_link_libraries(listener ${catkin_LIBRARIES})

add_dependencies(listener beginner_tutorials_generate_messages_cpp)

- This will create two executables, talker and listner, which by default will go to into package directory of your devel space, located by default at ~/catkin_ws/devel/lib/<package name>

source ~/catkin_ws/devel/setup.bash

- Let the terminal knows ROS.  

rosrun beginner_tutorials talker

[ INFO] [1533680834.204181475]: hello world 0

[ INFO] [1533680834.304349319]: hello world 1

[ INFO] [1533680834.404339320]: hello world 2

[ INFO] [1533680834.504308288]: hello world 3

[ INFO] [1533680834.604425992]: hello world 4

[ INFO] [1533680834.704335552]: hello world 5

rosrun beginner_tutorials listner

[ INFO] [1533680866.009809858]: I heard: [hello world 3]

[ INFO] [1533680866.109670809]: I heard: [hello world 4]

[ INFO] [1533680866.209616448]: I heard: [hello world 5]

[ INFO] [1533680866.309694638]: I heard: [hello world 6]

[ INFO] [1533680866.409597115]: I heard: [hello world 7]

Writing the Publisher Node in Python

 

mkdir scripts

- This is where the Python scripts are saved. 

cd scripts

wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/rospy_tutorials/001_talker_listener/talker.py

#!/usr/bin/env python

import rospy

from std_msgs.msg import String

def talker():

    pub = rospy.Publisher('chatter', String, queue_size=10)

    rospy.init_node('talker', anonymous=True)

    rate = rospy.Rate(10) # 10hz

    while not rospy.is_shutdown():

        hello_str = "hello world %s" % rospy.get_time()

        rospy.loginfo(hello_str)

        pub.publish(hello_str)

        rate.sleep()

if __name__ == '__main__':

    try:

        talker()

    except rospy.ROSInterruptException:

        pass

chmod +x talker.py

- This is required for the Python script to be executable. 

python talker.py

- Run talker. 

wget https://raw.github.com/ros/ros_tutorials/kinetic-devel/rospy_tutorials/001_talker_listener/listener.py

#!/usr/bin/env python

import rospy

from std_msgs.msg import String

def callback(data):

    rospy.loginfo(rospy.get_caller_id() + 'I heard %s', data.data)

def listener():

    # In ROS, nodes are uniquely named. If two nodes with the same

    # name are launched, the previous one is kicked off. The

    # anonymous=True flag means that rospy will choose a unique

    # name for our 'listener' node so that multiple listeners can

    # run simultaneously.

    rospy.init_node('listener', anonymous=True)

    rospy.Subscriber('chatter', String, callback)

    # spin() simply keeps python from exiting until this node is stopped

    rospy.spin()

if __name__ == '__main__':

    listener()

chmod +x listener.py

python listener.py

---

Running the publishers and subscribers

cd ~/catkin_ws

source ./devel/setup.bash

rosrun beginner_tutorials talker

rosrun beginner_tutorials talker.py

rosrun beginner_tutorials listener

rosrun beginner_tutorials listener.py

---

Creating a ROS service

----- I am too tired for this. 

#