文章目錄

• 1. 簡介
• • 1.1. 系統架構
  • 1.2. 文件系統
  • 1.3. 計算圖
  • 1.4. Source
  • 1.5. helloworld
  • • 1.5.1. C++ 實現
    • 1.5.2. Python 實現
• 2. 通信
• • 2.1. 話題通信
  • • 2.1.1. 簡介
    • 2.1.2. 理論模型
    • 2.1.3. C++ 實現
    • 2.1.4. Python 實現
    • 2.1.5. spinOnce 和 spin
    • 2.1.6. 話題同步
    • 2.1.7. 自定義 msg
    • 2.1.8. 自定義變長 msg
  • 2.2. 服務通信
  • • 2.2.1. 簡介
    • 2.2.2. 理論模型
    • 2.2.3. 話題和服務
    • 2.2.4. 自定義 srv
    • 2.2.5. C++ 實現
    • 2.2.6. Python 實現
  • 2.3. 參數服務器
• 3. 運行
• • 3.1. launch
  • • 3.1.1. 運行
    • 3.1.2. 標簽
    • • 3.1.2.1. launch
      • 3.1.2.2. node
      • 3.1.2.3. include
      • 3.1.2.4. remap
      • 3.1.2.5. param
      • 3.1.2.6. rosparam
      • 3.1.2.7. arg
      • 3.1.2.8. group

1. 簡介

ROS 全稱為 Robot Operating System (機器人操作系統)

• ROS 是適用于機器人的開源元操作系統
• ROS 集成了大量的工具，庫，協議，提供類似 OS 所提供的功能，簡化對機器人的控制
• ROS 還提供了用于在多臺計算機上獲取，構建，編寫和運行代碼的工具和庫，ROS 在某些方面類似于“機器人框架”
• ROS 設計者將 ROS 表述為 “ROS = Plumbing + Tools + Capabilities + Ecosystem”，即 ROS 是通訊機制、工具軟件包、機器人高層技能以及機器人生態系統的集合體

1.1. 系統架構

ROS 的系統架構可分為三層

OS 層，也即經典意義的操作系統。ROS 只是元操作系統，需要依托真正意義的操作系統，目前兼容性最好的是 Linux 的 Ubuntu，Mac、Windows 也支持 ROS 的較新版本

中間層。是 ROS 封裝的關于機器人開發的中間件，比如:

• 基于 TCP/UDP 繼續封裝的 TCPROS/UDPROS 通信系統
• 用于進程間通信 Nodelet，為數據的實時性傳輸提供支持
• 大量的機器人開發實現庫，如：數據類型定義、坐標變換、運動控制…

應用層。功能包，以及功能包內的節點，比如: master、turtlesim的控制與運動節點。

1.2. 文件系統

WorkSpace --- 自定義的工作空間|--- build:編譯空間，用于存放CMake和catkin的緩存信息、配置信息和其他中間文件。|--- devel:開發空間，用于存放編譯后生成的目標文件，包括頭文件、動態&靜態鏈接庫、可執行文件等。|--- src: 源碼|-- CMakeLists.txt: 編譯的基本配置|-- package：功能包(ROS 基本單元)包含多個節點、庫與配置文件，包名所有字母小寫，只能由字母、數字與下劃線組成|-- CMakeLists.txt 配置編譯規則，比如源文件、依賴項、目標文件|-- package.xml 包信息，比如:包名、版本、作者、依賴項...(以前版本是 manifest.xml)|-- scripts 存儲 python 文件|-- src 存儲 C++ 源文件|-- include 頭文件|-- msg 消息通信格式文件|-- srv 服務通信格式文件|-- action 動作格式文件|-- launch 可一次性運行多個節點 |-- config 配置信息|-- package

ROS 的文件系統本質上都還是操作系統文件，因此可以使用 Linux 命令來操作這些文件。不過，在 ROS 中為了更好的用戶體驗，ROS 專門提供了一些類似于 Linux 的命令，這些命令較之于 Linux 原生命令，更為簡潔、高效。

增

# 創建新的ROS功能包 catkin_create_pkg 自定義包名 依賴包# 安裝 ROS 功能包 sudo apt install xxx

