古月·ROS入門21講 | 一學(xué)就會的ROS機器人入門教程

ROS核心概念

1. ROS = 通信機制+開發(fā)工具+應(yīng)用功能+生態(tài)系統(tǒng)

2. 通信機制：

   • Node：完成具體功能的進程、獨立運行的可執(zhí)行文件?？捎枚喾N語言py、c++。節(jié)點在系統(tǒng)中的名稱唯一。

   • ROS Master：為節(jié)點提供命名注冊服務(wù)；跟蹤和記錄話題、服務(wù)通信，節(jié)點之間建立連接；提供參數(shù)服務(wù)器，記錄全局變量值。（管理Node）

   • Topic：節(jié)點間用來傳輸數(shù)據(jù)的重要總線；使用publisher/subscriber模型，單向數(shù)據(jù)傳輸有發(fā)布者傳輸?shù)接嗛喺撸粋€話題的訂閱者或者發(fā)布者不唯一。（異步通訊）

     

     Message：具有一定的類型和數(shù)據(jù)結(jié)構(gòu)，包括ROS提供的標(biāo)準(zhǔn)類型和用戶自定義類型；使用編程語言無關(guān)的.msg文件定義。

   • Service：（同步通訊機制）：使用Client/Server模型，客戶端發(fā)送請求數(shù)據(jù)，服務(wù)器完成處理后返回應(yīng)答數(shù)據(jù)；使用編程語言無關(guān)的.srv文件定義。請求一次應(yīng)答一次，帶反饋。一個server，多個client。

3. 參數(shù)Parameter：全局共享字典

   • 可通過網(wǎng)絡(luò)訪問的共享、多變量字典

   • 借點使用此服務(wù)器來存儲和檢索運行時的參數(shù)

   • 存儲靜態(tài)、非二進制配置參數(shù)。

4. 功能包Package：ROS軟件基本單元，包含節(jié)點源碼、配置文件、數(shù)據(jù)定義

ROS命令行

1. roscore：啟動ros master

   rosrun：啟動節(jié)點 TAB鍵查看包含節(jié)點

   rqt_graph：顯示系統(tǒng)計算圖。

   rosnode list：顯示系統(tǒng)中所有節(jié)點

   rosnode info：顯示節(jié)點信息，正在發(fā)布/訂閱的話題

   rostopic：查看話題

   rosmsg show：顯示消息的數(shù)據(jù)結(jié)構(gòu)

   rosservice list：服務(wù)列表

   rossrv show std_srvs/Trigger：查看數(shù)據(jù)結(jié)構(gòu)

   rosrecord -a -O cmd_record ：話題記錄

   rosbag play cmd_record.bag：復(fù)現(xiàn)指令

   //發(fā)布指令讓烏龜移動 -r 10:rate，發(fā)布話題數(shù)據(jù)內(nèi)容的頻率,10hz
   //rostopiv pub /話題名 消息結(jié)構(gòu)（內(nèi)容）數(shù)據(jù)
   //如Twist數(shù)據(jù)結(jié)構(gòu)有l(wèi)inear線速度和angular角速度兩個結(jié)構(gòu)
   rostopic pub -r 10 /turtle1/cmd_vel geometry_msgs/Twist "linear:
   x: 1.0 
   y: 0.0
   z: 0.0
   angular:
   x: 0.0
   y: 0.0
   z: 0.0"
   

工作空間與功能包

1. 工作空間 workspace _ws：一個存放工程開發(fā)相關(guān)文件的文件夾。

   • src：代碼空間 Source Space。 功能包、launch文件
   • build：編譯空間 Build Space。
   • devel：開發(fā)空間 Development Space。編譯生成的可執(zhí)行文件。
   • install：安裝空間 Install Space

2. 在系統(tǒng)中創(chuàng)建工作空間并進行編譯：

   //創(chuàng)建工作空間
   mkdir -p ~/catkin_ws/src
   cd ~/catkin_ws/src
   catkin_init_workspace
   //編譯工作空間
   cd ~/catkin_ws/
   catkin_make
   //設(shè)置環(huán)境變量
   source devel/setup.bash
   //檢查環(huán)境變量
   echo $ROS_PACKAGE_PATH
   

tf::MessageFilter結(jié)構(gòu)：
定義數(shù)據(jù)：TransformListener、message_filters::Subscriber、tf::MessageFilter，用消息的名稱來初始化 message_filters::Subscriber。用 tf、message_filters::Subscriber、目標(biāo)坐標(biāo)系來初始化 tf::MessageFilter，給 tf::MessageFilter 注冊 callback。編寫 callback，并在回調(diào)中完成坐標(biāo)轉(zhuǎn)換。至此完成消息訂閱+坐標(biāo)轉(zhuǎn)換。

訂閱與發(fā)布

發(fā)布者 Publisher

1. 話題模型

//創(chuàng)建功能包
// _ws/src目錄下 catkin_create_pkg 功能包名
catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim

2. 實現(xiàn)發(fā)布
   • 初始化ROS節(jié)點，創(chuàng)建節(jié)點句柄
   • 向ROS Master注冊節(jié)點信息，包括發(fā)布的話題名和話題中的消息類型
   • 創(chuàng)建消息數(shù)據(jù)
   • 按頻率發(fā)布消息

