########################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################################

|
|
v

catkin_install_python(PROGRAMS
scripts/helloworld.py
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

cd demo01_ws
catkin_make
##此处bug:
‘’‘find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs#s不要掉下来，否则编译失败了
)’‘’
source ./devel/setup.bash#刷新环境变量
rosrun helloworld helloworld.py##第一个helloworld是包名，二是脚本

6.综合开发环境：
terminator终端配置https://blog.csdn.net/weixin_42369926/article/details/99712378

下载terminator      sudo apt-get update     sudo apt-get install terminator  新建terminator配置文件      mkdir ~/.config/terminator     vim ~/.config/terminator/config  配置terminator      [global_config]       geometry_hinting = False       handle_size = 1       inactive_color_offset =1.0
      title_font = mry_KacstQurn Bold 11
      title_hide_sizetext = True
    [keybindings]
    [layouts]
      [[default]]
        [[[child1]]]
          parent = window0
          profile = default
          type = Terminal
        [[[window0]]]
          parent = ""
          type = Window
    [plugins]
    [profiles]
      [[default]]
        background_darkness = 0.49
        background_image = '背景图片路径'
        background_type = transparent
        cursor_color = "#3036ec"
        custom_command = tmux
        font = Ubuntu Mono 13
        foreground_color = "#ffffff"
        login_shell = True
        scroll_background = False
        show_titlebar = False
        use_system_font = False

terminator常用快捷方式
序号  快捷键 功能
1   Ctrl+Shift+O    水平分割终端
2   Ctrl+Shift+E    垂直分割终端
3   Ctrl+Shift+F    搜索
4   Ctrl+Shift+C    复制
5   Ctrl+Shift+V    粘贴
6   Ctrl+Shift+W    关闭当前终端
7   Ctrl+Shift+Q    退出当前窗口
8   Ctrl+Shift+T    打开终端
9   Ctrl+Shift+X    切换显示当前窗口
10  F11 全屏状态
11  Ctrl+Shift+G    clear屏幕
12  Ctrl+Shift+Right    在垂直分割的终端中将分割条向右移动
13  Ctrl+Shift+Left 在垂直分割的终端中将分割条向左移动
14  Ctrl+Shift+S    隐藏/显示滚动条

7.当mv,rm,mkdir,touch,cp,等权限不够时可加sudo

#sudo rm -r VSCode-linux-x64/强制删除
#sudo chmod 777 Python.sublime-package (最高权限)
#rm -r dir
8.如何下载vscode及其配置：
Ctrl+Shift+P, F1
打开命令面板

Ctrl+p    
快速打开文件

Ctrl+Shift+N     
打开新窗口/实例

Ctrl+Shift+W    
关闭窗口/实例

基础编辑

Ctrl+X      
剪切当前行

Ctrl+C    
复制当前行

Alt+ ↑ / ↓    
向上/向下移动当前行

Shift+Alt + ↓ / ↑    
向上/向下复制当前行

Ctrl+Shift+K   
删除当前行

Ctrl+Enter    
在当前行以下插入

Ctrl+Shift+Enter    
在当前行以上插入

Ctrl+Shift+\      
跳转到匹配的括号