刪

# 刪除某個功能包 sudo apt purge xxx

查

# 列出所有功能包 rospack list# 查找某個功能包是否存在，如果存在返回安裝路徑 rospack find 包名# 進入某個功能包 roscd 包名# 列出某個包下的文件 rosls 包名# 搜索某個功能包 apt search xxx

改

# 修改功能包文件（需要安裝 vim） rosed 包名 文件名

執行

# 必須運行 roscore 才能使 ROS 節點進行通信，他是 ROS 的系統先決條件節點和程序的集合。運行 roscore 會運行 ros master、ros 參數服務器、rosout 日志節點 roscore # 或(指定端口號) roscore -p xxxx# 運行指定的ROS節點 rosrun 包名 可執行文件名# 執行某個包下的 launch 文件 roslaunch 包名 launch文件名

1.3. 計算圖

ROS 文件結構是磁盤上 ROS 程序的存儲結構，是靜態的，而 ros 程序運行之后，不同的節點之間是錯綜復雜的，ROS 中提供了一個實用的工具：rqt_graph

rqt_graph 能夠創建一個顯示當前系統運行情況的動態圖形。ROS 分布式系統中不同進程需要進行數據交互，計算圖可以以點對點的網絡形式表現數據交互過程。rqt_graph 是 rqt 程序包中的一部分

運行 rat_graph 可通過下面命令執行：

rosrun rqt_graph rqt_graph # 或者直接輸入 rqt_graph

1.4. Source

• 下面命令是使得能夠在任意終端都能使用 ROS

echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc source ~/.bashrc

• 下面命令是使得能夠在任意終端都能使用當前工作空間

echo "source ~/工作空間/devel/setup.bash" >> ~/.bashrc source ~/.bashrc

1.5. helloworld

ROS 可是使用 C++ 或者 Python，但是具體選擇哪種語言需要視需求而定：C++ 運行效率高但是編碼效率低，而 Python 則反之。基于二者互補的特點，ROS 設計者分別設計了 roscpp 與 rospy 庫，前者旨在成為 ROS 的高性能庫，而后者則一般用于對性能無要求的場景，旨在提高開發效率

1.5.1. C++ 實現

進入 ros 包的 src 目錄編輯源文件

#include "ros/ros.h"int main(int argc, char *argv[]) {//執行 ros 節點初始化，輸入所有參數并對節點命名。注意，節點名稱是一個標識符，需要保證在 ROS 網絡拓撲中唯一ros::init(argc,argv,"hello");//創建 ros 節點句柄。注意，因為一個進程上運行一個節點，所以句柄是自動綁定到當前的進程，即節點上的ros::NodeHandle n;//控制臺輸出 hello worldROS_INFO("hello world!");return 0; }

編輯 ros 包下的 Cmakelist.txt 文件

add_executable(可執行文件名src/步驟3的源文件名.cpp ) target_link_libraries(可執行文件名${catkin_LIBRARIES} )

返回頂層工作空間目錄并編譯（生成 build 和 devel）：catkin_make

執行

在一個終端輸入命令啟動 ROS 核心：roscore

再在另一個終端輸入命令刷新環境變量并運行節點：

source ./devel/setup.bash rosrun 包名 可執行文件名

命令行輸出: HelloWorld!

1.5.2. Python 實現

進入 ros 包的 scripts 目錄編輯 python 文件（C++是進入同級的 src 目錄）

#! /usr/bin/env pythonimport rospyif __name__ == "__main__":rospy.init_node("Hello")rospy.loginfo("HelloWorld!")

為 python 文件添加可執行權限

chmod +x 文件名.py

編輯 ros 包下的 CamkeList.txt 文件

catkin_install_python(PROGRAMS scripts/文件名.pyDESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} )

返回頂層工作空間目錄并編譯：catkin_make

執行

在一個終端輸入命令啟動 ROS 核心：roscore

再在另一個終端輸入命令刷新環境變量并運行節點：

source ./devel/setup.bash rosrun 包名 文件名.py

輸出結果：HelloWorld!

另外，因為 Python 文件運行不需要編譯，所以在編寫完腳本后，可以直接運行節點