//C++
//創(chuàng)建發(fā)布者代碼 發(fā)布tuetle1/cmd_vel 話題，消息類型geometry_msgs::Twist
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>//消息數(shù)據(jù)類型頭文件

int main (int argc, char **argv)
{
    //ROS節(jié)點初始化 節(jié)點名Velocity_publisher
    ros::init(argc,argv,"velocity_publisher");
    //創(chuàng)建節(jié)點句柄 管理ROS API資源，調(diào)用
    ros::Nodehandle n;
    //創(chuàng)建一個Publisher，發(fā)布名為/turtle1/cmd_vel的topic，消息類型為geometry_msgs::Twist，隊列長度10 
    //  發(fā)布者名 = 句柄.advertise<消息類型>("話題名"，隊列長度)
    ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",10);
    //設(shè)置循環(huán)頻率 不斷publish
    ros:Rate loop_rate(10);
    
    int count = 0;
    while (ros:ok())
    {
        //初始化geometry_msgs::Twist類型消息
        geometry_msgs::Twist vel_msg;
        vel_msg.linear.x = 0.5;
        vel_msg.angular.z = 0.2;
        //發(fā)布消息
        turtle_vel_pub.publish(vel_msg); //由發(fā)布者發(fā)布消息，消息即vel_msg
        ROS_INFO("Publish turtle velocity command[%0.2f m/s, %0.2f rad/s]", vel_msg.linear.x,vel_msg.angular.z);//printf 輸出
        //按照循環(huán)頻率延時
        loop_rate.sleep();
    }
    return 0;
}

#Python 存放于scripts文件夾下，要設(shè)置為可執(zhí)行文件即可用rosrun執(zhí)行 
#!/usr/bin/python是告訴操作系統(tǒng)調(diào)用/usr/bin下的python解釋器來執(zhí)行這個腳本。例如，我們編寫了hello.py腳本，執(zhí)行時需要輸入命令：python hello.py。因為有了這行聲明，就可以直接用./hellp.py 來執(zhí)行了，在這之前需要給腳本設(shè)置可執(zhí)行權(quán)限chmod +x hello.py。
#!/usr/bin/env python是為了防止沒有將python裝在默認的/usr/bin路徑里。當(dāng)系統(tǒng)看到這一行的時候，首先會到env設(shè)置里查找python的安裝路徑，再調(diào)用對應(yīng)路徑下的解釋器程序完成操作，推薦這種寫法。
#2.x版本的py文件一般默認的是ASCII碼，如果文件里有中文，運行時會出現(xiàn)亂碼，注釋是中文也不行。因此，需要把文件編碼類型改為utf-8的類型，輸入# -*- coding:utf-8 -*-之后會把文件編碼強制轉(zhuǎn)換為utf-8。
#3.x版本的py文件的默認編碼為Unicode，也就是說不用進行編碼聲明，可以直接使用中文了。


#!/usr/bin/env python
# -*- coding:utf-8 -*-
#創(chuàng)建發(fā)布者代碼 發(fā)布tuetle1?cmd_vel 話題，消息類型geometry_msgs::Twist
import rospy
from geometry_msgs.msg import Twist
def velocity_publisher():
    #ROS節(jié)點初始化
    rospy,init_node('velocity_publisher',anonymous=True)
    #創(chuàng)建一個Publisher，發(fā)布名為/turtle1/cmd_vel的topic，消息類型為geometry_msgs::Twist，隊列長度10 
    turtle_vel_pub = rospy.Publsiehr('/turtle1/cmd_vel',Twist,queue_size = 10)
    #設(shè)置循環(huán)頻率 不斷publish
    rate = rospy.Rate(10)
    
    while not rospy.is_shutdown():
        # 初始化geometry_msgs::Twist類型消息
        vel_msg = Twist()
        vel_msg.linear.x = 0.5
        vel_msg.angular.z = 0.2
        #發(fā)布消息
        turltle_vel_pub.publish(vel_msg)
        rospy.loginfo("Publish turtle velocity command[%0.2f m/s, %0.2f rad/s]",vel_msg.linear.x, vel_msg.angualr.z)
        #按照循環(huán)頻率延時
        rate.sleep()
        
        if __name__ == '__main__':# 當(dāng)模塊被直接運行時，if...以下代碼塊將被運行，當(dāng)模塊是被導(dǎo)入時，代碼塊不被運行
            try:
                velocity_publisher()
                except rospy.ROSInterruptException:
                    pass

3. 編譯

##在CMakeLists.txt中加入 生成可執(zhí)行文件和路徑
add_executable(velocity_publisher src/velocity_publisher.cpp) 
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})

//工作空間根目錄
cd _ws
catkin_make
source devel/setup.bash //設(shè)置環(huán)境變量或可以把此行代碼寫入~/.bashrc
roscore
rosrun turtlesim turtlesim_node
rosrun learning_topic velocity_publisher

訂閱者 Subscriber

1. 實現(xiàn)訂閱
   • 初始化ROS節(jié)點
   • 訂閱需要的話題
   • 循環(huán)等待話題消息，接收到消息后進入回調(diào)函數(shù)
   • 在回調(diào)函數(shù)中完成消息處理

//C++
//訂閱/turtle1/pose話題，消息類型turtlesim::Pose
#include <ros/ros.h>
#include "turtlesim/Pose.h"