Ctrl+] / [    
缩进/取消缩进

Home     
转到行首

End     
转到行尾

Ctrl+Home    
转到页首

Ctrl+End     
转到页尾

Ctrl+↑ / ↓   
向上/向下滚动

Alt+PgUp / PgDown
向上/向下翻页

Ctrl+Shift+[ 
折叠当前代码块

Ctrl+Shift+]
展开当前代码块

Ctrl+K Ctrl+[  
折叠所有子代码块

Ctrl+K Ctrl+]
展开所有子代码块

Ctrl+K Ctrl+0
折叠所有代码块

Ctrl+K Ctrl+J   
展开所有代码块

Ctrl+K Ctrl+C  
添加行注释

Ctrl+K Ctrl+U
删除行注释

Ctrl+/   
添加/删除行注释

Shift+Alt+A 
添加/删除块注释

Alt+Z  
自动换行

导航

Ctrl+T  
显示所有符号

Ctrl+G
跳转到行

Ctrl+P    
跳转到文件

Ctrl+Shift+O      
跳转到符号

Ctrl+Shift+M  
显示问题面板

F8 
跳转到下一个问题或警告

Shift+F8
跳转到前一个问题或警告

Ctrl+Shift+Tab
显示编辑器文件历史

Alt+ ← / →
向后/向前查看文件

Ctrl+M
开启/关闭 Tab 移动焦点

搜索和替换
Ctrl+F
查找

Ctrl+H
替换

F3 / Shift+F3
查找下一个/前一个

Alt+Enter  
选择所有匹配项

Ctrl+D   
选择下一个匹配项

Ctrl+K Ctrl+D
跳过当前选择项

Alt+C / R / W
切换大小写敏感/正则表达式/全词

多光标与选择
Alt+Click
插入光标

Ctrl+Alt+ ↑ / ↓
向上/向下插入光标

Ctrl+U 
撤销上一个光标

Shift+Alt+I
在选中行的行尾插入光标

Ctrl+I
选择当前行

Ctrl+Shift+L
选择当前选中项的所有匹配项

Ctrl+F2
选择当前单词的所有匹配项

Shift+Alt+→  
扩展选择

Shift+Alt+←
缩小选择

Shift+Alt + (drag mouse)
列（框）选择

Ctrl+Shift+Alt + (arrow key)
列（框）选择

Ctrl+Shift+Alt +PgUp/PgDown

向上页/下页列（框）选择
2、自定义快捷键:(以下代码表示方向键可以自定义)
// Place your key bindings in this file to overwrite the defaults
// alt + i, j, k,l
[{
“key”: “alt+j”,
“command”: “cursorLeft”
},
{
“key”: "alt+j ",
“command”: “list.collapse”,
“when”: “listFocus”
},
{
“key”: “alt+k”,
“command”: “cursorDown”
},
{
“key”: “alt+k”,
“command”: “repl.action.historyNext”,
“when”: “editorTextFocus && inDebugRepl && onLastDebugReplLine”
}, {
“key”: “alt+k”,
“command”: “settings.action.focusSettingsFile”,
“when”: “inSettingsSearch”
}, {
“key”: “alt+k”,
“command”: “showNextParameterHint”,
“when”: “editorTextFocus && parameterHintsMultipleSignatures && parameterHintsVisible”
}, {
“key”: “alt+k”,
“command”: “selectNextSuggestion”,
“when”: “editorTextFocus && suggestWidgetMultipleSuggestions && suggestWidgetVisible”
}, {
“key”: “alt+k”,
“command”: “keybindings.editor.focusKeybindings”,
“when”: “inKeybindings && inKeybindingsSearch”
}, {
“key”: “alt+k”,
“command”: “keybindings.editor.focusKeybindings”,
“when”: “inKeybindings && inKeybindingsSearch”
}, {
“key”: “alt+k”,
“command”: “search.focus.nextInputBox”,
“when”: “inputBoxFocus && searchViewletVisible”
}, {
“key”: “alt+k”,
“command”: “workbench.action.interactivePlayground.arrowDown”,
“when”: “interactivePlaygroundFocus && !editorTextFocus”
},
{
“key”: “alt+l”,
“command”: “cursorRight”
},
{
“key”: “alt+l”,
“command”: “repl.action.acceptSuggestion”,
“when”: “editorTextFocus && inDebugRepl && suggestWidgetVisible”
}, {
“key”: “alt+l”,
“command”: “list.expand”,
“when”: “listFocus”
},
{
“key”: “alt+i”,
“command”: “cursorUp”
},
{
“key”: “alt+i”,
“command”: “repl.action.historyPrevious”,
“when”: “editorTextFocus && inDebugRepl && onLastDebugReplLine”
}, {
“key”: “alt+i”,
“command”: “showPrevParameterHint”,
“when”: “editorTextFocus && parameterHintsMultipleSignatures && parameterHintsVisible”
}, {
“key”: “alt+i”,
“command”: “selectPrevSuggestion”,
“when”: “editorTextFocus && suggestWidgetMultipleSuggestions && suggestWidgetVisible”
},
{
“key”: “alt+i”,
“command”: “list.focusUp”,
“when”: “listFocus”
}, {
“key”: “alt+i”,
“command”: “search.action.focusSearchFromResults”,
“when”: “firstMatchFocus && searchViewletVisible”
}, {
“key”: “alt+i”,
“command”: “search.action.focusSearchFromResults”,
“when”: “firstMatchFocus && searchViewletVisible”
}, {
“key”: “alt+i”,
“command”: “workbench.action.interactivePlayground.arrowUp”,
“when”: “interactivePlaygroundFocus && !editorTextFocus”
}
]

9.用vscode开发ros:
mkdir demo01_ws/src
cd demo01_ws
catkin_make
cd demo01_ws
code .
在/demo01_ws/src下catkin_create_pkg helloworld rospy std_msgs
ctrl+shift+B 调用编译,选择catkin_make:build
修改.vscode/tasks.json：##以后此步骤可以执行，即可以打开task.json，但是不必要修改此文件，直接默认即可

{
// 有关 tasks.json 格式的文档，请参见
// https://go.microsoft.com/fwlink/?LinkId=733558
“version”: “2.0.0”,
“tasks”: [
{
“label”: “catkin_make:debug”, //代表提示的描述性信息
“type”: “shell”, //可以选择shell或者process,如果是shell代码是在shell里面运行一个命令，如果是process代表作为一个进程来运行
“command”: “catkin_make”,//这个是我们需要运行的命令
“args”: [],//如果需要在命令后面加一些后缀，可以写在这里，比如-DCATKIN_WHITELIST_PACKAGES=“pac1;pac2”
“group”: {“kind”:“build”,“isDefault”:true},
“presentation”: {
“reveal”: “always”//可选always或者silence，代表是否输出信息
},
“problemMatcher”: “$msCompile”
}
]
}
在demo01_ws/src/hellowold/scripts下新建helloworld.py并添加可执行权限

写脚本：
#! /usr/bin/env python
“”"
Python 版本的 HelloVScode，执行在控制台输出 HelloVScode
实现:
1.导包
2.初始化 ROS 节点
3.日志输出 HelloWorld

“”"

import rospy # 1.导包

if name == “main”:

rospy.init_node("Hello_Vscode_p")  # 2.初始化 ROS 节点
rospy.loginfo("Hello VScode, 我是 Python ....")  #3.日志输出 HelloWorld

配置 CMakeLists.txt：
catkin_install_python(PROGRAMS scripts/自定义文件名.py
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

编译: ctrl + shift + B#实际上已经代替了catkin_make
激活：source ./devel/setup.bash
rosrun helloworld helloworld.py

10.用launch文件来控制输出：

1…需求

‘’‘find_package和catkin_package相对应，若是编译helloworld的功能包，就必须要依赖于find_packaged的功能包
而find_package的功能包必须依赖于catkin_package的功能包’‘’

add_message_files(##若是自定义msg,则要放开3个注释，否则都不需要放开(catkin_install除外)
FILES
Person.msg
)

generate_messages(
DEPENDENCIES
std_msgs
)

#执行时依赖
catkin_package(

CATKIN_DEPENDS roscpp rospy std_msgs message_runtime#message_runtime是添加的功能包

)

add_message_file—generate_messages—catkin_package—find_package
#配置msg源文件—如果要执行Person.msg就必须要依赖于std_msgs—helloworld依赖于find_package—find_package依赖于catkin_package
#所以find_package可以理解为编译式依赖，而catkin_package是运行式依赖

1-3.编译

编译后的中间文件查看:

C++ 需要调用的中间文件(…/工作空间/devel/include/包名/Person.h)

Python 需要调用的中间文件(…/工作空间/devel/lib/python3/dist-packages/包名/msg/Person.py)

后续调用相关 msg 时，是从这些中间文件调用的
my_python_script

4.话题通信自定义msg调用

需求:

编写发布订阅实现，要求发布方以1HZ(每秒1次)的频率发布自定义消息，订阅方订阅自定义消息并将消息内容打印输出。

分析:

在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:

发布方
接收方
数据(此处为自定义消息)

流程:

1.编写发布方实现；
2.编写订阅方实现；
3.为python文件添加可执行权限；
4.编辑配置文件；
5.编译并执行。

4-1.vscode配置

为了方便代码提示以及误抛异常，需要先配置 vscode，将前面生成的 python 文件路径配置进 settings.json

{
“python.autoComplete.extraPaths”: [
“/opt/ros/noetic/lib/python3/dist-packages”,
“/home/kim/demo01/devel/lib/python3/dist-packages/helloworld/msg”
],
“python.analysis.extraPaths”: [
“/opt/ros/noetic/lib/python3/dist-packages”
],
“ros.distro”: “noetic”
}

4-2.发布方

#! /usr/bin/env python
“”"
发布方:
循环发送消息

“”"
import rospy
from demo02_talker_listener.msg import Person

if name == “main”:
#1.初始化 ROS 节点
rospy.init_node(“talker_person_p”)
#2.创建发布者对象
pub = rospy.Publisher(“chatter_person”,Person,queue_size=10)
#3.组织消息
p = Person()
p.name = “葫芦瓦”
p.age = 18
p.height = 0.75

#4.编写消息发布逻辑
rate = rospy.Rate(1)
while not rospy.is_shutdown():
    pub.publish(p)  #发布消息
    rate.sleep()  #休眠
    rospy.loginfo("姓名:%s, 年龄:%d, 身高:%.2f",p.name, p.age, p.height)#输出

4-3.订阅方

#! /usr/bin/env python
“”"
订阅方:
订阅消息

“”"
import rospy
from demo02_talker_listener.msg import Person

def doPerson§:
rospy.loginfo(“接收到的人的信息:%s, %d, %.2f”,p.name, p.age, p.height)

注意：发布方和订阅方都要导入Person

if name == “main”:
#1.初始化节点
rospy.init_node(“listener_person_p”)
#2.创建订阅者对象
sub = rospy.Subscriber(“chatter_person”,Person,doPerson,queue_size=10)
rospy.spin() #3.循环

4-4.权限设置

终端下进入 scripts 执行:chmod +x *.py
4-5.配置 CMakeLists.txt

catkin_install_python(PROGRAMS
scripts/talker_p.py
scripts/listener_p.py
scripts/person_talker.py
scripts/person_listener.py
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

4-6.执行

1.启动 roscore;

2.启动发布节点;

3.启动订阅节点。

运行结果与引言部分的演示案例2类似。

PS：
可以使用 rqt_graph 查看节点关系。
连续按2次f5可以调试程序
!!!注意：helloworld包下的include,msg,scripts,src是平级别文件不要搞错

!conclude:
1.在cmake中：find_package:message_generation---->add_message_file:Person.msg
----->generate_messages:std_msgs---->catkin_package:message_runtime------>catkin_install_python
2.在xml中：message_generation+message_runtime<—>build_depend+build_export_depend+exec_depend
3.导包：c/s and p/s都要导入:from model.msg/model.srv import *
‘3.通信机制’

服务通信较之于话题通信更简单些，理论模型如下图所示，该模型中涉及到三个角色:

ROS master(管理者)
Server(服务端)
Client(客户端)

ROS Master 负责保管 Server 和 Client 注册的信息，并匹配话题相同的 Server 与 Client ，帮助 Server 与 Client 建立连接，连接建立后，Client 发送请求信息，Server 返回响应信息。

整个流程由以下步骤实现:
0.Server注册

Server 启动后，会通过RPC在 ROS Master 中注册自身信息，其中包含提供的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。
1.Client注册

Client 启动后，也会通过RPC在 ROS Master 中注册自身信息，包含需要请求的服务的名称。ROS Master 会将节点的注册信息加入到注册表中。
2.ROS Master实现信息匹配

ROS Master 会根据注册表中的信息匹配Server和 Client，并通过 RPC 向 Client 发送 Server 的 TCP 地址信息。
3.Client发送请求

Client 根据步骤2 响应的信息，使用 TCP 与 Server 建立网络连接，并发送请求数据。
4.Server发送响应

Server 接收、解析请求的数据，并产生响应结果返回给 Client。

注意:

1.客户端请求被处理时，需要保证服务器已经启动；

2.服务端和客户端都可以存在多个。

3.话题，服务端口，客户端，数据载体#要保证话题是一致的

1.服务通信自定义srv

需求:

服务通信中，客户端提交两个整数至服务端，服务端求和并响应结果到客户端，请创建服务器与客户端通信的数据载体。

流程:

srv 文件内的可用数据类型与 msg 文件一致，且定义 srv 实现流程与自定义 msg 实现流程类似:

按照固定格式创建srv文件

编辑配置文件

编译生成中间文件

1-1.定义srv文件

服务通信中，数据分成两部分，请求与响应，在 srv 文件中请求和响应使用—分割，具体实现如下:

功能包下新建 srv 目录，添加 xxx.srv 文件，内容:

int32 sum

1-2.编辑配置文件

package.xml中添加编译依赖与执行依赖

message_generation
message_runtime

CMakeLists.txt编辑 srv 相关配置

find_package(catkin REQUIRED COMPONENTS
roscpp
rospy
std_msgs
message_generation
)

add_service_files(
FILES
AddInts.srv
)

generate_messages(
DEPENDENCIES
std_msgs
)
#find_package是当前创建的包依赖的包，catkin_package是依赖包所依赖的包
注意: 官网没有在 catkin_package 中配置 message_runtime,经测试配置也可以
1-3.编译

编译后的中间文件查看:

C++ 需要调用的中间文件(…/工作空间/devel/include/包名/xxx.h)

Python 需要调用的中间文件(…/工作空间/devel/lib/python3/dist-packages/包名/srv)

后续调用相关 srv 时，是从这些中间件调用的
!!!devel文件下include是专门放c++文件，lib是专门放python文件，但是还需进入到python3/dist-packages/包名/srv/_AddInts.py下查看具体信息

2.服务通信自定义srv调用

需求:

编写服务通信，客户端提交两个整数至服务端，服务端求和并响应结果到客户端。

分析:

在模型实现中，ROS master 不需要实现，而连接的建立也已经被封装了，需要关注的关键点有三个:

服务端
客户端
数据

流程:

编写服务端实现；
编写客户端实现；
为python文件添加可执行权限；
编辑配置文件；
编译并执行。

2-0.vscode配置

需要像之前自定义 msg 实现一样配置settings.json 文件，如果以前已经配置且没有变更工作空间，可以忽略，如果需要配置，配置方式与之前相同:

{
“python.autoComplete.extraPaths”: [
“/opt/ros/noetic/lib/python3/dist-packages”,
]
}

2-1.服务端

#! /usr/bin/env python
“”"
需求:
编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
客户端再解析

服务器端实现:
    1.导包
    2.初始化 ROS 节点
    3.创建服务对象
    4.回调函数处理请求并产生响应
    5.spin()#有回调函数就必需要有rospy.spin()

“”"

import rospy
from model_01 import AddInts,AddIntsRequest,AddIntsResponse

def doReq(req):
# 1.解析提交的数据
sum = req.num1 + req.num2
rospy.loginfo(“提交的数据:num1 = %d, num2 = %d, sum = %d”,req.num1, req.num2, sum)

# resp = AddIntsResponse()
# resp.sum = sum
# 2.创建响应对象，将结果装进响应对象，并返回响应对象
resp = AddIntsResponse(sum)
return resp#response

if name == “main”:
# 2.初始化 ROS 节点
rospy.init_node(“addints_server_p”)
# 3.创建服务端
server = rospy.Service(“AddInts”,AddInts,doReq)
rospy.loginfo(‘服务器已经启动’)

'''1.addints代表主题，且service和serviceproxy的主题要一致
2.proxy表示代理人;3.第二个参数是service_class,即是服务类型；
4.第三个参数是handler,即是回调函数，回调函数的作用是处理master请求并产生响应
请求会以参数的方式来传递给函数，响应会以返回值的方式来返回'''

# 4.回调函数处理请求并产生响应

# 5.spin 函数
rospy.spin()

总结：
import rospy
from model_02.srv import *

def doReq(req):

sum = req.num1 + req.num2#1.解析数据

response = AddIntsRequest(sum)#2.将数据封装进响应对象；函数传入的数据是请求，返回的响应，

return response

##实际上是1.发出请求，2.返回响应

if name == ‘main’:

rospy.init_node('server')

server = rospy.Server('house',AddInts,doReq)

rospy.spin()

2-2.客户端

#! /usr/bin/env python

“”"
需求:
2- 编写两个节点实现服务通信，客户端节点需要提交两个整数到服务器
服务器需要解析客户端提交的数据，相加后，将结果响应回客户端，
客户端再解析

客户端实现:
    1.导包
    2.初始化 ROS 节点
    3.创建请求对象
    4.发送请求
    5.接收并处理响应

优化:
    加入数据的动态获取

“”"
‘简化版’
import rospy
from helloworld.srv import *
import sys

if name == ‘main’:
#1.初始化节点
rospy.init_node(‘client’)
#2.创建客户端对象
client = rospy.ServiceProxy(‘house’,addInts)
#3.组织请求数据
response = client.call(12,23)#服务参数的对象
#4.处理响应

rospy.loginfo('响应的结果:%d',response.sum)

‘升级版’
#! /usr/bin/env python
#1.导包
import rospy
from demo03_server_client.srv import *
import sys

if name == “main”:

#优化实现
if len(sys.argv) != 3:
    rospy.logerr("请正确提交参数")
    sys.exit(1)#退出程序


# 2.初始化 ROS 节点
rospy.init_node("AddInts_Client_p")
# 3.创建请求对象
client = rospy.ServiceProxy("AddInts",AddInts)
# 请求前，等待服务已经就绪
# 方式1:
# rospy.wait_for_service("AddInts")
# 方式2
client.wait_for_service()
# 4.发送请求,接收并处理响应
# 方式1
# resp = client(3,4)
# 方式2
# resp = client(AddIntsRequest(1,5))
# 方式3
req = AddIntsRequest()##1.发送请求
# req.num1 = 100
# req.num2 = 200 

#优化
req.num1 = int(sys.argv[1])
req.num2 = int(sys.argv[2]) 

resp = client.call(req)##2.处理响应,#当于将调用server，并把req传给doReq(req)的req,并返回resp
rospy.loginfo("响应结果:%d",resp.sum)

!!!sys.argv的作用

argv[0]代表模块文件名、argv[1]代表传入的第一个命令行参数，argv[2]为传入的第二个命令行参数值，以此类推

详解：argv是sys模块的一个全局变量，也称sys模块的一个属性！argv本身为一个list类型的对象，该对象持有的第1个元素是命令行中传入的模块名、从第2个元素开始（含），均为命令行中传入的参数！

注意：argv持有的每个元素的类型均为str（字符串）

举个例子

python temp.py a b c d#在终端中运行python文件的格式

说明：命令行运行temp.py模块，同时传入4个参数：a、b、c、d

sys.argv == [“temp.py”,“a”,“b”,“c”,“d”] #sys.argv是持有5个元素的list对象

sys.argv[0] == “temp.py” #第1个元素为模块名“temp.py”

sys.argv[1] == “a” #第2个元素为"a"

sys.argv[2] == “b” #第3个元素为"b"

sys.argv[3] == “c” #第4个元素为"c"

2-3.设置权限

终端下进入 scripts 执行:chmod +x *.py
2-4.配置 CMakeLists.txt

CMakeLists.txt

catkin_install_python(PROGRAMS
scripts/AddInts_Server_p.py
scripts/AddInts_Client_p.py
DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

2-5.执行

流程:

需要先启动服务:rosrun 包名 服务

然后再调用客户端 :rosrun 包名 客户端 参数1 参数2

结果:

会根据提交的数据响应相加后的结果。

4.参数服务器

参数服务器实现是最为简单的，该模型如下图所示,该模型中涉及到三个角色:

ROS Master (管理者)
Talker (参数设置者)
Listener (参数调用者)

            rosmaster

------------> <---------------------------------
| (1)setParam(‘foo’,1) | |
| |(3){foo:1} |(2)getParam{‘foo’}
| | |
| V |
| V---------------------
talker listener

ROS Master 作为一个公共容器保存参数，Talker 可以向容器中设置参数，Listener 可以获取参数。
整个流程由以下步骤实现:
1.Talker 设置参数

Talker 通过 RPC 向参数服务器发送参数(包括参数名与参数值)，ROS Master 将参数保存到参数列表中。
2.Listener 获取参数

Listener 通过 RPC 向参数服务器发送参数查找请求，请求中包含要查找的参数名。
3.ROS Master 向 Listener 发送参数值

ROS Master 根据步骤2请求提供的参数名查找参数值，并将查询结果通过 RPC 发送给 Listener。

！！！talker发送参数—>listener请求参数—>master给listener发送参数

参数可使用数据类型:

32-bit integers

booleans

strings

doubles

iso8601 dates

lists

base64-encoded binary data

字典

注意:参数服务器不是为高性能而设计的，因此最好用于存储静态的非二进制的简单数据

需求:实现参数服务器参数的增删改查操作。
#int float bool list dict
4-1.参数服务器新增(修改)参数

#! /usr/bin/env python
“”"
参数服务器操作之新增与修改(二者API一样)_Python实现:
“”"

import rospy

if name == “main”:
rospy.init_node(“set_update_paramter_p”)

# 设置各种类型参数
rospy.set_param("p_int",10)
rospy.set_param("p_double",3.14)
rospy.set_param("p_bool",True)
rospy.set_param("p_string","hello python")
rospy.set_param("p_list",["hello","haha","xixi"])
rospy.set_param("p_dict",{"name":"hulu","age":8})

# 修改
rospy.set_param("p_int",100)

4-2.参数服务器获取参数

#! /usr/bin/env python

“”"
参数服务器操作之查询_Python实现:
get_param(键,默认值)
当键存在时，返回对应的值，如果不存在返回默认值
get_param_cached
get_param_names
has_param
search_param
“”"

import rospy

if name == “main”:
rospy.init_node(“get_param_p”)

#获取参数
int_value = rospy.get_param("p_int",10000)
double_value = rospy.get_param("p_double")
bool_value = rospy.get_param("p_bool")
string_value = rospy.get_param("p_string")
p_list = rospy.get_param("p_list")
p_dict = rospy.get_param("p_dict")

rospy.loginfo("获取的数据:%d,%.2f,%d,%s",
            int_value,
            double_value,
            bool_value,
            string_value)
for ele in p_list:
    rospy.loginfo("ele = %s", ele)

rospy.loginfo("name = %s, age = %d",p_dict["name"],p_dict["age"])

# get_param_cached
int_cached = rospy.get_param_cached("p_int")#cache：N.是高速缓存器，V.缓存
rospy.loginfo("缓存数据:%d",int_cached)

# get_param_names
names = rospy.get_param_names()
for name in names:
    rospy.loginfo("name = %s",name)

rospy.loginfo("-"*80)

# has_param
flag = rospy.has_param("p_int")
rospy.loginfo("包含p_int吗？%d",flag)#1表示有，0表示无

# search_param
key = rospy.search_param("p_int")
rospy.loginfo("搜索的键 = %s",key)#键为p_int

4-3.参数服务器删除参数

#! /usr/bin/env python
“”"
参数服务器操作之删除_Python实现:
rospy.delete_param(“键”)
键存在时，可以删除成功，键不存在时，会抛出异常
“”"
import rospy

if name == “main”:
rospy.init_node(“delete_param_p”)

try:
    rospy.delete_param("p_int")
except Exception as e:
    rospy.loginfo("删除失败")

##包含get_param/set_param/get_param_cached/get_param_names/has_param/search_param

.输入：rosparam list
/p_bool
/p_dict/age
/p_dict/name
/p_double
/p_list
/p_string
/rosdistro
/roslaunch/uris/host_kim_g3_3590__42061
/rosversion
/run_id

…执行顺序：rosrun model_02 param_set.py -----> rosrun model_02 param_get.py—>rosrun model_02 param_del.py

设置数据：rospy.prama_set(‘int’,12)—>
得到数据：int_value=rospy.param_get(‘int’)/
得到数据名称：names=rospy.param_get_names()/
得到缓存数据：cached = rospy.param_get_cached(‘int’)/
判断数据：flag = rospy.has_param(‘int’