ROS通信方式（保姆级教程）

ROS通信方式

主题

前言

工作空间: catkin_ws1

ROS功能包: xhgpfk

c++文件: xhgfk.cpp和sudujieshou.cpp

定义一个可执行文件: luguoqin

发布器编程实例：小海龟速度控制

对ROS的小海龟来说，速度的控制主题为/turtle1/cmd_vel,只需要对这个主题发送ge-ometry_msgs::Twist这个信息包就可以对小海龟的速度进行调控了。

ge-ometry_msgs::Twist：里面有两个部分速度值，第一个为linear,它表示在机器人的x、y、z、三个方向上，单位是m/s,第二个为angular,它表示在机器人的x、y、z、三个方向上，单位是弧度/s。

步骤如下

Ctrl+Alt+T打开终端

i.创建ROS工作空间

	mkdir -p ~/catkin_ws1/src

ROSA2

ii.切换到catkin_ws1 工作空间内的 src 目录

	cd ~/catkin_ws1/src

ROSA3

iii.初始化一个新的 catkin 工作空间(前提一定要在“工作空间”下的“src 目录”)

	catkin_init_workspace

ROSA4

iv.切换到catkin_ws1 工作空间

	cd ~/catkin_ws1/

ROSA5

v.编译(前提一定要在“工作空间”下)

	catkin_make

ROSA6

可以看到出现build、devel、src，3个文件夹

ROSA10

vi.使 ROS 工作空间的环境变量在每次打开新的终端时自动设置(里面的catkin_ws1要换成自己的“工作空间”)

	echo "source ~/catkin_ws1/devel/setup.bash" >> ~/.bashrc

ROSA7

vii.重新执行 ~/.bashrc 文件中的所有命令

ROSA8

viii.切换到catkin_ws1 工作空间内的 src 目录

	cd ~/catkin_ws1/src

ROSA9

ix.创建新的 ROS 包(xhgpfk为包名，可以自己更改)

catkin_create_pkg用于创建新的 ROS 包的命令行工具

	catkin_create_pkg xhgpfk roscpp geometry_msgs

ROSA11

x.打开VSC(Visual Studio Code)点击File（文件）点击Open Folder(打开文件夹)选择“编译空间”的文件

ROSA12

xi.点击“编译空间”的文件的src看到ROS功能包的src鼠标右键单击创建一个c++文件（是在第二个src创建），例如：xhgfk.cpp

ROSA14

ROSA24

ROSA15

xii.i.小海龟的圆形代码如下：

#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
int main(int argc, char** argv)
{
    // 初始化ROS节点
    ros::init(argc, argv, "velocity_publisher");
// 创建节点句柄
	ros::NodeHandle n;

// 创建一个发布者，发布/turtle1/cmd_vel话题，消息队列大小为20
	ros::Publisher vel_pub = 			n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 20);

// 设置循环频率为10Hz
ros::Rate loop_rate(10);

while(ros::ok())
{
    // 创建Twist消息
    geometry_msgs::Twist vel_cmd;
    vel_cmd.linear.x = 2;
    vel_cmd.linear.y = 0;
    vel_cmd.linear.z = 0;
    vel_cmd.angular.x = 0;
    vel_cmd.angular.y = 0;
    vel_cmd.angular.z = 1.8;

    // 发布消息
    vel_pub.publish(vel_cmd);

    // 处理回调函数
    ros::spinOnce();

    // 按照设定的循环频率休眠
    loop_rate.sleep();
}

return 0;
}

xii.ii.小海龟的矩形代码如下：

#include <ros/ros.h>
#include <geometry_msgs/Twist.h>