//接收到訂閱的消息后，進入消息回調(diào)函數(shù) 訂閱者不知道什么時候會有消息進入，一旦有消息進入即調(diào)用回調(diào)函數(shù)處理
void poseCallback(const turtlesim::Pose::ConstPtr& msg)//針對消息的常指針
{
    //將接收到的消息打印出來
    ROS_INFO("turtle pose: x:%0.6f, y:%0.6f", msg->x,msg->y);//指針數(shù)據(jù)調(diào)用
}

int main(int argc, char **argv)
{
    //初始化ROS節(jié)點
    ros::init(argc, argv, "pose_subscriber");
    //創(chuàng)建節(jié)點句柄 管理節(jié)點資源
    ros::NodeHandle n;
    //創(chuàng)建一個Subscriber, 訂閱名為/turtle1/pose的topic，注冊回調(diào)函數(shù)poseCallback
    //訂閱者：pose_sub，訂閱話題：/turtle1/pose
    ros::Subscriber pose_sub = n.subscriber("/turtle1/pose", 10, poseCallback);
    //循環(huán)等待回調(diào)函數(shù)
    ros::；spin();//循環(huán)等待 查看隊列，若有消息則調(diào)用poseCallback，否則死循環(huán)；缺少了某個資源，等到資源就緒之后，轉(zhuǎn)換到就緒態(tài)，再等待上cpu執(zhí)行；spin = 等待某個命令 = 直到命令到達 = 等著上cpu執(zhí)行下一步
    return 0;
}

#Python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#訂閱/turtle1/pose話題，消息類型turtlesim::Pose

import rospy
from turtlesim.msg import Pose
def poseCallback(msg):
    rospy.loginfo("Turtle pose: x:%0.6f, y:%0.6f", msg.x, msg.y)
def pose_subscriber():
        # 初始化ROS節(jié)點
        rospy.init_node('pose_subscriber', anonymous=True)
        # 創(chuàng)建一個Subscriber, 訂閱名為/turtle1/pose的topic，注冊回調(diào)函數(shù)poseCallback
        rospy.Subscriber("/turtle1/pose", Pose, poseCallback)
        # 循環(huán)等待回調(diào)函數(shù)
        rospy.spin()
if __name__ == '__main__': # 當(dāng)模塊被直接運行時，if...以下代碼塊將被運行，當(dāng)模塊是被導(dǎo)入時，代碼塊不被運行
    pose_subscriber()
       

2. 編譯

   add_executable(velocity_subscriber src/pose_subscriber.cpp)
   target_link_libraries(pose_subscriber ${catkin_LIBRARIES})
   catkin make 
   
   

話題消息的自定義與使用

1. 消息數(shù)據(jù)類型的自定義

   • 創(chuàng)建msg文件并定義

   • 在package.xml中添加功能包依賴

     編譯依賴 功能包message_generation動態(tài)產(chǎn)生message
     <build_depend>message_generation</build_depend>
     執(zhí)行依賴
     <exec_depend>message_runtime</exec_depend>
     

   • 在CMakeLists.txt添加編譯選項

     find_package( ...... message_generation)
     add_message_files(FILES Person.msg) //定義接口
     generate_messages(DEPENDENCIES std_msgs) //接口依賴庫
     catkin_package( ...... message_runtime) //運行依賴
     

   • 編譯生成可執(zhí)行文件，將在devel中生成.h頭文件。使用時需引用頭文件自己定義并編譯的.h。

//定義一個人的類型的消息Person.msg
//一般在msg文件夾下
string name 
uint8 sex
uint8 age
//宏定義    
uint8 unknown = 0
uint8 male = 1
uint8 female = 2

依賴添加多一項add_dependcies

add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)
add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messsages_cpp)

2. 關(guān)閉roscore不影響已經(jīng)建立聯(lián)系的Publisher和Subscriber

服務(wù)與客戶端

客戶端 Client

1. 話題模型：Client端 請求節(jié)點，發(fā)布產(chǎn)生烏龜?shù)膔equest，server收到后產(chǎn)生response。

   • 創(chuàng)建功能包

     //在工作空間的src目錄下
     cd ~/catkin_ws/src
     catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim
     

2. 實現(xiàn)一個客戶端

   • 初始化ROS節(jié)點
   • 創(chuàng)建Client實例
   • 發(fā)布服務(wù)請求數(shù)據(jù)
   • 等待Server處理之后的應(yīng)答結(jié)果

 /**
  * 該例程將請求/spawn服務(wù)，服務(wù)數(shù)據(jù)類型turtlesim::Spawn
  */
 #include <ros/ros.h>
 #include <turtlesim/Spawn.h> //數(shù)據(jù)類型頭文件
 
 int main(int argc, char** argv)
 {
     // 初始化ROS節(jié)點
 	ros::init(argc, argv, "turtle_spawn");
     // 創(chuàng)建節(jié)點句柄
 	ros::NodeHandle node;
     // 發(fā)現(xiàn)/spawn服務(wù)后，創(chuàng)建一個服務(wù)客戶端，連接名為/spawn的service
 	ros::service::waitForService("/spawn"); //查詢系統(tǒng)里是否有/spawn服務(wù)，存在才能請求
     //創(chuàng)建名為add_turtle的客戶端，請求名為/spawn、數(shù)據(jù)類型為turtle::Spawn的服務(wù)
 	ros::ServiceClient add_turtle = node.serviceClient<turtlesim::Spawn>("/spawn");
     // 初始化turtlesim::Spawn的請求數(shù)據(jù)
 	turtlesim::Spawn srv;//定義請求數(shù)據(jù)結(jié)構(gòu)為turtlesim::Spawn的變量srv
 	srv.request.x = 2.0;
 	srv.request.y = 2.0;
 	srv.request.name = "turtle2";
     // 請求服務(wù)調(diào)用
 	ROS_INFO("Call service to spwan turtle[x:%0.6f, y:%0.6f, name:%s]", 
 			 srv.request.x, srv.request.y, srv.request.name.c_str());
 
 	add_turtle.call(srv);//請求數(shù)據(jù)，阻塞型函數(shù)，一直等待反饋
 	// 顯示服務(wù)調(diào)用結(jié)果
 	ROS_INFO("Spwan turtle successfully [name:%s]", srv.response.name.c_str());//c_str()返回當(dāng)前字符串的首字符地址
 	return 0;
 };
 

