ros2-rolling 参数服务通信

 

每个 ROS 2 节点都会自动创建以下服务：

• /your_node_name/set_parameters

• /your_node_name/get_parameters

参数变更流程

1. 客户端节点调用 set_parameters 服务

2. 服务器（目标）节点接收参数变更请求

3. 在服务器（目标）节点，触发注册的 param_change_callback

4. 在服务器（目标）节点，回调函数验证参数：

   • 如果有效：接受变更并返回成功

   • 如果无效：拒绝变更并返回原因

5. 在服务器（目标）节点，响应返回给客户端节点

参数类型处理

在参数客户端的节点中，在 Python 中需要显式指定参数类型

def _create_parameter_value(self, value):
    param_value = ParameterValue()
    
    if isinstance(value, float):
        param_value.type = ParameterValue.Type.DOUBLE
        param_value.double_value = value
    # ... 其他类型处理

验证机制

在参数服务的节点中，回调中实现业务逻辑验证：

if param.name == 'speed':
    if param.value < 0:
        result.successful = False
        result.reason = "速度不能为负值"

 

参数服务通信  举例1

服务器

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from rcl_interfaces.msg import SetParametersResult
from rclpy.parameter import Parameter

class ParamNode(Node):
    def __init__(self):
        super().__init__('param_node')# 节点名称，即参数服务器时使用。
        
        # 声明参数
        self.declare_parameter('speed', 1.0)
        self.declare_parameter('color', 'blue')
        self.declare_parameter('enable', True)
        
        # 添加参数变更回调
        self.add_on_set_parameters_callback(self.param_change_callback)
        
        self.get_logger().info("参数节点已启动，等待参数修改...")
    
    def param_change_callback(self, params):
        """处理参数变更的回调函数"""
        result = SetParametersResult(successful=True)
        
        for param in params:
            # 记录参数变更
            self.get_logger().info(
                f"参数变更: {param.name} = {param.value} (类型: {type(param.value).__name__})"
            )
            
            # 参数验证逻辑
            if param.name == 'speed':
                if param.value < 0:
                    result.successful = False
                    result.reason = "速度不能为负值"
                elif param.value > 10:
                    self.get_logger().warn("警告：速度超过安全阈值！")
            
            elif param.name == 'color':
                valid_colors = ['red', 'green', 'blue', 'yellow']
                if param.value not in valid_colors:
                    result.successful = False
                    result.reason = f"无效颜色，必须是 {', '.join(valid_colors)}"
            
            elif param.name == 'enable':
                # 当enable参数变化时执行特定操作
                if param.value:
                    self.get_logger().info("系统已启用")
                else:
                    self.get_logger().warn("系统已禁用")
        
        return result

def main(args=None):
    rclpy.init(args=args)
    node = ParamNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()

if __name__ == '__main__':
    main()

 

客户端

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from rcl_interfaces.srv import SetParameters
from rcl_interfaces.msg import Parameter, ParameterValue, ParameterType
import time

class ParamClient(Node):
    def __init__(self):
        super().__init__('param_client')
        self.target_node = 'param_node'  # 目标节点名称，即参数服务器
        
        # 创建参数服务客户端
        self.client = self.create_client(
            SetParameters, 
            f'/{self.target_node}/set_parameters'
        )
        
        # 等待服务可用
        while not self.client.wait_for_service(timeout_sec=1.0):
            self.get_logger().info('等待参数服务...')
        
        # 修改目标节点参数
        self.modify_parameters()
    
    def modify_parameters(self):
        """修改目标节点参数序列"""
        # 1. 修改速度参数
        self.set_param('speed', 2.5)
        time.sleep(1)
        
        # 2. 修改颜色参数
        self.set_param('color', 'green')
        time.sleep(1)
        
        # 3. 尝试设置无效速度
        self.set_param('speed', -1.0)
        time.sleep(1)
        
        # 4. 尝试设置无效颜色
        self.set_param('color', 'purple')
        time.sleep(1)
        
        # 5. 切换启用状态
        self.set_param('enable', False)
    
    def set_param(self, name, value):
        """设置单个参数"""
        param = Parameter()
        param.name = name
        param.value = self._create_parameter_value(value)
        
        request = SetParameters.Request()
        request.parameters = [param]
        
        self.get_logger().info(f"尝试设置 {name} = {value}...")
        
        future = self.client.call_async(request)
        future.add_done_callback(
            lambda future: self.param_set_callback(future, name, value))
    
    def _create_parameter_value(self, value):
        """根据Python类型创建ParameterValue"""
        param_value = ParameterValue()
        
        if isinstance(value, float):
            param_value.type = ParameterType.PARAMETER_DOUBLE
            param_value.double_value = value
        elif isinstance(value, bool):
            param_value.type = ParameterType.PARAMETER_BOOL
            param_value.bool_value = value
        elif isinstance(value, int):
            param_value.type = ParameterType.PARAMETER_INTEGER
            param_value.integer_value = value
        elif isinstance(value, str):
            param_value.type = ParameterType.PARAMETER_STRING
            param_value.string_value = value

        else:
            raise ValueError(f"不支持的参数类型: {type(value)}")
        
        return param_value
    
    def param_set_callback(self, future, name, value):
        """处理参数设置响应"""
        try:
            response = future.result()
            if response.results[0].successful:
                self.get_logger().info(f"✓ 成功设置 {name} = {value}")
            else:
                self.get_logger().error(
                    f"✗ 设置失败: {name} = {value} - 原因: {response.results[0].reason}"
                )
        except Exception as e:
            self.get_logger().error(f"服务调用失败: {str(e)}")

