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

| | 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中添加编译依赖与执行依赖

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

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’