#python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 該例程將請求/spawn服務(wù)，服務(wù)數(shù)據(jù)類型turtlesim::Spawn
import sys
import rospy
from turtlesim.srv import Spawn

def turtle_spawn():
	# ROS節(jié)點初始化
    rospy.init_node('turtle_spawn')
	# 發(fā)現(xiàn)/spawn服務(wù)后，創(chuàng)建一個服務(wù)客戶端，連接名為/spawn的service
    rospy.wait_for_service('/spawn')
    try:
        add_turtle = rospy.ServiceProxy('/spawn', Spawn)
		# 請求服務(wù)調(diào)用，輸入請求數(shù)據(jù)
        response = add_turtle(2.0, 2.0, 0.0, "turtle2")#x,y,theta,name
        return response.name
    except rospy.ServiceException, e:
        print "Service call failed: %s"%e
if __name__ == "__main__":
	#服務(wù)調(diào)用并顯示調(diào)用結(jié)果
    print "Spwan turtle successfully [name:%s]" %(turtle_spawn())

3. 編譯

   add_executable(turtle_spawn src/turtle_spawn.cpp)
   target_link_libraries(turtle_spawn ${catkin_LIBRARIES})
   ##工作空間根目錄下
   catkin_make
   source devel/setup.bash
   roscore
   rosrun turtlesim turtlesim_node
   rosrun learning_service turtle_spawn
   

服務(wù)端 Server

1. 服務(wù)端server：給海龜發(fā)指令，接受request決定是不是要給海龜發(fā)指令。包含server和topic發(fā)布。

   觸發(fā)信號Trigger 可用rossrv show std_srvs/Trigger查看數(shù)據(jù)結(jié)構(gòu)

   • 初始化ROS節(jié)點
   • 創(chuàng)建Server實例
   • 循環(huán)等待服務(wù)請求，進入回調(diào)函數(shù)（已注冊）
   • 在回調(diào)函數(shù)中完成服務(wù)功能的處理，并反饋應(yīng)答數(shù)據(jù)

   /**
    * 該例程將執(zhí)行/turtle_command服務(wù)，服務(wù)數(shù)據(jù)類型std_srvs/Trigger
    */
   #include <ros/ros.h>
   #include <geometry_msgs/Twist.h> //topic頭文件
   #include <std_srvs/Trigger.h> //server頭文件
   
   ros::Publisher turtle_vel_pub; //全局publisher
   bool pubCommand = false; //標(biāo)志位默認停止false
   // service回調(diào)函數(shù)，輸入?yún)?shù)req，輸出參數(shù)res
   bool commandCallback(std_srvs::Trigger::Request  &req,
            			std_srvs::Trigger::Response &res)
   {
   	pubCommand = !pubCommand;//標(biāo)志位取反 開關(guān)
       // 顯示請求數(shù)據(jù)
       ROS_INFO("Publish turtle velocity command [%s]", pubCommand==true?"Yes":"No");
   	// 設(shè)置反饋數(shù)據(jù) 數(shù)據(jù)結(jié)構(gòu)來自于內(nèi)置庫的Trigger
   	res.success = true;
   	res.message = "Change turtle command state!";
       return true;
   }
   
   int main(int argc, char **argv)
   {
       // ROS節(jié)點初始化
       ros::init(argc, argv, "turtle_command_server");
       // 創(chuàng)建節(jié)點句柄
       ros::NodeHandle n;
       // 創(chuàng)建一個名為/turtle_command的server，注冊回調(diào)函數(shù)commandCallback。收到request后，立刻進入回調(diào)函數(shù)
       ros::ServiceServer command_service = n.advertiseService("/turtle_command", commandCallback);
   	// 創(chuàng)建一個Publisher，發(fā)布名為/turtle1/cmd_vel的topic，消息類型為geometry_msgs::Twist，隊列長度10。發(fā)送速度指令
   	turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 10);
       // 循環(huán)等待回調(diào)函數(shù)
       ROS_INFO("Ready to receive turtle command.");
   	// 設(shè)置循環(huán)的頻率
   	ros::Rate loop_rate(10);
       
   	while(ros::ok())
   	{
   		// 查看一次回調(diào)函數(shù)隊列 有數(shù)據(jù)隊列就進入回調(diào)函數(shù)，沒有就跳出繼續(xù)執(zhí)行程序
       	ros::spinOnce();
   		// 如果標(biāo)志為true，則發(fā)布速度指令
   		if(pubCommand)
   		{
   			geometry_msgs::Twist vel_msg;
   			vel_msg.linear.x = 0.5;
   			vel_msg.angular.z = 0.2;
   			turtle_vel_pub.publish(vel_msg);
   		}
   		//按照循環(huán)頻率延時
   	    loop_rate.sleep();
   	}
       return 0;
   }
   

   #Python
   #!/usr/bin/env python
   # -*- coding: utf-8 -*-
   # 該例程將執(zhí)行/turtle_command服務(wù)，服務(wù)數(shù)據(jù)類型std_srvs/Trigger
   import rospy
   import thread,time
   from geometry_msgs.msg import Twist
   from std_srvs.srv import Trigger, TriggerResponse
   
   pubCommand = False;
   turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)
   def command_thread():	#線程，判斷標(biāo)志位；python只有spin沒有spinonce
   	while True:
   		if pubCommand:
   			vel_msg = Twist()
   			vel_msg.linear.x = 0.5
   			vel_msg.angular.z = 0.2
   			turtle_vel_pub.publish(vel_msg)
   		time.sleep(0.1)
   
   def commandCallback(req):
   	global pubCommand
   	pubCommand = bool(1-pubCommand)
   	# 顯示請求數(shù)據(jù)
   	rospy.loginfo("Publish turtle velocity command![%d]", pubCommand)
   	# 反饋數(shù)據(jù)
   	return TriggerResponse(1, "Change turtle command state!")
   def turtle_command_server():
   	# ROS節(jié)點初始化
       rospy.init_node('turtle_command_server')
   	# 創(chuàng)建一個名為/turtle_command的server，注冊回調(diào)函數(shù)commandCallback
       s = rospy.Service('/turtle_command', Trigger, commandCallback)
   	# 循環(huán)等待回調(diào)函數(shù)
       print "Ready to receive turtle command."
       thread.start_new_thread(command_thread, ())
       rospy.spin()#循環(huán)直到收到數(shù)據(jù)，進入回調(diào)函數(shù) 
   if __name__ == "__main__":
       turtle_command_server()
   