def main(args=None):
    rclpy.init(args=args)
    client = ParamClient()
    rclpy.spin(client)
    client.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

 

参数服务通信  举例2

客户端

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from rcl_interfaces.srv import GetParameters, SetParameters
from rcl_interfaces.msg import Parameter, ParameterValue, ParameterType
import asyncio
from typing import List, Union, Optional

class ParameterClient(Node):
    def __init__(self):
        super().__init__('parameter_client')#节点名称
        self.counter = 0
        
        # 创建服务客户端
        self.get_param_cli = self.create_client(
            GetParameters,  # 服务接口  
            'usr_get_parameters' # 服务名称
        )
        self.set_param_cli = self.create_client(
            SetParameters,       # 服务接口  srv_type
            'usr_set_parameters' # 服务名称  svr_name
        )
        
        # 服务可用性检查
        self._check_services_timer = self.create_timer(1.0, self._check_services) # 周期1.0s , 回调函数
        self._services_ready = False

    def _check_services(self) -> None:
        """检查服务可用性"""
        if not self._services_ready:
            if self.get_param_cli.service_is_ready() and self.set_param_cli.service_is_ready():
                self._services_ready = True
                self._check_services_timer.cancel()
                self.get_logger().info("✅ 参数服务已就绪")
                self.timer = self.create_timer(3.0, self._timer_callback)
            else:
                self.get_logger().info('等待参数服务...', throttle_duration_sec=5)

    def _timer_callback(self) -> None:  #在 Python 中，-> 符号是类型提示（Type Hints）的一部分，用于指定函数的返回类型
        """定时器回调（同步触发异步操作）"""       # 定时器同步触发
        self.counter += 1
        asyncio.create_task(self._demo_parameter_ops())# 异步操作

    async def _demo_parameter_ops(self) -> None: #在 Python 中，-> 符号是类型提示（Type Hints）的一部分，用于指定函数的返回类型
        """异步参数操作演示"""
        try:
            # 获取参数
            names = ['robot_speed','operation_mode']   # 参数名称 表
            values = await self._get_parameters(names) # 调方法，按名取得参数值
            
            if values:
                self.get_logger().info(
                    f"当前参数: speed={values[0].double_value}, mode={values[1].string_value}" #按序取得参数值
                )
            
            # 设置新参数
            new_speed = 1.0 + (self.counter % 3) * 0.5
            success = await self._set_parameter('robot_speed', new_speed) #异步操作，向服务器发请求和键值对，设置新值
            
            if success:
                self.get_logger().info(f"✅ 成功设置速度: {new_speed}")
            else:
                self.get_logger().error("❌ 参数设置失败")
                
        except Exception as e:
            self.get_logger().error(f"操作异常: {str(e)}", throttle_duration_sec=10)

    async def _get_parameters(self, names: List[str]) -> Optional[List[ParameterValue]]:
        """获取参数（带重试机制）"""
        req = GetParameters.Request() # 请求实例
        req.names = names # 请求实例，参数名称表
        
        for attempt in range(3):  # 最大重试3次
            try:
                future = self.get_param_cli.call_async(req) # 异步操作 实例
                await asyncio.wait_for(future, timeout=2.0) # 阻塞，等待完成
                return future.result().values   # 返回 参数名称表对应的参数值表
            except asyncio.TimeoutError:
                self.get_logger().warn(f"获取参数超时 (尝试 {attempt + 1}/3)")
            except Exception as e:
                self.get_logger().warn(f"获取参数失败: {str(e)} (尝试 {attempt + 1}/3)")
            
            await asyncio.sleep(1.0)  # 重试前等待 1.0秒
        
        self.get_logger().error(f"无法获取参数: {names}")
        return None  # 返回，空

    async def _set_parameter(
        self, 
        name: str, 
        value: Union[float, str, int, bool]
    ) -> bool:
        """设置单个参数"""
        param = Parameter()
        param.name = name
        
        if isinstance(value, float):
            param.value.type = ParameterType.PARAMETER_DOUBLE
            param.value.double_value = value
        elif isinstance(value, str):
            param.value.type = ParameterType.PARAMETER_STRING
            param.value.string_value = value
        elif isinstance(value, int):
            param.value.type = ParameterType.PARAMETER_INTEGER
            param.value.integer_value = value
        elif isinstance(value, bool):
            param.value.type = ParameterType.PARAMETER_BOOL
            param.value.bool_value = value
        else:
            raise TypeError(f"不支持的参数类型: {type(value)}")
        
        req = SetParameters.Request()
        req.parameters = [param]  # 参数名称-值 表
        
        try:
            future = self.set_param_cli.call_async(req)
            await asyncio.wait_for(future, timeout=2.0)
            return future.result().results[0].successful
        except asyncio.TimeoutError:
            self.get_logger().error("设置参数超时")
            return False
        except Exception as e:
            self.get_logger().error(f"设置参数失败: {str(e)}")
            return False