rosrun 包名 文件名.py

或者直接運行 Python 文件

python 文件名.py

2. 通信

機器人是一種高度復雜的系統性實現，在機器人上可能集成各種傳感器(雷達、攝像頭、GPS…)以及運動控制實現，為了解耦合，在 ROS 中每一個功能點都是一個單獨的進程，每一個進程都是獨立運行的。更確切的講，ROS 是進程（也稱為 Nodes）的分布式框架。 因為這些進程甚至還可分布于不同主機，不同主機協同工作，從而分散計算壓力。而為了實現不同進程之間的通信，ROS 提供了三種方式：

話題通信(發布訂閱模式)

服務通信(請求響應模式)

參數服務器(參數共享模式)

2.1. 話題通信

2.1.1. 簡介

• ROS 中使用最多的通信方式
• ROS 中的異步通信方式
• 通過 TCP/IP 通信
• Node 之間通過 publish-subscribe 機制通信
• 能夠進行多對多通信
• 常用于連續、高頻的數據發布：激光雷達、里程計發布數據
• Message：
  • topic 內容的數據格式
  • 定義在 .msg 文件中
  • 可以看作是一個結構體或者類

2.1.2. 理論模型

話題通信理論模型中涉及到三個角色。其中，ROS Master 負責保管 Talker 和 Listener 注冊的信息，并匹配話題相同的 Talker 與 Listener，幫助 Talker 與 Listener 建立連接，連接建立后，Talker 可以發布消息，且發布的消息會被 Listener 訂閱

2.1.3. C++ 實現

發布方

#include "ros/ros.h" #include "std_msgs/String.h" //普通文本類型的消息 #include <sstream>int main(int argc, char *argv[]) {setlocale(LC_ALL, "");ros::init(argc,argv,"talker");ros::NodeHandle nh;//泛型: 發布的消息類型//參數1: 要發布到的話題//參數2: 隊列中最大保存的消息數，超出此閥值時，先進的先銷毀ros::Publisher pub = nh.advertise<std_msgs::String>("chatter",10);std_msgs::String msg;std::string msg_front = "Hello！";int count = 0;//邏輯(一秒10次)ros::Rate r(10);while (ros::ok()) {std::stringstream ss;ss << msg_front << count;msg.data = ss.str();pub.publish(msg);ROS_INFO("發送消息: %s", msg.data.c_str());//根據前面制定的發送頻率自動休眠 休眠時間 = 1/頻率；r.sleep();count++;//循環結束前，讓 count 自增}return 0; }

訂閱方

#include "ros/ros.h" #include "std_msgs/String.h"void doMsg(const std_msgs::String::ConstPtr& msg_p) {ROS_INFO("接受信息: %s",msg_p->data.c_str()); }int main(int argc, char *argv[]) {setlocale(LC_ALL,"");ros::init(argc,argv,"listener");ros::NodeHandle nh;ros::Subscriber sub = nh.subscribe<std_msgs::String>("chatter", 10, doMsg);while (ros::ok()) {//循環調用回調函數ros::spinOnce();r.sleep();}return 0; }

接受信息一般使用 ros::spin() 或者 ros::spinOnce()。兩者區別在于，ros::spin() 在調用后不會再返回，而 ros::spinOnce() 后者在調用后還可以繼續執行之后的程序。因此，ros::spin() 函數一般不會出現在循環中，后面除了 return 0; 外不能有其他語句

CMakeLists.txt

add_executable(Hello_pubsrc/Hello_pub.cpp ) add_executable(Hello_subsrc/Hello_sub.cpp )target_link_libraries(Hello_pub${catkin_LIBRARIES} ) target_link_libraries(Hello_sub${catkin_LIBRARIES} )

2.1.4. Python 實現

發布方

#! /usr/bin/env python import rospy from std_msgs.msg import Stringif __name__ == "__main__":rospy.init_node("talker_p")pub = rospy.Publisher("chatter", String, queue_size=10)msg = String()msg_front = "hello"count = 0rate = rospy.Rate(10)while not rospy.is_shutdown():msg.data = msg_front + str(count)pub.publish(msg)rate.sleep()rospy.loginfo("發送信息:%s",msg.data)count += 1