2. 編譯

   add_executable(turtle_command_server src/turtle_command_server.cpp)
   target_link_libraries(turtle_command_server ${catkin_LIBRARIES})
   
   cd ~/..._ws
   catkin_make
   source devel/setup.bash
   roscore
   rosrun turtlesim turtlesim_node
   rosrun learning_service turtle_command_server
   rosservice call /turtle_command "{}"
   

服務(wù)數(shù)據(jù)的自定義

1. 服務(wù)模型

• 自定義服務(wù)數(shù)據(jù) 創(chuàng)建新文件srv下，創(chuàng)建Person.srv文件并寫入

string name 
uint8 age
uint8 sex

uint8 unknown = 0
uint8 male = 1
uint8 female = 2
---   //以上是request數(shù)據(jù)，以下是response數(shù)據(jù)
string result

• 在package.xml中添加功能包依賴

  <build_depend>message_generation</build_depend>
  <exec_depend>message_runtime</exec_depend>
  

• 在CMakeLists.txt文件中添加編譯選項

  find_package( .... message_generation)#加功能包
  add_service_files(FILES Person.srv)#根據(jù)哪一個srv文件創(chuàng)建頭文件
  generate_messages(DEPENDENCIES std_msgs)#根據(jù)文件定義產(chǎn)生頭文件
  catkin_package( .... message_runtime)#添加編譯依賴
  #工作空間根目錄下
  catkin_make#成功后在include下會找到對應(yīng)的頭文件 
  

2. 客戶端

   /**
    * 該例程將請求/show_person服務(wù)，服務(wù)數(shù)據(jù)類型learning_service::Person
    */
   #include <ros/ros.h>
   #include "learning_service/Person.h"
   
   int main(int argc, char** argv)
   {
       // 初始化ROS節(jié)點
   	ros::init(argc, argv, "person_client");
       // 創(chuàng)建節(jié)點句柄
   	ros::NodeHandle node;
       // 發(fā)現(xiàn)/spawn服務(wù)后，創(chuàng)建一個服務(wù)客戶端，連接名為/spawn的service
   	ros::service::waitForService("/show_person");
   	ros::ServiceClient person_client = node.serviceClient<learning_service::Person>("/show_person");
       // 初始化learning_service::Person的請求數(shù)據(jù)
   	learning_service::Person srv;
   	srv.request.name = "Tom";
   	srv.request.age  = 20;
   	srv.request.sex  = learning_service::Person::Request::male;
       // 請求服務(wù)調(diào)用
   	ROS_INFO("Call service to show person[name:%s, age:%d, sex:%d]", 
   			 srv.request.name.c_str(), srv.request.age, srv.request.sex);
   
   	person_client.call(srv);
   	// 顯示服務(wù)調(diào)用結(jié)果
   	ROS_INFO("Show person result : %s", srv.response.result.c_str());
   	return 0;
   };
   

   3. 服務(wù)端

      /**
       * 該例程將執(zhí)行/show_person服務(wù)，服務(wù)數(shù)據(jù)類型learning_service::Person
       */
      #include <ros/ros.h>
      #include "learning_service/Person.h"
      
      // service回調(diào)函數(shù)，輸入?yún)?shù)req，輸出參數(shù)res
      bool personCallback(learning_service::Person::Request  &req,
               			learning_service::Person::Response &res)
      {
          // 顯示請求數(shù)據(jù)
          ROS_INFO("Person: name:%s  age:%d  sex:%d", req.name.c_str(), req.age, req.sex);
      	// 設(shè)置反饋數(shù)據(jù)
      	res.result = "OK";
          return true;
      }
      int main(int argc, char **argv)
      {
          // ROS節(jié)點初始化
          ros::init(argc, argv, "person_server");
          // 創(chuàng)建節(jié)點句柄
          ros::NodeHandle n;
          // 創(chuàng)建一個名為/show_person的server，注冊回調(diào)函數(shù)personCallback
          ros::ServiceServer person_service = n.advertiseService("/show_person", personCallback);
          // 循環(huán)等待回調(diào)函數(shù)
          ROS_INFO("Ready to show person informtion.");
          ros::spin();
          return 0;
      }
      

   4. 編譯

      add_executable(person_server src/person_server.cpp)
      target_link_libraries(person_servr ${catkin_LIBRARIES})
      add_dependencies(person_server ${PROJECT_NAME}_gencpp) #動態(tài)生成的cpp文件
      
      add_executable(person_client src/person_client.cpp)
      target_link-libraries(person_client ${catkin_LIBRARIES})
      add_dependencies(person_client ${PROJECT_NAME}_gencpp)
      
      # 工作空間根目錄下
      catkin_make
      source devel/setup.bash #可寫入系統(tǒng)環(huán)境變量bashrc，否則每次都要輸入
      roscore 
      rosrun learning_service person_server
      rosrun learning_service person_client
      