int main(int argc, char** argv)
  {
    ros::init(argc, argv, "turtle_vel_ctrl_node");
    ros::NodeHandle n;

    ros::Publisher vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 20);
    ros::Rate loop_rate(2);

    int count = 0;

    while(ros::ok())
    {
      geometry_msgs::Twist vel_cmd;
      vel_cmd.linear.x = 1.0;
      vel_cmd.linear.y = 0.0;
      vel_cmd.linear.z = 0.0;
      vel_cmd.angular.x = 0.0;
      vel_cmd.angular.y = 0.0;
      vel_cmd.angular.z = 0.0;

      if(count == 5)
        {
          vel_cmd.angular.z = 3.1415926; // Change angular velocity when count reaches 5
          count = 0; // Reset count
        }
      else
        {
          count++; // Increment count
        }

      vel_pub.publish(vel_cmd);
      ros::spinOnce();
      loop_rate.sleep();
    }

      return 0;
  }

注意：以下是拿小海龟的矩形来写，圆形也一样

xiii.在下面找到CMakeLists.txt，在最后面（第207行开始）添加代码进行编译（你的c++是什么名字就改为什么名字xhgfk.cpp）,(luguoqin这个可以改一个随便的)

add_executable(luguoqin src/xhgfk.cpp)
add_dependencies(luguoqin ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(luguoqin ${catkin_LIBRARIES})

xiv.切换到 catkin_ws1 工作空间

	cd ~/catkin_ws1/

ROSA5

xv.在创建或修改了 ROS 包后，需要使用 catkin_make 来编译这些更改

	catkin_make

ROSA16

ROSA17

xvi.Ctrl+Alt+T打开终端

xvii.用于启动 ROS 的节点

	roscore

ROSA22

xiii.用于运行 ROS 节点

	rosrun turtlesim turtlesim_node

ROSA20

xix.运行小海龟跑矩形的指令

	rosrun xhgpfk luguoqin

ROSA21

实现效果

ROSA23

订阅器编程实例：小乌龟速度接收

在ROS（机器人操作系统）中，订阅器（Subscriber）是一种节点，它订阅特定的话题（Topic），以接收并处理发布器（Publisher）发布的消息。

i.打开vscode

ii.点击“编译空间”的文件的src看到ROS功能包的src鼠标右键单击创建一个c++文件（是在第二个src创建），例如：xhgfk.cpp

ROSA25

iii.在创建的c++文件添加代码

	#include <ros/ros.h>
#include <geometry_msgs/Twist.h>

// 回调函数，用于处理接收到的消息
void callback(const geometry_msgs::Twist& cmd_vel) {
    ROS_INFO("Received a /turtle1/cmd_vel message!");
    ROS_INFO("Linear Velocity: [%f, %f, %f]",
             cmd_vel.linear.x, cmd_vel.linear.y, cmd_vel.linear.z);
    ROS_INFO("Angular Velocity: [%f, %f, %f]",
             cmd_vel.angular.x, cmd_vel.angular.y, cmd_vel.angular.z);
}

int main(int argc, char** argv) {
    // 初始化ROS节点
    ros::init(argc, argv, "turtle_vel_rece_node");

    // 创建节点句柄
    ros::NodeHandle n;

    // 创建一个订阅者，订阅/turtle1/cmd_vel话题，缓冲区大小为1000
    ros::Subscriber sub = n.subscribe("/turtle1/cmd_vel", 1000, callback);

    // 进入循环，等待回调函数被调用
    ros::spin();

    // 正常情况下，ros::spin()不会返回，除非ROS被关闭
    // 所以这里实际上不会执行到return语句
    return 0;
}

iv.在下面找到CMakeLists.txt，在最后面（第211行开始）添加代码进行编译（你的c++是什么名字就改为什么名字lihaitong.cpp）,(lihaitong这个可以改一个随便的)

add_executable(lihaitong src/lihaitong.cpp)
add_dependencies(lihaitong ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(lihaitong ${catkin_LIBRARIES})

v.切换到 catkin_ws1 工作空间

	cd ~/catkin_ws1/

ROSA5

vi.在创建或修改了 ROS 包后，需要使用 catkin_make 来编译这些更改

	catkin_make

ROSA16

ROSA17

vii.Ctrl+Alt+T打开终端

viii.用于启动 ROS 的节点

	roscore

ROSA22

ix.用于运行 ROS 节点

	rosrun turtlesim turtlesim_node

ROSA20

x.运行小海龟跑矩形的指令

	rosrun xhgpfk luguoqin

ROSA21

xi.运行小海龟速度接收的指令

	rosrun xhgpfk lihaitong

ROSA26

xii.显示当前ROS里的节点网络情况

	rqt_graph

ROSA27

服务

概述

与Topie（主题）不同，Service（服务）通信是双向的，它不仅可以发送反馈。一个服务（Service）被分成服务端（Server）和客户端（Client)，分别对应节点A和节点B，两个都要到主节点管理器进行注册。在主节点管理器的管理下，节点B（客户端）向节点A（服务端）发送请求，节点A（服务端）响应该请求，实现节点之间的双向通信。在请求机器人执行特定操作时，或者根据特定条件需要产生响应事性时，通常使用Service（服务）。

前言

工作空间: catkin_ws1（和上面是同一个工作空间）

ROS功能包: xhgpfk

c++文件: fuwu.cpp和kewu.cpp

srv文件: ServiceClientExMsg.srv

定义一个可执行文件: fuwu和kewu

自定义src消息文件

步骤如下

i.在上面的catkin_ws1工作空间里创建新的ROS功能包,(service_client_pkg为包名，可以自己更改)catkin_create_pkg用于创建新的 ROS 包的命令行工具.

	cd ~/catkin_ws1/src/

	catkin_create_pkg service_client_pkg roscpp std_msgs

ii.进入service_client_pkg文件夹创建srv来放.srv文件

	cd service_client_pkg
	mkdir srv

iii.打开vscode再打开catkin_ws1文件，找到service_client_pkg子文件的srv文件，点击srv鼠标右键创建ServiceClientExMsg.srv,在里面写入代码

string name
---
bool in_class
bool boy
int32 age
string personality

iv.编写完成后在service_client_pkg文件下的package.xml，在59行开始添加下面语句

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

v.添加完成后在service_client_pkg文件下的CMakeLists.txt，内容修改。

#大概第10~18行
find_package(catkin REQUIRED COMPONENTS
  roscpp
  rospy
  message_generation
  std_msgs
  std_srvs
)

#大概第61~65行
add_service_files(
  FILES
  ServiceClientExMsg.srv
  # Service2.srv
)

#大概第75~78行
generate_messages(
  DEPENDENCIES
  std_msgs
)

#大概第109~115行
catkin_package(
 INCLUDE_DIRS include
 LIBRARIES service_client_pkg
 CATKIN_DEPENDS roscpp std_msgs
 DEPENDS system_lib
 CATKIN_DEPENDS message_runtime
)

vi.在工作空间进行代码编译

	cd ~/catkin_ws1

	catkin_make

服务端编程

步骤如下

i.打开vscode再打开catkin_ws1文件，找到service_client_pkg子文件的src文件，点击src鼠标右键创建fuwu.cpp,在里面写入代码

#include <ros/ros.h>

#include <service_client_pkg/ServiceClientExMsg.h> // 注意文件扩展名应该是 .h 而不是 .hx

using namespace std;


bool infoInquiry(service_client_pkg::ServiceClientExMsgRequest& request, 
                 service_client_pkg::ServiceClientExMsgResponse& response) {
    ROS_INFO("Callback activated");
    string inputName = request.name;
    response.in_class = false;

    if (inputName.compare("Tom") == 0) {
        ROS_INFO("Student information about Tom");
        response.in_class = true;
        response.boy = true;
        response.age = 20;
        response.personality = "outgoing";
    } else if (inputName.compare("Mary") == 0) {
        ROS_INFO("Student information about Mary");
        response.in_class = true;
        response.boy = false;
        response.age = 21;
        response.personality = "introverted";
    }
    return true;
}

int main(int argc, char **argv) {
    ros::init(argc, argv, "service_example_node");
    ros::NodeHandle n;
    ros::ServiceServer service = n.advertiseService("info_inquiry_by_name", infoInquiry);
    ROS_INFO("Ready to inquiry names.");
    ros::spin();
    return 0;
}

ii.写完后在service_client_pkg文件下的CMakeLists.txt，在最后面添加编译规则

add_executable(fuwu src/fuwu.cpp)
add_dependencies(fuwu ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(fuwu ${catkin_LIBRARIES})

iii.切换到 catkin_ws1 工作空间

	cd ~/catkin_ws1/

iv.在创建或修改了 ROS 包后，需要使用 catkin_make 来编译这些更改

	catkin_make

v.Ctrl+Alt+T打开终端

x.用于启动 ROS 的节点

	roscore

vi.用于运行 fuwu 节点

	rosrun service_client_pkg fuwu

vii.测试节点是否正常反馈信息

	rosservice call /info_inquiry_by_name "Tom"

实现效果

ROSC1

客户端编程

步骤如下

i.打开vscode再打开catkin_ws1文件，找到service_client_pkg子文件的src文件，点击src鼠标右键创建kehu.cpp,在里面写入代码

#include <ros/ros.h>
#include <service_client_pkg/ServiceClientExMsg.h>
#include <iostream>
#include <string>

using namespace std;

int main(int argc, char **argv)
{
    ros::init(argc, argv, "client_example_node");
    ros::NodeHandle n;

    ros::ServiceClient client = n.serviceClient<service_client_pkg::ServiceClientExMsg>("info_inquiry_by_name");
    service_client_pkg::ServiceClientExMsg srv;

    string input_name;

    while(ros::ok())
    {
        cout << endl;
        cout << "Enter a name (q to quit): ";
        cin >> input_name;

        if (input_name.compare("q") == 0)
        {
            return 0;
        }

        srv.request.name = input_name;

        if (client.call(srv))
        {
            if (srv.response.in_class)
            {
                if (srv.response.boy)
                {
                    cout << srv.request.name << " is a boy;" << endl;
                }
                else
                {
                    cout << srv.request.name << " is a girl;" << endl;
                }
                cout << srv.request.name << " is " << srv.response.age << " years old;" << endl;
                cout << srv.request.name << " has a " << srv.response.personality << " personality." << endl;
            }
            else
            {
                cout << srv.request.name << " is not in class" << endl;
            }
        }
        else
        {
            ROS_ERROR("Failed to call service info_inquiry_byname");
            return 1;
        }
    }

    return 0;
}

ii.写完后在service_client_pkg文件下的CMakeLists.txt，在最后面添加编译规则

add_executable(kehu src/kehu.cpp)
add_dependencies(kehu ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(kehu ${catkin_LIBRARIES})

iii.切换到 catkin_ws1 工作空间

	cd ~/catkin_ws1/

iv.在创建或修改了 ROS 包后，需要使用 catkin_make 来编译这些更改

	catkin_make

v.Ctrl+Alt+T打开终端

x.用于启动 ROS 的节点

	roscore

vi.用于运行 fuwu 节点

	rosrun service_client_pkg fuwu

vii.用于运行 kehu 节点

	rosrun service_client_pkg kehu

viii.输入Tom

实现效果

ROSC6

ROSC7

动作库

概述

Actionlib（动作库）是 ROS中一个很重要的库，类似Service 通信方式，Actionlib 也是一种请求响应机制的通信方式。在Service通信方式中，当客户端发送一个请求后，只有当它接收到服务端的响应信息才能执行其他操作，而 Actionlib 通信就不受这种限制、它采用Action-server 服务端与 Action-client 客户端通信机制，Action-client 客户端对 Action-server服务端发出一个请求后，还可以执行其他操作，比较适合需要长时间的通信过程。同时Action-server 服务端用来不断向 Action-client客户端反馈任务的进度，还支持在任务中途中止运行。

前言

工作空间: catkin_ws1（和上面是同一个工作空间）

ROS功能包: actionlib_example_pkg

c++文件: actionlib_client_node.cpp和actionlib_server_node.cpp

action文件: ActionlibExMsg.action

定义一个可执行文件: fuwu

自定义action消息文件

步骤如下

i.在上面的catkin_ws1工作空间里创建新的ROS功能包,(actionlib_example_pkg为包名，可以自己更改)catkin_create_pkg用于创建新的 ROS 包的命令行工具.

	cd ~/catkin_ws1/src/

	catkin_create_pkg actionlib_example_pkg roscpp actionlib actionlib_msgs

ii.进入actionlib_example_pkg文件夹创建action来放.action文件

	cd actionlib_example_pkg
	mkdir action

iii.打开vscode再打开catkin_ws1文件，找到actionlib_example_pkg子文件的action文件，点击action鼠标右键创建ActionlibExMsg.action,在里面写入代码

#goal definition
int32 whole_distance
---
#result definition
bool is_finish
---
#feedback
int32 moving_meter

iv.编写完成后在actionlib_example_pkg文件下的package.xml，在59行开始添加下面语句

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

v.添加完成后在actionlib_example_pkg文件下的CMakeLists.txt，内容修改。

#大概是64~69行
## Generate actions in the 'action' folder
add_action_files(
    FILES
    ActionlibExMsg.action
)

#大概是71~75行
## Generate added messages and services with any dependencies listed here
  generate_messages(
    DEPENDENCIES
    actionlib_msgs
  )

vi.在工作空间进行代码编译

	cd ~/catkin_ws1

	catkin_make

客户端编程

步骤如下

i.打开vscode再打开catkin_ws1文件，找到actionlib_example_pkg子文件的src文件，点击src鼠标右键创建actionlib_client_node.cpp,在里面写入代码

#include <actionlib/client/simple_action_client.h>
#include <actionlib_example_pkg/ActionlibExMsgAction.h>

// Action完成后调用的回调函数
void doneCb(const actionlib::SimpleClientGoalState& state,
            const actionlib_example_pkg::ActionlibExMsgResultConstPtr& result)
{
    ROS_INFO("Task completed!");
    ros::shutdown();
}

// Action激活时调用的回调函数
void activeCb()
{
    ROS_INFO("Goal is active! The robot begins to move forward.");
}

// Action执行过程中接收反馈的回调函数
void feedbackCb(const actionlib_example_pkg::ActionlibExMsgFeedbackConstPtr& feedback)
{
    ROS_INFO("The robot has moved forward %d meters.", feedback->moving_meter);
}

int main(int argc, char** argv)
{
    ros::init(argc, argv, "actionlib_client_node");

    // 创建一个action的client，指定action名称为“moving_forward”
    actionlib::SimpleActionClient<actionlib_example_pkg::ActionlibExMsgAction> client("moving_forward", true);

    ROS_INFO("Waiting for action server to start");
    client.waitForServer(); // 等待服务器响应
    ROS_INFO("Action server started");

    // 创建一个目标：移动机器人前进10m
    actionlib_example_pkg::ActionlibExMsgGoal goal;
    goal.whole_distance = 10;

    // 把action的任务目标发送给服务器，绑定上面定义的各种回调函数
    client.sendGoal(goal, &doneCb, &activeCb, &feedbackCb);

    ros::spin();

    return 0;
}

ii.写完后在actionlib_example_pkg文件下的CMakeLists.txt，在最后面添加编译规则

add_executable(actionlib_client_node src/actionlib_client_node.cpp)
add_dependencies(actionlib_client_node ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(actionlib_client_node ${catkin_LIBRARIES})

iii.切换到 catkin_ws1 工作空间

cd ~/catkin_ws1/

iv.使用 catkin_make 来编译这些更改

catkin_make

服务端编程

步骤如下

i.打开vscode再打开catkin_ws1文件，找到actionlib_example_pkg子文件的src文件，点击src鼠标右键创建actionlib_server_node.cpp,在里面写入代码

#include <ros/ros.h>

#include <actionlib/server/simple_action_server.h>

#include <actionlib_example_pkg/ActionlibExMsgAction.h>

// 服务器接收任务目标后，调用该函数执行任务
void execute(const actionlib_example_pkg::ActionlibExMsgGoalConstPtr& goal,
             actionlib::SimpleActionServer<actionlib_example_pkg::ActionlibExMsgAction>* as) {
    ros::Rate r(0.5);
    actionlib_example_pkg::ActionlibExMsgFeedback feedback;

    ROS_INFO("Task: The robot moves forward %d meters.", goal->whole_distance);

    for(int i = 1; i <= goal->whole_distance; ++i) {
        feedback.moving_meter = i;
        as->publishFeedback(feedback); // 反馈任务执行的过程
        r.sleep();
    }

    ROS_INFO("Task completed!");
    as->setSucceeded();
}

int main(int argc, char** argv) {
    ros::init(argc, argv, "actionlib_server_node");
    ros::NodeHandle n;

    // 创建一个action的server，指定action名称为"moving_forward"
    actionlib::SimpleActionServer<actionlib_example_pkg::ActionlibExMsgAction> server(
        n, "moving_forward", boost::bind(&execute, _1, &server), false);

    // 服务器启动
    server.start();

    ros::spin();

    return 0;
}

ii.写完后在actionlib_example_pkg文件下的CMakeLists.txt，在最后面添加编译规则

add_executable(actionlib_server_node src/actionlib_server_node.cpp)
add_dependencies(actionlib_server_node ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(actionlib_server_node ${catkin_LIBRARIES})

iii.切换到 catkin_ws1 工作空间

cd ~/catkin_ws1/

iv.使用 catkin_make 来编译这些更改

catkin_make

v.Ctrl+Alt+T打开终端

x.用于启动 ROS 的节点

roscore

vi.用于运行 actionlib_client_node 节点

rosrun actionlib_example_pkg actionlib_client_node

vii.用于运行 actionlib_server_node 节点

rosrun actionlib_example_pkg actionlib_server_node

viii.打开ROS的节点网络

rqt_graph

参数服务器

概述

机器人工作时，经常需要用到参数传递功能，可以事先将一些不需要经常变动的常量（如机器人的轮廓、传感器参数、算法的参数等)保存到Parameter Server（参数服务器），在需要用到参数的时候再从参数服务器中获取。

参数信息一般写入yaml 文件中，通过命令行指令或 launch 文件可以实现对yawl文件的调用，从而进一步实现对文件中参数的读取。

前言

工作空间: catkin_ws1（和上面是同一个工作空间）

ROS功能包: parameter_server_pkg

c++文件: get_parameter_node.cpp

launch文件: para_load.launch
yaml文件: para_setting.yaml

定义一个可执行文件: lgq

创建yaml文件

步骤如下

i.在上面的catkin_ws1工作空间里创建新的ROS功能包,(parsmeter_server_pkg为包名，可以自己更改)catkin_create_pkg用于创建新的 ROS 包的命令行工具.

	cd ~/catkin_ws1/src/

	catkin_create_pkg parsmeter_server_pkg roscpp std_msgs

ii.进入parsmeter_server_pkg文件夹创建launch来放.yaml文件

	cd parsmeter_server_pkg
	mkdir launch

iii.打开vscode再打开catkin_ws1文件，找到parameter_server_pkg子文件的launch文件，点击launch鼠标右键创建para_setting.yaml,在里面写入代码

kinect_height: 0.34
kinect_pitch: 1.54

加载yaml文件

在获取yaml文件中的参数信息之前，需要先加载yaml文件。加载yaml 文件有如下两种方法：通过rosparam 指令加载或通过 launch 文件加载。

通过rosparam 指令加载

i.Ctrl+Alt+T打开终端,用于启动 ROS 的节点

roscore

ii.Ctrl+Alt+T打开终端,切换到para_setting.yaml目录下，再加载para_setting.yaml文件

cd ~/catkin_ws1/src/parsmeter_server_pkg/launch
rosparam load para_setting.yaml

iii.用rosparam list观看加载的参数(可选)

rosparam list

iv.用rosparam get /kinect_height查看数值(可选)

rosparam get /kinect_height

v.用rosparam set /kinect_height 0.4(可选)

	rosparam set /kinect_height 0.4

想让变更值保留再yaml中，请输入如下命令

	rosparam dump para_setting.yaml

通过roslaunch 指令加载

i.打开 Visual Studio Code，在parameter_server_pkg文件夹的launch子文件夹上单击鼠标右键，选择New File 新建一个名为para_load.launch的代码文件。

ii.编写para_load.launch代码

<launch>
    <rosparam command="load" file="$(find parsmeter_server_pkg)/launch/para_setting.yaml"/>
</launch>

iii.Ctrl+Alt+T打开终端,用于启动 launch文件

roslaunch parsmeter_server_pkg para_load.launch

iv.用rosparam.list观看加载的参数(可选)

rosparam list

在节点中进行参数读取

步骤如下

i.打开 Viwual Studio Code，在parameter_server_pkg 文件夹下的src子文件夹上单击鼠标右键，选择New File 新建一个代码文件。新建的代码文件命名为get_parameter_node.cpp

ii.编写get_parameter_node.cpp代码

#include <ros/ros.h>

int main(int argc, char **argv) {
    // 初始化ROS节点
    ros::init(argc, argv, "get_parameter_node");

    // 创建节点句柄
    ros::NodeHandle nh; // 节点句柄

    // 定义变量
    double kinect_height_getting, kinect_pitch_getting;

    // 尝试从参数服务器获取参数
    if (nh.getParam("/kinect_height", kinect_height_getting)) {
        ROS_INFO("kinect_height set to %f", kinect_height_getting);
    } else {
        ROS_WARN("could not find parameter value /kinect_height on parameter server");
    }

    if (nh.getParam("/kinect_pitch", kinect_pitch_getting)) {
        ROS_INFO("kinect_pitch set to %f", kinect_pitch_getting);
    } else {
        ROS_WARN("could not find parameter value /kinect_pitch on parameter server");
    }

    // 保持节点运行，直到被终止
    ros::spin();

    return 0;
}

iii.写完后在parameter_server_pkg文件下的CMakeLists.txt，在最后面添加编译规则

add_executable(lgq src/get_parameter_node.cpp)
add_dependencies(lgq ${${PROJECT_NAME}_EXPORTED_TARGETS}
${catkin_EXPORTED_TARGETS})
target_link_libraries(lgq ${catkin_LIBRARIES})

iv.切换到 catkin_ws1 工作空间

	cd ~/catkin_ws1/

v.在创建或修改了 ROS 包后，需要使用 catkin_make 来编译这些更改

	catkin_make

vi.Ctrl+Alt+T打开终端,运行launch文件

roslaunch parsmeter_server_pkg para_load.launch

vii.Ctrl+Alt+T打开终端,运行lgq节点

rosrun parsmeter_server_pkg lgq

posted @ 2024-10-16 02:33 LGQLHT 阅读(416) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· opencv 项目

· STM32单片机做智能宠物狗项目

· ROS学习记录

· ROS学习第六天

· ROS节点通信学习总结

公告

昵称： LGQLHT
园龄： 5个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔分类

随笔档案

2024年10月(6)

lgqlht

ROS通信方式（保姆级教程）

ROS通信方式

主题

前言

发布器编程实例：小海龟速度控制

步骤如下

注意：以下是拿小海龟的矩形来写，圆形也一样

实现效果

订阅器编程实例：小乌龟速度接收

服务

概述

前言

自定义src消息文件

步骤如下

服务端编程

步骤如下

实现效果

客户端编程

步骤如下

实现效果

动作库

概述

前言

自定义action消息文件

步骤如下

客户端编程

步骤如下

服务端编程

步骤如下

参数服务器

概述

前言

创建yaml文件

步骤如下

加载yaml文件

通过rosparam 指令加载

通过roslaunch 指令加载

在节点中进行参数读取

步骤如下

公告

搜索

常用链接

合集

随笔分类

随笔档案

相册

阅读排行榜

评论排行榜

最新评论