1 /**
  2  * 该例程将发布chatter话题，消息类型String
  3  */
  4 
  5 #include <sstream>
  6 #include "ros/ros.h"
  7 #include "std_msgs/String.h"
  8 
  9 int main(int argc, char **argv)
 10 {
 11   // ROS节点初始化       节点名称（运行名称）
 12   ros::init(argc, argv, "talker");
 13 
 14   // 创建节点句柄
 15   ros::NodeHandle n;
 16 
 17   // 创建一个Publisher发布者，发布名为chatter（话题名）的topic，消息类型为std_msgs::String
 18   ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
 19 
 20   // 设置循环的频率   多久循环一次
 21   ros::Rate loop_rate(10);
 22 
 23   int count = 0;
 24   while (ros::ok())
 25   {
 26 	// 初始化std_msgs::String类型的消息
 27     std_msgs::String msg;
 28     std::stringstream ss;
 29     ss << "hello world " << count;
 30     msg.data = ss.str();
 31 
 32 	// 发布消息
 33     ROS_INFO("%s", msg.data.c_str());
 34     chatter_pub.publish(msg);
 35 
 36 	// 循环等待回调函数              在这里实际上没有意义后边还会讲
 37     ros::spinOnce();
 38 
 39 	// 按照循环频率延时         不写sleep系统会一直循环，cpu占用会很高
 40     loop_rate.sleep();
 41     ++count;
 42   }
 43 
 44   return 0;
 45 }

  1 /**
  2  * 该例程将订阅chatter话题，消息类型String
  3  */
  4 
  5 #include "ros/ros.h"
  6 #include "std_msgs/String.h"
  7 
  8 // 接收到订阅的消息后，会进入消息回调函数
  9 void chatterCallback(const std_msgs::String::ConstPtr& msg)
 10 {
 11   // 将接收到的消息打印出来
 12   ROS_INFO("I heard: [%s]", msg->data.c_str());
 13 }
 14 
 15 int main(int argc, char **argv)
 16 {
 17   // 初始化ROS节点
 18   ros::init(argc, argv, "listener");
 19 
 20   // 创建节点句柄
 21   ros::NodeHandle n;
 22 
 23   // 创建一个Subscriber，订阅名为chatter的topic，注册回调函数chatterCallback   需要订阅的话题名为chatter，进入回调函数
 24   ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
 25 
 26   // 循环等待回调函数   一直等待消息发布，接收到后会进入回调函数
 27   ros::spin();
 28 
 29   return 0;
 30 }

  1 /**
  2  * AddTwoInts Server
  3  */
  4 
  5 #include "ros/ros.h"
  6 #include "learning_communication/AddTwoInts.h"
  7 
  8 // service回调函数，输入参数req，输出参数res    三个---以上的是request  以下的是response
  9 bool add(learning_communication::AddTwoInts::Request  &req,
 10          learning_communication::AddTwoInts::Response &res)
 11 {
 12   // 将输入参数中的请求数据相加，结果放到应答变量中
 13   res.sum = req.a + req.b;
 14   ROS_INFO("request: x=%ld, y=%ld", (long int)req.a, (long int)req.b);
 15   ROS_INFO("sending back response: [%ld]", (long int)res.sum);
 16 
 17   return true;
 18 }
 19 
 20 int main(int argc, char **argv)
 21 {
 22   // ROS节点初始化
 23   ros::init(argc, argv, "add_two_ints_server");
 24 
 25   // 创建节点句柄
 26   ros::NodeHandle n;
 27 
 28   // 创建一个名为add_two_ints的server，注册回调函数add()  服务名  add为回调函数
 29   ros::ServiceServer service = n.advertiseService("add_two_ints", add);
 30 
 31   // 循环等待回调函数
 32   ROS_INFO("Ready to add two ints.");
 33   ros::spin();
 34 
 35   return 0;
 36 }

  1 /**
  2  * AddTwoInts Client
  3  */
  4 
  5 #include <cstdlib>
  6 #include "ros/ros.h"
  7 #include "learning_communication/AddTwoInts.h"
  8 
  9 int main(int argc, char **argv)
 10 {
 11   // ROS节点初始化
 12   ros::init(argc, argv, "add_two_ints_client");
 13 
 14   // 从终端命令行获取两个加数
 15   if (argc != 3)
 16   {
 17     ROS_INFO("usage: add_two_ints_client X Y");
 18     return 1;
 19   }
 20 
 21   // 创建节点句柄
 22   ros::NodeHandle n;
 23 
 24   // 创建一个client，请求add_two_int service，service消息类型是learning_communication::AddTwoInts
 25   ros::ServiceClient client = n.serviceClient<learning_communication::AddTwoInts>("add_two_ints");
 26 
 27   // 创建learning_communication::AddTwoInts类型的service消息
 28   learning_communication::AddTwoInts srv;
 29   srv.request.a = atoll(argv[1]);
 30   srv.request.b = atoll(argv[2]);
 31 
 32   // 发布service请求，等待加法运算的应答结果          调用call如果服务端没有回应，会卡在这儿，发生阻塞
 33   if (client.call(srv))
 34   {
 35     ROS_INFO("Sum: %ld", (long int)srv.response.sum);
 36   }
 37   else
 38   {
 39     ROS_ERROR("Failed to call service add_two_ints");
 40     return 1;
 41   }
 42 
 43   return 0;
 44 }

  1 #include <ros/ros.h>
  2 #include <actionlib/server/simple_action_server.h>
  3 #include "learning_communication/DoDishesAction.h"
  4 
  5 typedef actionlib::SimpleActionServer<learning_communication::DoDishesAction> Server;
  6 
  7 // 收到action的goal后调用该回调函数
  8 void execute(const learning_communication::DoDishesGoalConstPtr& goal, Server* as)
  9 {
 10     ros::Rate r(1);
 11     learning_communication::DoDishesFeedback feedback;
 12 
 13     ROS_INFO("Dishwasher %d is working.", goal->dishwasher_id);
 14 
 15     // 假设洗盘子的进度，并且按照1hz的频率发布进度feedback
 16     for(int i=1; i<=10; i++)
 17     {
 18         feedback.percent_complete = i * 10;
 19         as->publishFeedback(feedback);
 20         r.sleep();
 21     }
 22 
 23     // 当action完成后，向客户端返回结果
 24     ROS_INFO("Dishwasher %d finish working.", goal->dishwasher_id);
 25     as->setSucceeded();
 26 }
 27 
 28 int main(int argc, char** argv)
 29 {
 30     ros::init(argc, argv, "do_dishes_server");
 31     ros::NodeHandle n;
 32 
 33     // 定义一个服务器
 34     Server server(n, "do_dishes", boost::bind(&execute, _1, &server), false);
 35 
 36     // 服务器开始运行
 37     server.start();
 38 
 39     ros::spin();
 40 
 41     return 0;
 42 }

  1 #include <actionlib/client/simple_action_client.h>
  2 #include "learning_communication/DoDishesAction.h"
  3 
  4 typedef actionlib::SimpleActionClient<learning_communication::DoDishesAction> Client;
  5 
  6 // 当action完成后会调用该回调函数一次
  7 void doneCb(const actionlib::SimpleClientGoalState& state,
  8         const learning_communication::DoDishesResultConstPtr& result)
  9 {
 10     ROS_INFO("Yay! The dishes are now clean");
 11     ros::shutdown();
 12 }
 13 
 14 // 当action激活后会调用该回调函数一次
 15 void activeCb()
 16 {
 17     ROS_INFO("Goal just went active");
 18 }
 19 
 20 // 收到feedback后调用该回调函数
 21 void feedbackCb(const learning_communication::DoDishesFeedbackConstPtr& feedback)
 22 {
 23     ROS_INFO(" percent_complete : %f ", feedback->percent_complete);
 24 }
 25 
 26 int main(int argc, char** argv)
 27 {
 28     ros::init(argc, argv, "do_dishes_client");
 29 
 30     // 定义一个客户端
 31     Client client("do_dishes", true);
 32 
 33     // 等待服务器端
 34     ROS_INFO("Waiting for action server to start.");
 35     client.waitForServer();
 36     ROS_INFO("Action server started, sending goal.");
 37 
 38     // 创建一个action的goal
 39     learning_communication::DoDishesGoal goal;
 40     goal.dishwasher_id = 1;
 41 
 42     // 发送action的goal给服务器端，并且设置回调函数
 43     client.sendGoal(goal,  &doneCb, &activeCb, &feedbackCb);
 44 
 45     ros::spin();
 46 
 47     return 0;
 48 }

  1 #include <ros/ros.h>
  2 #include <tf/transform_broadcaster.h>
  3 #include <turtlesim/Pose.h>
  4 
  5 std::string turtle_name;
  6 
  7 void poseCallback(const turtlesim::PoseConstPtr& msg)
  8 {
  9     // tf广播器
 10     static tf::TransformBroadcaster br;
 11 
 12     // 根据乌龟当前的位姿，设置相对于世界坐标系的坐标变换
 13     tf::Transform transform;
 14     transform.setOrigin( tf::Vector3(msg->x, msg->y, 0.0) );
 15     tf::Quaternion q;
 16     q.setRPY(0, 0, msg->theta);
 17     transform.setRotation(q);
 18 
 19     // 发布坐标变换
 20     br.sendTransform(tf::StampedTransform(transform, ros::Time::now(), "world", turtle_name));
 21 }
 22 
 23 int main(int argc, char** argv)
 24 {
 25     // 初始化节点
 26     ros::init(argc, argv, "my_tf_broadcaster");
 27     if (argc != 2)
 28     {
 29         ROS_ERROR("need turtle name as argument");
 30         return -1;
 31     };
 32     turtle_name = argv[1];
 33 
 34     // 订阅乌龟的pose信息
 35     ros::NodeHandle node;
 36     ros::Subscriber sub = node.subscribe(turtle_name+"/pose", 10, &poseCallback);
 37 
 38     ros::spin();
 39 
 40     return 0;
 41 };