參數(shù)的使用與編程

1. 參數(shù)模型：各個節(jié)點可以全局訪問參數(shù)服務(wù)器。參數(shù)文件.yaml

• 創(chuàng)建功能包：

  cd ~/catkin_ws/src
  catkin_create_pkg learning_parameter roscpp rospy std_srvs
  

• 參數(shù)命令行 修改參數(shù)后請求服務(wù)才能生效

  //顯示參數(shù)列表
  rosparam list
  //獲取參數(shù)
  rosparam get 
  //修改參數(shù)值
  rosparam set 變量名 變量值
  //保存參數(shù)到文件于當(dāng)前路徑下
  rosparam dump 文件名.yaml 
  //從文件讀取參數(shù)
  rosparam load 文件名.yaml
  //刪除參數(shù)
  rosparam delete 參數(shù)名
  

2. 程序?qū)崿F(xiàn)參數(shù)操作

   • 初始化ROS節(jié)點
   • get函數(shù)獲取參數(shù)
   • set函數(shù)設(shè)置參數(shù)

   /**
    * 該例程設(shè)置/讀取海龜例程中的參數(shù)
    */
   #include <string>
   #include <ros/ros.h>
   #include <std_srvs/Empty.h>
   
   int main(int argc, char **argv)
   {
   	int red, green, blue;
       // ROS節(jié)點初始化
       ros::init(argc, argv, "parameter_config");
       // 創(chuàng)建節(jié)點句柄
       ros::NodeHandle node;
       // 讀取背景顏色參數(shù) get("變量名"，參數(shù)值存儲到哪個變量中)
   	ros::param::get("/background_r", red);
   	ros::param::get("/background_g", green);
   	ros::param::get("/background_b", blue);
   	ROS_INFO("Get Backgroud Color[%d, %d, %d]", red, green, blue);
   	// 設(shè)置背景顏色參數(shù)
   	ros::param::set("/background_r", 255);
   	ros::param::set("/background_g", 255);
   	ros::param::set("/background_b", 255);
   	ROS_INFO("Set Backgroud Color[255, 255, 255]");
       // 讀取背景顏色參數(shù)
   	ros::param::get("/background_r", red);
   	ros::param::get("/background_g", green);
   	ros::param::get("/background_b", blue);
   	ROS_INFO("Re-get Backgroud Color[%d, %d, %d]", red, green, blue);
   	// 調(diào)用服務(wù)，刷新背景顏色
   	ros::service::waitForService("/clear");
   	ros::ServiceClient clear_background = node.serviceClient<std_srvs::Empty>("/clear");
   	std_srvs::Empty srv;
   	clear_background.call(srv);
   	sleep(1);
       return 0;
   }
   

   • 編譯

     add_executable(parameter_config src/parameter_config.cpp)
     target_link_libraries(parameter_config ${catkin_LIBRARIES})
     #工作空間下
     catkin_make
     source devel/setup.absh
     roscore
     rosrun turtlesim turtlesim_node
     rosrun learning_parameter parameter_config
     

ROS中的坐標(biāo)管理系統(tǒng) TF

1. 坐標(biāo)變換工具TF：查詢兩坐標(biāo)系之間的變換關(guān)系。通過廣播和監(jiān)聽實現(xiàn)。

sudo apt-get install ros-melodic-turtlle-tf //ros-版本-功能包
roslaunch turtle_tf turtle_tf_demo.launch //.launch啟動腳本文件中的諸多節(jié)點
rosrun turtlesim turtle_teleop_key
rosrun tf view_frames //tf功能包提供的查看系統(tǒng)中所有tf關(guān)系

World坐標(biāo)系：全局坐標(biāo)系，不動。

rosrun tf tf_echo 坐標(biāo)系1 坐標(biāo)系2   //查詢坐標(biāo)關(guān)系
//Translation：平移，旋轉(zhuǎn)：四元數(shù)/歐拉角RPY

