ubuntu中配置ROS详细教程

 
<launch>  <group ns="turtlesim1">  <node pkg="turtlesim" name="sim" type="turtlesim_node"/>  </group>  <group ns="turtlesim2">  <node pkg="turtlesim" name="sim" type="turtlesim_node"/>  </group>  <node pkg="turtlesim" name="mimic" type="mimic">  <remap from="input" to="turtlesim1/turtle1"/>  <remap from="output" to="turtlesim2/turtle1"/>  </node> </launch>

启动launch文件 roslaunch beginner_tutorials turtlemimic.launch

让两个乌龟转圈 rostopic pub /turtlesim1/turtle1/cmd_vel geometry_msgs/Twist -r 1 -- ‘[2.0, 0.0, 0.0]‘ ‘[0.0, 0.0, -1.8]‘

10.创建ROS消息和服务

 使用msg消息 cd ~/catkin_ws/src/beginner_tutorials  mkdir msg

 echo "int64 num" > msg/Num.msg
给package.xml增加语句 cd catkin_ws/src/beginner_tutorials
 gedit package.xml
复制进去package.xml的内容(蓝色字体不要动) 
 <build_depend>message_generation</build_depend>
  <run_depend>message_runtime</run_depend>
更改CMakeLists.txt里面的东西 cd catkin_ws/src/beginner_tutorials
 gedit CMakeLists.txt
找到这个模块 
# add_message_files(
#   FILES
#   Message1.msg
#   Message2.msg
# )
然后更改为这样  
add_message_files(
  FILES
  Num.msg
)
检查ROS能否识别消息  cd catkin_ws
 source devel/setup.bash
 rosmsg show beginner_tutorials/Num
使用服务roscd beginner_tutorials  mkdir srv （创建服务）  roscp rospy_tutorials AddTwoInts.srv srv/AddTwoInts.srv（给服务复制文件）
修改CMakeList.txt文件
找到这个模块
 
# add_service_files(
#   FILES
#   Service1.srv
#   Service2.srv
# )
更改为
 
add_service_files(
  FILES
  AddTwoInts.srv
)
把前面的find_package也改一下，增加message_generation
使用服务：
查看ROS能否识别服务 rossrv show beginner_tutorials/AddTwoInts
更改CMakeLists.txt里面的东西
找到这个模块
 
# generate_messages(
#   DEPENDENCIES
# #  std_msgs  # Or other packages containing msgs
# )
更改为
 
generate_messages(
  DEPENDENCIES
  std_msgs
)
重新编译乌龟包
cd ../..
catkin_make
11.编写简单的消息发不起和订阅器
cd ~/catkin_ws/src/beginner_tutorials/src
创建文件 gedit 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; }
创建listener,cpp文件 gedit listener.cpp  并粘贴下面代码
 
 
#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; }
编译节点 
在CMakeLists.txt增加几条语句
cd ..
gedit CMakeLists.txt 
在最后增加几条语句
 
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_dependencies(talker ${catkin_EXPORTED_TARGETS})
add_executable(listener src/listener.cpp)target_link_libraries(listener ${catkin_LIBRARIES})
编译（在工作空间下 cd catkin_ws）
catkin_make
12.测试消息发布器和订阅器
启动发布器 roscore
 cd catkin_ws
         source ./devel/setup.bash
         rosrun beginner_tutorials talker
你会看到
在新的终端 cd catkin_ws
          source devel/setup.bash
         rosrun beginner_tutorials listener 
会看到
 13.编写简单的Service和Client 
编写service节点 cd ~/catkin_ws/src/beginner_tutorials

复制代码 cd src
       gedit add_two_ints_server.cpp
代码(代码需要自己看懂) 
 
#include "ros/ros.h" #include "beginner_tutorials/AddTwoInts.h" bool add(beginner_tutorials::AddTwoInts::Request &req,  beginner_tutorials::AddTwoInts::Response &res) {  res.sum = req.a + req.b;  ROS_INFO("request: x=%ld, y=%ld", (long int)req.a, (long int)req.b);  ROS_INFO("sending back response: [%ld]", (long int)res.sum);  return true; } int main(int argc, char **argv) {  ros::init(argc, argv, "add_two_ints_server");  ros::NodeHandle n;  ros::ServiceServer service = n.advertiseService("add_two_ints", add);  ROS_INFO("Ready to add two ints.");  ros::spin();  return 0; }
 
编写client节点
gedit add_two_ints_client.cpp
复制代码
 
#include "ros/ros.h" #include "beginner_tutorials/AddTwoInts.h" #include <cstdlib> int main(int argc, char **argv) {  ros::init(argc, argv, "add_two_ints_client");  if (argc != 3)  {  ROS_INFO("usage: add_two_ints_client X Y");  return 1;  }  ros::NodeHandle n;  ros::ServiceClient client = n.serviceClient<beginner_tutorials::AddTwoInts>("add_two_ints");  beginner_tutorials::AddTwoInts srv;  srv.request.a = atoll(argv[1]);  srv.request.b = atoll(argv[2]);  if (client.call(srv))  {  ROS_INFO("Sum: %ld", (long int)srv.response.sum);  }  else  {  ROS_ERROR("Failed to call service add_two_ints");  return 1;  }  return 0; }
编译节点 gedit CMakeLists.txt
在末尾增加
 
add_executable(add_two_ints_server src/add_two_ints_server.cpp) target_link_libraries(add_two_ints_server ${catkin_LIBRARIES}) add_dependencies(add_two_ints_server beginner_tutorials_gencpp) add_executable(add_two_ints_client src/add_two_ints_client.cpp) target_link_libraries(add_two_ints_client ${catkin_LIBRARIES}) add_dependencies(add_two_ints_client beginner_tutorials_gencpp)

 
开始编译 cd catkin_ws
 catkin_make
14.测试简单的Service和Client
 运行service命令 cd catkin_ws
 source devel/setup.bash
 rosrun beginner_tutorials add_two_ints_server 
运行Client命令 cd catkin_ws
 source devel/setup.bash
 rosrun beginner_tutorials add_two_ints_client 1 3