訂閱方

#! /usr/bin/env python import rospy from std_msgs.msg import Stringdef doMsg(msg):rospy.loginfo("接受信息:%s", msg.data)if __name__ == "__main__":rospy.init_node("listener_p")sub = rospy.Subscriber("chatter", String, doMsg, queue_size=10)rospy.spin()

添加可執行權限

chmod +x *.py

CMakeLists.txt

catkin_install_python(PROGRAMSscripts/talker_p.pyscripts/listener_p.pyDESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} )

2.1.5. spinOnce 和 spin

spin 是忙等待，一旦接受緩沖區有數據就會立即處理，這樣處理信息的速度較快，但是忙等待會占用一定硬件資源。而 spinOnce 處理接受緩存區的速度由訂閱節點循環的頻率決定，并且每次都直接處理緩存區里的所有數據。

注意，在 Python 實現中，或者說在 rospy 中并沒有 spinOnce，這是因為 rospy 中 spin 的作用與 roscpp 不同，這里的 spin 只是用來確保不讓程序在節點關閉前退出，而不想 roscpp 中的那樣會影響處理信息的回調函數，所以 rospy 中只需要 spin 就可以了。

但是這樣就會產生一個問題，如果想實現在循環中處理接受信息調用回調函數，并執行發布消息的任務，則可以通過新開一個線程來解決循環問題，但是如果不需要循環，則可以直接在訂閱的回調函數中發布信息

#!/usr/bin/env python #-*- coding: utf-8 -*-import rospy import thread, time from geometry_msgs.msg import Twist from std_srvs.srv import Trigger, TriggerResponsepubCommand = False turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)def command_thread():while True:if pubCommand:vel_msg = Twist()vel_msg.linear.x = 0.5vel_msg.angular.z = 0.2turtle_vel_pub.publish(vel_msg)time.sleep(0.1)def commandCallback(req):global pubCommandpubCommand = bool(1 - pubCommand)return TriggerResponse(1, "Change turtle command state!")def turtle_command_server():rospy.init_node('turtle_command_server')s = rospy.Service('/turtle_command', Trigger, commandCallback)thread.start_new_thread(command_thread, ())rospy.spin()if __name__ == "__main__":turtle_command_server()

2.1.6. 話題同步

注意，只有多個主題都有數據的時候才可以觸發回調函數。如果其中一個主題的發布節點崩潰了，則整個回調函數永遠無法觸發回調；并且，當多個主題頻率一致的時候也無法保證回調函數的頻率等于訂閱主題的頻率，一般會很低。實際測試訂閱兩個需要同步的主題頻率為 50Hz 和 50Hz，而回調函數的頻率只有 24Hz 左右。

C++

#include <ros/ros.h> #include "sensor_msgs/LaserScan.h" #include "geometry_msgs/PoseWithCovarianceStamped.h" #include <message_filters/subscriber.h> #include <message_filters/synchronizer.h> #include <message_filters/sync_policies/approximate_time.h> #include <message_filters/time_synchronizer.h> #include <boost/thread/thread.hpp> #include <iostream>void multi_callback(const sensor_msgs::LaserScanConstPtr& scan, const geometry_msgs::PoseWithCovarianceStampedConstPtr& pose) {std::cout << "同步完成！" << std::endl; }int main(int argc, char** argv) {ros::init(argc, argv, "multi_receiver");ros::NodeHandle n;message_filters::Subscriber<sensor_msgs::LaserScan> subscriber_laser(n,"scan",1000,ros::TransportHints().tcpNoDelay());message_filters::Subscriber<geometry_msgs::PoseWithCovarianceStamped> subscriber_pose(n,"car_pose",1000,ros::TransportHints().tcpNoDelay());typedef message_filters::sync_policies::ApproximateTime<sensor_msgs::LaserScan, geometry_msgs::PoseWithCovarianceStamped> syncPolicy;//message_filters::TimeSynchronizer<sensor_msgs::LaserScan,geometry_msgs::PoseWithCovarianceStamped> sync(subscriber_laser, subscriber_pose, 10);message_filters::Synchronizer<syncPolicy> sync(syncPolicy(10), subscriber_laser, subscriber_pose); sync.registerCallback(boost::bind(&multi_callback, _1, _2));std::cout << "hahah" << std::endl;ros::spin();return 0; }