TF基本的數(shù)據(jù)類型（Quaternion, Vector, Point, Pose, Transform）

TF坐標(biāo)系廣播與監(jiān)聽

1. 創(chuàng)建功能包

   $ cd ~/catkin_ws/src
   $ catkin_create_pkg learning_tf roscpp rospy tf turtlesim
   

2. TF廣播器：廣播坐標(biāo)系之間的關(guān)系

   • 定義TF廣播器(TransformBroadcaster)

   • 創(chuàng)建坐標(biāo)變換值

   • 發(fā)布坐標(biāo)變換(sendTransform)

     /**
      * 該例程產(chǎn)生tf數(shù)據(jù)，并計算、發(fā)布turtle2的速度指令
      */
     #include <ros/ros.h>
     #include <tf/transform_broadcaster.h>
     #include <turtlesim/Pose.h>
     std::string turtle_name;
     
     void poseCallback(const turtlesim::PoseConstPtr& msg)
     {
     	// 創(chuàng)建tf的廣播器
     	static tf::TransformBroadcaster br;
     	// 初始化tf數(shù)據(jù)
     	tf::Transform transform; //4x4矩陣 T
     	transform.setOrigin( tf::Vector3(msg->x, msg->y, 0.0) ); //平移參數(shù)
     	tf::Quaternion q; //旋轉(zhuǎn)
     	q.setRPY(0, 0, msg->theta); //姿態(tài)變化
     	transform.setRotation(q);
     	// 廣播world與海龜坐標(biāo)系之間的tf數(shù)據(jù) StampedTransform(變換矩陣，時間戳，坐標(biāo)系1，坐標(biāo)系2)
     	br.sendTransform(tf::StampedTransform(transform, ros::Time::now(), "world", turtle_name));
     }
     
     int main(int argc, char** argv)
     {
         // 初始化ROS節(jié)點
     	ros::init(argc, argv, "my_tf_broadcaster");
     	// 輸入?yún)?shù)作為海龜?shù)拿?	if (argc != 2)
     	{
     		ROS_ERROR("need turtle name as argument"); 
     		return -1;
     	}
     	turtle_name = argv[1];
     	// 訂閱海龜?shù)奈蛔嗽掝}
     	ros::NodeHandle node;
     	ros::Subscriber sub = node.subscribe(turtle_name+"/pose", 10, &poseCallback);
         // 循環(huán)等待回調(diào)函數(shù)
     	ros::spin();
     	return 0;
     };
     

3. TF監(jiān)聽器：獲取任意兩個坐標(biāo)系之間關(guān)系

   • 定義TF監(jiān)聽器 TransformListener

   • 查找坐標(biāo)變換 waitForTransform、lookupTransform

     /**
      * 該例程監(jiān)聽tf數(shù)據(jù)，并計算、發(fā)布turtle2的速度指令
      */
     #include <ros/ros.h>
     #include <tf/transform_listener.h>
     #include <geometry_msgs/Twist.h>
     #include <turtlesim/Spawn.h>
     
     int main(int argc, char** argv)
     {
     	// 初始化ROS節(jié)點
     	ros::init(argc, argv, "my_tf_listener");
         // 創(chuàng)建節(jié)點句柄
     	ros::NodeHandle node;
     	// 請求產(chǎn)生turtle2
     	ros::service::waitForService("/spawn");
     	ros::ServiceClient add_turtle = node.serviceClient<turtlesim::Spawn>("/spawn");
     	turtlesim::Spawn srv;
     	add_turtle.call(srv);
     	// 創(chuàng)建發(fā)布turtle2速度控制指令的發(fā)布者
     	ros::Publisher turtle_vel = node.advertise<geometry_msgs::Twist>("/turtle2/cmd_vel", 10);
     	// 創(chuàng)建tf的監(jiān)聽器
     	tf::TransformListener listener;
     	ros::Rate rate(10.0);
     	while (node.ok())
     	{
     		// 獲取turtle1與turtle2坐標(biāo)系之間的tf數(shù)據(jù)
     		tf::StampedTransform transform;//保存平移旋轉(zhuǎn)關(guān)系
     		try
     		{
                  // waitForTransform(坐標(biāo)系1，坐坐標(biāo)系2，查詢（當(dāng)前）時間，等待時間)如果存在關(guān)系則程序往下走
     			listener.waitForTransform("/turtle2", "/turtle1", ros::Time(0), ros::Duration(3.0));
                  // lookupTransform(坐標(biāo)系1，坐標(biāo)系2，查詢時間，結(jié)果保存于)
     			listener.lookupTransform("/turtle2", "/turtle1", ros::Time(0), transform);
     		}
     		catch (tf::TransformException &ex) 
     		{
     			ROS_ERROR("%s",ex.what());
     			ros::Duration(1.0).sleep();
     			continue;
     		}
     		// 根據(jù)turtle1與turtle2坐標(biāo)系之間的位置關(guān)系，發(fā)布turtle2的速度控制指令
     		geometry_msgs::Twist vel_msg;
     		vel_msg.angular.z = 4.0 * atan2(transform.getOrigin().y(),
     				                        transform.getOrigin().x());
     		vel_msg.linear.x = 0.5 * sqrt(pow(transform.getOrigin().x(), 2) +
     				                      pow(transform.getOrigin().y(), 2));
     		turtle_vel.publish(vel_msg);
     		rate.sleep();
     	}
     	return 0;
     };
     