def main(args=None):
    rclpy.init(args=args)
    node = ParameterClient()
    
    try:
        # 使用单线程执行器
        executor = rclpy.executors.SingleThreadedExecutor()
        executor.add_node(node)
        
        # 创建新的事件循环
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
        
        async def spin():
            while rclpy.ok():
                executor.spin_once(timeout_sec=0.1)
                await asyncio.sleep(0.1)  # 让出控制权
        
        loop.run_until_complete(spin())#事件循环
        
    except KeyboardInterrupt:
        node.get_logger().info("关闭节点...")
    except Exception as e:
        node.get_logger().error(f"节点异常: {str(e)}")
    finally:
        node.destroy_node()
        rclpy.shutdown()
        # 清理事件循环        loop.close()

if __name__ == '__main__':
    main()

 

 

服务器

# export RCUTILS_CONSOLE_OUTPUT_FORMAT =[{function_name}:{line_number}:{message}]

# echo "export RCUTILS_CONSOLE_OUTPUT_FORMAT='[{file_name}:{line_number}:{name}] {message}'" >> ~/.bashrc

# pakage.xml 中的依赖项 <depend>rclpy</depend>

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from rcl_interfaces.srv import GetParameters, SetParameters
from rcl_interfaces.msg import Parameter, ParameterValue, ParameterType, SetParametersResult
from rclpy.parameter import Parameter as Param
# export RCUTILS_CONSOLE_OUTPUT_FORMAT =[{function_name}:{line_number}:{message}]
#echo "export RCUTILS_CONSOLE_OUTPUT_FORMAT='[{file_name}:{line_number}:{name}] {message}'" >> ~/.bashrc
class ParameterServer(Node):
    def __init__(self):
        super().__init__('parameter_server')
        
        # 声明可共享的参数
        self.declare_parameter('robot_speed', 1.0)
        self.declare_parameter('operation_mode', 'normal')#operation_mode
        self.declare_parameter('battery_level', 95)
        
        # 提供参数服务
        self.get_srv = self.create_service(
            GetParameters, 
            'usr_get_parameters',
            self.handle_get_params
        )
        
        self.set_srv = self.create_service(
            SetParameters,
            'usr_set_parameters',
            self.handle_set_params
        )
        
        self.get_logger().info("🟢 参数服务已启动")

    def handle_get_params(self, request, response):
        """处理参数查询请求"""
        response.values = []
        for name in request.names:
            self.get_logger().info(f"参数名: {name}")
            if self.has_parameter(name):
                param = self.get_parameter(name) # 在节点内，按参数名取得变量值
                p_value = ParameterValue() # 参数对象实例
                
                # 根据参数类型填充值
                if param.type_ == Param.Type.DOUBLE:
                    p_value.double_value = param.value # 参数变量，赋值
                    p_value.type = ParameterType.PARAMETER_DOUBLE
                elif param.type_ == Param.Type.STRING:
                    p_value.string_value = param.value # 参数变量，赋值
                    p_value.type = ParameterType.PARAMETER_STRING
                elif param.type_ == Param.Type.INTEGER:
                    p_value.integer_value = param.value # 参数变量，赋值
                    p_value.type = ParameterType.PARAMETER_INTEGER
                
                response.values.append(p_value)  # 参数变量，赋值
                self.get_logger().info(f"已知参数: {name}:{p_value}")
            else:
                self.get_logger().info(f"未知参数: {name}")
                response.values.append(ParameterValue())  # 加入参数的值
     
        return response # 返回

    def handle_set_params(self, request, response):
        """处理参数设置请求"""
        results = []
        for param in request.parameters: #参数名称-值 表
            try:
                # 参数验证逻辑
                if param.name == 'robot_speed' and param.value.double_value < 0:
                    raise ValueError("速度不能为负值")
                
                # 更新参数
                self.set_parameters([Param.from_parameter_msg(param)]) # 重新设置参数名-值
                results.append(True)
                self.get_logger().info(f"更新参数: {param.name}={param.value}")
            except Exception as e:
                self.get_logger().error(f"参数设置失败: {str(e)}")
                results.append(False)
        
        response.results = [SetParametersResult(successful=r) for r in results] # 服务应答
        return response

def main(args=None):
    rclpy.init(args=args)
    node = ParameterServer()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()