Python

#!/usr/bin/env python # coding=UTF-8 import rospy,math,random import numpy as np import message_filters from std_msgs.msg import String from sensor_msgs.msg import LaserScan from laser_geometry import LaserProjection from geometry_msgs.msg import PoseWithCovarianceStampeddef multi_callback(Subcriber_laser,Subcriber_pose):print "同步完成！"if __name__ == '__main__':rospy.init_node('multi_receive',anonymous=True)subcriber_laser = message_filters.Subscriber('scan', LaserScan, queue_size=1)subcriber_pose = message_filters.Subscriber('car_pose', PoseWithCovarianceStamped, queue_size=1)sync = message_filters.ApproximateTimeSynchronizer([subcriber_laser, subcriber_pose],10,0.1,allow_headerless=True)sync.registerCallback(multi_callback)rospy.spin()

2.1.7. 自定義 msg

在 ROS 通信協議中，數據載體是一個較為重要組成部分，ROS 中通過 std_msgs 封裝了一些原生的數據類型，比如：String、Int32、Int64、Char、Bool、Empty… 但是，這些數據一般只包含一個 data 字段，結構的單一意味著功能上的局限性，當傳輸一些復雜的數據，如激光雷達的信息時，可以使用自定義的消息類型

msgs 只是簡單的文本文件，每行具有字段類型和字段名稱，可以使用的字段類型有：

int8, int16, int32, int64 (或者無符號類型: uint*) float32, float64 string time, duration other msg files variable-length array[] and fixed-length array[C]

ROS 中還有一種特殊類型：Header，標頭包含時間戳和 ROS 中常用的坐標幀信息

首先在與功能包 src 同級的 msg 目錄下編輯自定義消息文件 Person.msg

string name uint16 age float64 height

然后編輯配置文件

package.xml

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

CMakeLists.txt（也可以在 msg 文件夾內再定義一個 CMake 文件，用來統一加入消息文件）