4. 編譯

   • 編譯成可執(zhí)行文件 add_executable

   • 添加鏈接 target_link_libraries

     $ cd ~/catkin_ws
     $ catkin_make
     $ source devel/setup.bash
     $ roscore
     $ rosrun turtlesim turtlesim_node
     $ rosrun learning_tf turtle_tf_broadcaster __name:=turtle1_tf_broadcaster /turtle1 #重映射，重新命名
     $ rosrun learning_tf turtle_tf_broadcaster __name:=turtle2_tf_broadcaster /turtle2
     $ rosrun learning_tf turtle_tf_listener
     $ rosrun turtlesim turtle_teleop_key
     

launch啟動文件的使用方法

1. launch文件：通過XML文件實現(xiàn)多節(jié)點的配置和啟動?？焖賳庸?jié)點，不用打開終端輸入。（自動啟動ROS Master）

   常用語法：

   <launch> launch文件中的根元素采用<launch>標(biāo)簽定義</launch>
   <node> 啟動節(jié)點
      <node pkg="package-name" type="executable-name" name="node-name" />
            pkg：節(jié)點所在功能包名稱
            type：節(jié)點的可執(zhí)行文件名稱
            name：節(jié)點運行時的名稱 會取代文件中初始化的節(jié)點名，同文件多命名以實現(xiàn)該程序的多次利用
            output：節(jié)點是否要打印日志信息
            respawn：如果節(jié)點掛掉是否要進行重啟
            required：某個節(jié)點是否必須要啟動
            ns：namespace，避免命名沖突
            args：輸入?yún)?shù)
       </node>
   <param> 設(shè)置ROS運行中的一個參數(shù)，存儲在參數(shù)服務(wù)器中
       <param name="output_frame" value="odom"/>
       name：參數(shù)名
       value：參數(shù)值
       </param>
       
   <rosparam>加載參數(shù)文件中的多個參數(shù)
       <rosparam file="params.yaml" command="load" ns="params" />
       </rosparam>
       
   <arg> launch文件內(nèi)部的局部變量，僅限于launch文件使用
       <arg name="arg-name" default="arg-value" />
       name：參數(shù)名
       value：參數(shù)值
       </arg>
       調(diào)用
       <!--
       <param name="foo" value=$(arg arg-name)" />
       <node name="node" pkg="package" type="type" args="$(arg arg-name)" />  
          -->
   <remap>重映射ROS計算圖資源的命名
       <remap from="/turtlebot/cmd_vel" to="/cmd_vel" />
       from :原命名
       to：映射之后的命名
           </param>
       
   <include>包含其他launch文件，類似于C語言中的頭文件包含
       <include flle="$(dirname)/other.launch" />
       file：包含的其他launch文件路徑
       </include>
   

2. 示例：開啟兩個node節(jié)點

   <launch>
       <node pkg="learning_topic" type="person_subscriber" name="talker" output="screen" />
       <node pkg="learning_topic" type="person_publisher" name="listener" output="screen" /> 
   </launch>
   開啟功能包下的可執(zhí)行文件的某某節(jié)點并于終端輸出日志
   

   開啟launch

   $ roslaunch 功能包 .launch
   

3. 示例：配置參數(shù)

   <launch>
   	<param name="/turtle_number"   value="2"/> 
       <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node">
   		<param name="turtle_name1"   value="Tom"/>
   		<param name="turtle_name2"   value="Jerry"/> 
   		<rosparam file="$(find learning_launch)/config/param.yaml" command="load"/>
   	</node>
       <node pkg="turtlesim" type="turtle_teleop_key" name="turtle_teleop_key" output="screen"/>
   </launch>
   $(find learning_launch)系統(tǒng)搜索功能包
   

4. 示例：啟動海龜跟隨

    <launch>
       <!-- Turtlesim Node-->
       <node pkg="turtlesim" type="turtlesim_node" name="sim"/>
       <node pkg="turtlesim" type="turtle_teleop_key" name="teleop" output="screen"/>
       <node pkg="learning_tf" type="turtle_tf_broadcaster" args="/turtle1" name="turtle1_tf_broadcaster" />
       <node pkg="learning_tf" type="turtle_tf_broadcaster" args="/turtle2" name="turtle2_tf_broadcaster" />
       <node pkg="learning_tf" type="turtle_tf_listener" name="listener" />
     </launch>
   

5. 示例：重映射以及include

   <launch>
   	<include file="$(find learning_launch)/launch/simple.launch" /> 啟動這個launch文件所有內(nèi)容
       <node pkg="turtlesim" type="turtlesim_node" name="turtlesim_node">
   		<remap from="/turtle1/cmd_vel" to="/cmd_vel"/>
   	</node>
   </launch>
   

可視化工具

1. Qt工具箱

   • rqt_console日志輸出工具
   • rqt_graph計算圖可視化工具
   • rqt_plot數(shù)據(jù)繪圖工具
   • rqt_image_view圖像渲染工具
   • rqt工具箱

2. Rviz：數(shù)據(jù)顯示平臺

   rosrun rviz rviz
   

3. Gazebo：三維仿真平臺文章來源地址http://www.zghlxwxcb.cn/news/detail-484191.html

到了這里，關(guān)于ROS入門21講 | ROS機器人入門教程 【簡明筆記】的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！