find_package(catkin REQUIRED COMPONENTSroscpprospystd_msgs # 需要加入 message_generation,必須有 std_msgsmessage_generation )# 配置 msg 源文件 add_message_files(FILESPerson.msg )# 生成消息時依賴于 std_msgs generate_messages(DEPENDENCIESstd_msgs )#執行時依賴 catkin_package(CATKIN_DEPENDS roscpp rospy std_msgs message_runtime )

最后進行編譯，會生成供 C++ 和 Python 使用的中間文件，此時調用這些中間文件就能發送自定義消息

• C++：.../工作空間/devel/include/包名/xxx.h。調用時執行#include "功能包包名/xxx.h"
• Python：.../工作空間/devel/lib/python3/dist-packages/包名/msg。調用時執行from 功能包包名.msg import xxx

2.1.8. 自定義變長 msg

--------------------------------------- imgData.msgint32 upperLeftint32 lowerRightstring colorstring cameraID --------------------------------------- imgDataArray.msgimgData[] images --------------------------------------- demo_pub.cppros::Publisher pub = n.advertise<my_pkg::imgDataArray>("test", 1000);my_pkg::imgData data; my_pkg::imgDataArray msg;data.upperleft=0; data.lowerRight=100; data.color="red"; data.cameraID="one"; msg.images.push_back(data); data.upperleft=1; data.lowerRight=101; data.color="blue"; data.cameraID="two"; msg.images.push_back(data);pub.publish(msg); --------------------------------------- demo_sub.cppvoid subCB(const my_pkg::imgDataArray::ConstPtr& msg) {for (int i=0; i<msg->images.size; ++i) {const my_pkg::imgData &data = msg->images[i];ROS_INFO_STREAM("UL: " << data.upperleft << "UR: " << data.upperright << "color: " << data.color << "ID: " << data.cameraID);} }int main(int argc, char **argv) {...ros::Subscriber sub = n.subscribe("test", 1000, subCB);ros::spin(); }

2.2. 服務通信

2.2.1. 簡介

• ROS 中的同步通信方式
• 通過 TCP/IP 通信
• Node 之間通過 request-reply 機制通信
• 能夠進行多對一通信
• 常用于偶爾調用的功能/具體的任務：開關傳感器、拍照、逆接計算
• srv：
  • service 通信的數據格式
  • 定義在 .srv 文件中

2.2.2. 理論模型

2.2.3. 話題和服務

在一個簡單字符串通信任務中，使用話題時平均延遲為 0.7ms，但是使用服務時平均延遲為 3ms。考慮到服務通信中 client 與 server 之間維持的是一個持久連接，那么服務通信應該要比話題通信快。但實際上，服務通信中 client 發出請求后需要先等 server 喚醒，而 server 喚醒時間就會占整體時間的 80%，即實際上因為服務通信是通過持久性連接發送請求的，所以服務通信的請求發送時間要比話題通信快，但是服務通信中服務喚醒的時間要更大，因此整體上服務通信延遲要比話題通信大

2.2.4. 自定義 srv

不同于話題通信可以只發送某個字段作為消息，服務通信包含請求和響應兩個過程，因此使用服務通信前必須先定義服務類型

首先在與功能包 src 同級的 srv 目錄下編輯自定義消息文件。其中，請求和響應使用---分割

# 客戶端請求時發送的兩個數字 int32 num1 int32 num2 --- # 服務器響應發送的數據 int32 sum

編輯 package.xml 文件，添加編譯依賴與執行依賴

<build_depend>message_generation</build_depend><exec_depend>message_runtime</exec_depend><!-- exce_depend 以前對應的是 run_depend 現在非法-->

編輯 CMakeLists.txt 相關配置

find_package(catkin REQUIRED COMPONENTSroscpprospystd_msgsmessage_generation ) # 需要加入 message_generation,必須有 std_msgsadd_service_files(FILESAddInts.srv )generate_messages(DEPENDENCIESstd_msgs )

最后進行編譯，會生成供 C++ 和 Python 使用的中間文件，此時調用這些中間文件就能發送自定義消息

• C++：.../工作空間/devel/include/包名/xxx.h。調用時執行#include "功能包包名/xxx.h"
• Python：.../工作空間/devel/lib/python3/dist-packages/包名/srv。調用時執行from 功能包包名.srv import xxx

2.2.5. C++ 實現

服務端

#include "ros/ros.h" #include "demo03_server_client/AddInts.h"// bool 返回值由于標志是否處理成功 bool doReq(demo03_server_client::AddInts::Request& req,demo03_server_client::AddInts::Response& resp) {int num1 = req.num1;int num2 = req.num2;ROS_INFO("服務器接收到的請求數據為:num1 = %d, num2 = %d",num1, num2);//邏輯處理if (num1 < 0 || num2 < 0) {ROS_ERROR("提交的數據異常:數據不可以為負數");return false;}//如果沒有異常，那么相加并將結果賦值給 respresp.sum = num1 + num2;return true; }int main(int argc, char *argv[]) {setlocale(LC_ALL,"");ros::init(argc,argv,"AddInts_Server");ros::NodeHandle nh;ros::ServiceServer server = nh.advertiseService("AddInts",doReq);ROS_INFO("服務已經啟動....");ros::spin();return 0; }

客戶端

#include "ros/ros.h" #include "demo03_server_client/AddInts.h"int main(int argc, char *argv[]) {setlocale(LC_ALL,"");if (argc != 3) {ROS_ERROR("請提交兩個整數");return 1;}ros::init(argc,argv,"AddInts_Client");ros::NodeHandle nh;ros::ServiceClient client = nh.serviceClient<demo03_server_client::AddInts>("AddInts");//方式1ros::service::waitForService("AddInts");//方式2// client.waitForExistence();// 組織請求數據demo03_server_client::AddInts ai;ai.request.num1 = atoi(argv[1]);ai.request.num2 = atoi(argv[2]);// 發送請求,返回 bool 值，標記是否成功bool flag = client.call(ai);// 處理響應if (flag) {ROS_INFO("請求正常處理,響應結果:%d",ai.response.sum);}else {ROS_ERROR("請求處理失敗....");return 1;}return 0; }

在客戶端發送請求前添加: client.waitForExistence(); 或: ros::service::waitForService("AddInts");。這是一個阻塞式函數，只有服務啟動成功后才會繼續執行。client.call() 也是一個阻塞式函數

2.2.6. Python 實現

服務端

#! /usr/bin/env pythonimport rospy from demo03_server_client.srv import AddInts,AddIntsRequest,AddIntsResponsedef doReq(req):sum = req.num1 + req.num2rospy.loginfo("提交的數據:num1 = %d, num2 = %d, sum = %d",req.num1, req.num2, sum)resp = AddIntsResponse(sum)return respif __name__ == "__main__":rospy.init_node("addints_server_p")# 創建服務對象server = rospy.Service("AddInts",AddInts,doReq)rospy.spin()

客戶端

#! /usr/bin/env pythonimport rospy from demo03_server_client.srv import * import sysif __name__ == "__main__":if len(sys.argv) != 3:rospy.logerr("請正確提交參數")sys.exit(1)rospy.init_node("AddInts_Client_p")# 創建請求對象client = rospy.ServiceProxy("AddInts",AddInts)# 方式1:# rospy.wait_for_service("AddInts")# 方式2client.wait_for_service()# 發送請求,接收并處理響應# 方式1# resp = client(3,4)# 方式2# resp = client(AddIntsRequest(1,5))# 方式3req = AddIntsRequest()# req.num1 = 100# req.num2 = 200 req.num1 = int(sys.argv[1])req.num2 = int(sys.argv[2]) resp = client.call(req)rospy.loginfo("響應結果:%d",resp.sum)

2.3. 參數服務器

rosparam：https://blog.csdn.net/u014695839/article/details/78348600

3. 運行

3.1. launch

3.1.1. 運行

一個程序中可能需要啟動多個節點，比如：ROS 內置的小烏龜案例，如果要控制烏龜運動，要啟動多個窗口，分別啟動 roscore、烏龜界面節點、鍵盤控制節點。如果每次都調用 rosrun 逐一啟動，顯然效率低下，因此官方給出的優化策略是使用 launch 文件，可以一次性啟動多個 ROS 節點。

進入 ros 包的 launch 目錄編輯 launch 文件：

<launch><node pkg="helloworld" type="demo_hello" name="hello" output="screen" /><node pkg="turtlesim" type="turtlesim_node" name="t1"/><node pkg="turtlesim" type="turtle_teleop_key" name="key1" /> </launch>

運行 launch 文件（此時 roslaunch 命令會在內部自動執行 roscore 命令）

roslaunch 包名 launch文件名

運行結果：一次性啟動了多個節點

3.1.2. 標簽

3.1.2.1. launch

launch 標簽規定了一片區域，所有的 launch 文件都由 <launch> 開頭，由 </launch> 結尾，所有的描述標簽都要寫在 <launch> 和 </launch>之間

<launch> ... </launch>

3.1.2.2. node

node 標簽里包括了 ROS 中節點的名稱屬性 name、該節點所在的包名 pkg、節點的類型 type 以及日志輸出位置屬性 output

屬性屬性作用

name=“NODE_NAME”	為節點指派名稱，這將會覆蓋掉 ros::init() 定義的 node_name
pkg=“PACKAGE_NAME”	節點所在的包名
type=“FILE_NAME”	執行文件的名稱。如果是用 Python 編寫則為 xxx.py，如果是 C++ 則為生成的可執行文件名
output=“screen”	終端輸出轉儲在當前的控制臺上，而不是在日志文件中。在節點內有日志輸出時該屬性才會起作用
respawn=“true”	當 roslaunch 啟動完所有該啟動的節點之后，會監測每一個節點，保證它們正常的運行狀態。對于任意節點，當它終止時，roslaunch 會將該節點重啟
required=“true”	當被此屬性標記的節點終止時，roslaunch 會將其他的節點一并終止。注意此屬性不可以與 respawn=“true” 一起描述同一個節點
launch-prefix = “command-prefix”	相當于在執行啟動命令時加上一段命令前綴
ns = “NAME_SPACE”	在自定義的命名空間里運行節點

3.1.2.3. include

該標簽可以導入另一個 roslaunch XML 文件到當前文件

屬性屬性作用

file ="$(find pkg-name)/path/filename.xml"	指明想要包含進來的文件
ns=“NAME_SPACE”	相對NAME_SPACE命名空間導入文件

<include file="$(find demo)/launch/demo.launch" ns="demo_namespace"> ... </include>

3.1.2.4. remap

ROS 支持 topic 的重映射，remap 標簽里包含一個 original-name 和一個 new-name，及原名稱和新名稱

比如現在拿到一個節點，這個節點訂閱了 “/chatter” 話題，然而自己寫的節點只能發布到 “/demo/chatter” 話題，由于這兩個 topic 的消息類型是一致的，想讓這兩個節點進行通訊，那么可以在 launch 文件中這樣寫：

<remap from="chatter" to="demo/chatter"/>

這樣就可以直接把 /chatter 重映射到 /demo/chatter，讓兩個節點進行通訊

如果 remap 標簽寫在與 node 元素的同一級，而且在 launch 元素內的最頂層。 那么這個重映射將會作用于 launch 文件中所有的節點

3.1.2.5. param

param 標簽的作用相當于命令行中的 rosparam set。比如現在在參數服務器中添加一個名為 demo_param，值為 666 的參數

<param name="demo_param" type="int" value="666"/>

3.1.2.6. rosparam

rosparam 標簽允許從 YAML 文件中一次性導入大量參數

<rosparam command="load" file="$(find pkg-name)/path/name.yaml"/>

3.1.2.7. arg

arg 標簽用來在 launch 文件中定義參數，arg 和 param 在 ROS 里有根本性的區別，就像局部變量和全局變量的區別一樣。arg 不儲存在參數服務器中，不能提供給節點使用，只能在 launch 文件中使用。param 則是儲存在參數服務器中，可以被節點使用。

<arg name="demo"/>

像上面這樣，就簡單地聲明了一個參數，名叫 demo，但是聲明不等于定義，在賦值之后參數才能夠發揮作用。

<arg name="demo" value="666"/> <arg name="demo" default="666"/>

以上是兩種簡單的賦值方法，兩者的區別是使用后者賦值的參數可以在命令行中像下面這樣被修改，前者則不行。

roslaunch demo demo.launch demo:=6666

arg 還有更加高級，也更加靈活的用法：$(arg arg_name)
當 $(arg arg_name) 出現在 launch 文件任意位置時，將會自動替代為所給參數的值

3.1.2.8. group

group 標簽可以將若干個節點同時劃分進某個工作空間

<group ns="demo_1"><node name="demo_1" pkg="demo_1" type="demo_pub_1" output="screen"/><node name="demo_1" pkg="demo_1" type="demo_sub_1" output="screen"/> </group> <group ns="demo_2"><node name="demo_2" pkg="demo_2" type="demo_pub_2" output="screen"/><node name="demo_2" pkg="demo_2" type="demo_sub_2" output="screen"/> </group>

group 標簽還可以做到對 node 的批量管理。比如可以同時終止在同一個 group 中的節點

<group if="1-or-0"> …… …… …… </group><group unless="1-or-0"> …… …… …… </group>

第一種情況，當 if 屬性的值為 0 的時候將會忽略掉 <group></group> 之間的標簽

第二種恰好相反，當 if 屬性的值為 1 的時候將會忽略掉 <group></group> 之間的標簽

但是通常不會直接用 1 或 0 來定義 if 標簽。因為這樣不夠靈活。
通常會搭配 $(arg arg_name) 來使用 demo.launch 文件

<launch><include file="include.launch"><arg name="demo_arg" value="1"/></include> </launch>

include.launch文件

<launch><arg name="demo_arg"/><group if="$(demo_arg)"><node name="demo" pkg="demo" type="demo_pub" output="screen"/><node name="demo" pkg="demo" type="demo_sub" output="screen"/></group> </launch>

https://zhuanlan.zhihu.com/p/157526418

總結

以上是生活随笔為你收集整理的ROS基础教程的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。