ROS相关知识点

SabrinaW711

已于 2023-09-22 11:57:21 修改

阅读量134

点赞数

文章标签：人工智能

于 2023-09-08 16:12:32 首次发布

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_46118358/article/details/132761774

版权

目录

ROS核心概念

节点(Node) — 执行单元

节点管理器(ROS Master) — 控制中心

参数(parameter) — 全局共享字典

编辑话题(Topic) 一异步通信机制

消息(Message) 一话题数据

服务(Service) 一同步通信机制

话题 VS 服务

创建工作空间与功能包

话题(Topic)编程实现

发布者Publisher的编程实现

订阅者Subscriber的编程实现

话题消息的定义与使用

服务(Service)编程实现

客户端Client的编程实现

服务端Server的编程实现

开发环境：Ubuntu 20.04 Noetic

图文皆摘录于【古月居】古月·ROS入门21讲 | 一学就会的ROS机器人入门教程

代码仓库地址：guyuehome/ros_21_tutorials: 《古月 · ROS入门21讲》课件&源码 (github.com)

ROS核心概念

节点(Node) — 执行单元

（1）执行具体任务的进程、独立运行的可执行文件；
（2）不同节点可使用不同的编程语言，可分布式运行在不同的主机；
（3）节点在系统中的名称必须是唯一的。

节点管理器(ROS Master) — 控制中心

（1）为节点提供命名和注册服务；
（2）跟踪和记录话题 / 服务通信，辅助节点相互查找、建立连接；
（3）提供参数服务器，节点使用此服务器存储和检索运行时的参数。

参数(parameter) — 全局共享字典

（1）可通过网络访问的共享、多变量字典；
（2）节点使用参数服务器来存储和检索运行时的参数；
（3）适合存储静态、非二进制的配置参数，不适合存储动态配置的数据。

话题(Topic) 一异步通信机制

（1）节点间用来传输数据的重要总线；
（2）使用发布/订阅模型，数据由发布者传输到订阅者，同一个话题的订阅者或发布者可以不唯一

消息(Message) 一话题数据

（1）具有一定的类型和数据结构，包括ROS提供的标准类型和用户自定义类型；
（2）使用与编程语言无关的.msg文件定义，编译过程中生成对应的代码文件。

服务(Service) 一同步通信机制

（1）使用客户端 / 服务器 (C/S) 模型,客户端发送请求数据,服务器完成处理后返回应答数据；
（2）使用编程语言无关的.srv文件定义请求和应答数据结构，编译过程中生成对应的代码文件。

话题 VS 服务

ROS命令

$ roscore                                              //启动ROS Master
# rosrun + 功能包 + 节点
$ rosrun turtlesim turtlesim_node                      //启动小海龟仿真器节点
$ rosrun turtlesim turtle_teleop_key                   //启动海龟键盘控制节点

$ rqt_graph                                           //展示所有节点以及话题

$ rosnode	            
$ rostopic
$ rosservice
$ rosbag

# rostopic pub + 话题 + 消息结构 + 消息具体数据 （只发一次）
$ rostopic pub /turtle1/cmd_vel geometry_msgs/Twist "linear:
  x: 1.0
  y: 0.0
  z: 0.0
angular:
  x: 0.0
  y: 0.0
  z: 0.0" 

# -r 10 1s发10次（循环发）
$ rostopic pub -r 10 /turtle1/cmd_vel geometry_msgs/Twist "linear:
  x: 1.0
  y: 0.0
  z: 0.0
angular:
  x: 0.0
  y: 0.0
  z: 1.0" 

# 展示消息具体信息
$ rosmsg show geometry_msgs/Twist

# 派生新的海龟
$ rosservice call /spawn "x: 0.0
y: 0.0
theta: 0.0
name: 'turtle2'" 
name: "turtle2"

创建工作空间与功能包

# 创建工作空间
$ mkdir -p ~/catkin_ws/src
$ cd ~/catkin_ws/src
$ catkin_init_workspace

# 编译工作空间
$ cd ~/catkin_ws
$ catkin_make
$ catkin_make install

# 创建功能包 
# catkin_create_pkg + 包名 + 依赖
$ catkin_create_pkg test_pkg roscpp rospy std_msgs

# 设置环境变量(重要)
$ source devel/setup.bash

src:功能包的源码

install 安装空间(开发后):最终编译生成的可执行文件

devel 开发空间(开发中):开发过程中生成的可执行文件以及一些库

build: 编译过程中的一些中间文件（二进制文件）

src:功能包的代码

include:头文件

话题(Topic)编程实现

发布者Publisher的编程实现

C++

$ cd ~/catkin_ws/src
# 创建功能包
$ catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim

# 创建velocity_publisher.cpp文件
$ touch velocity_publisher.cpp

# 如何实现一个发布者？
# （1）初始化ROS节点；
# （2）向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型；
# （3）创建消息数据；
# （4）按照一定频率循环发布消息。

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs::Twist
 */
 
#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;

	// 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
	ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 10);

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

	int count = 0;
	while (ros::ok())
	{
	    // 初始化geometry_msgs::Twist类型的消息
		geometry_msgs::Twist vel_msg;
		vel_msg.linear.x = 0.5;
		vel_msg.angular.z = 0.2;

	    // 发布消息
		turtle_vel_pub.publish(vel_msg);
		ROS_INFO("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]", 
				vel_msg.linear.x, vel_msg.angular.z);

	    // 按照循环频率延时
	    loop_rate.sleep();
	}

	return 0;
}

# 将下列代码加到CMakeLists.txt
# 如何配置 CMakeLists.txt 中的编译规则
# · 设置需要编译的代码和生成的可执行文件
# · 设置链接库
$ add_executable(velocity_publisher src/velocity_publisher.cpp)
$ target_link_libraries(velocity_publisher ${catkin_LIBRARIES})

# 编译并运行发布者
$ cd ~/catkin_ws
$ catkin_make

# 设置环境变量并将语句加入到.bashrc
$ source devel/setup.bash

$ roscore
//启动小海龟仿真器节点
$ rosrun turtlesim turtlesim_node
$ rosrun learning_topic velocity_publisher

Python

# 创建velocity_publisher.py文件
$ touch velocity_publisher.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

########################################################################
####          Copyright 2020 GuYueHome (www.guyuehome.com).          ###
########################################################################

# 该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs::Twist

import rospy
from geometry_msgs.msg import Twist

def velocity_publisher():
	# ROS节点初始化
    rospy.init_node('velocity_publisher', anonymous=True)

	# 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
    turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

	#设置循环的频率
    rate = rospy.Rate(10) 

    while not rospy.is_shutdown():
		# 初始化geometry_msgs::Twist类型的消息
        vel_msg = Twist()
        vel_msg.linear.x = 0.5
        vel_msg.angular.z = 0.2

		# 发布消息
        turtle_vel_pub.publish(vel_msg)
    	rospy.loginfo("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]", 
				vel_msg.linear.x, vel_msg.angular.z)

		# 按照循环频率延时
        rate.sleep()

if __name__ == '__main__':
    try:
        velocity_publisher()
    except rospy.ROSInterruptException:
        pass

# 直接运行脚本文件不需要编译，但是运行前记得改文件属性，允许文件作为程序执行
$ python3 velocity_publisher.py

订阅者Subscriber的编程实现

C++

# 创建pose_subscriber.cpp文件
$ touch pose_subscriber.cpp

# 如何实现一个订阅者？
# (1)初始化ROS节点；
# (2)订阅需要的话题；
# (3)循环等待话题消息，接收到消息后进入回调函数；
# (4)在回调函数中完成消息处理。

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将订阅/turtle1/pose话题，消息类型turtlesim::Pose
 */
 
#include <ros/ros.h>
#include "turtlesim/Pose.h"

// 接收到订阅的消息后，会进入消息回调函数
void poseCallback(const turtlesim::Pose::ConstPtr& msg)
{
    // 将接收到的消息打印出来
    ROS_INFO("Turtle pose: x:%0.6f, y:%0.6f", msg->x, msg->y);
}

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

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

    // 创建一个Subscriber，订阅名为/turtle1/pose的topic，注册回调函数poseCallback
    ros::Subscriber pose_sub = n.subscribe("/turtle1/pose", 10, poseCallback);

    // 循环等待回调函数
    ros::spin();

    return 0;
}

# 将下列代码加到CMakeLists.txt
# 如何配置 CMakeLists.txt 中的编译规则
# · 设置需要编译的代码和生成的可执行文件
# · 设置链接库
$ add_executable(pose_subscriber src/pose_subscriber.cpp)
$ target_link_libraries(pose_subscriber ${catkin_LIBRARIES})

# 编译并运行发布者
$ cd ~/catkin_ws
$ catkin_make

Python

# 创建pose_subscriber.py文件
$ touch pose_subscriber.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

########################################################################
####          Copyright 2020 GuYueHome (www.guyuehome.com).          ###
########################################################################

# 该例程将订阅/turtle1/pose话题，消息类型turtlesim::Pose

import rospy
from turtlesim.msg import Pose

def poseCallback(msg):
    rospy.loginfo("Turtle pose: x:%0.6f, y:%0.6f", msg.x, msg.y)

def pose_subscriber():
	# ROS节点初始化
    rospy.init_node('pose_subscriber', anonymous=True)

	# 创建一个Subscriber，订阅名为/turtle1/pose的topic，注册回调函数poseCallback
    rospy.Subscriber("/turtle1/pose", Pose, poseCallback)

	# 循环等待回调函数
    rospy.spin()

if __name__ == '__main__':
    pose_subscriber()

# 直接运行脚本文件不需要编译，但是运行前记得改文件属性，允许文件作为程序执行
$ python3 pose_subscriber.py

话题消息的定义与使用

C++

# 创建自定义话题消息Person.msg
$ touch Person.msg

string name
uint8  age
uint8  sex

uint8 unknown = 0
uint8 male    = 1
uint8 female  = 2

# 在package.xml中添加功能包依赖
$ <build_depend>message_generation</build_depend>
$ <exec_depend>message_runtime</exec_depend>

# 在CMakeLists.txt添加编译选项
$ find_package( … … message_generation)
$ add_message_files(FILES Person msg)
$ generate_messages(DEPENDENCIES std_msgs)
$ catkin package(..... message runtime)

# 编译生成语言相关文件
$ cd ~/catkin_ws
$ catkin_make

# 创建person_publisher.cpp文件
$ touch person_publisher.cpp

# 如何实现一个发布者？
# （1）初始化ROS节点；
# （2）向ROS Master注册节点信息，包括发布的话题名和话题中的消息类型；
# （3）创建消息数据；
# （4）按照一定频率循环发布消息。

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将发布/person_info话题，自定义消息类型learning_topic::Person
 */
 
#include <ros/ros.h>
#include "learning_topic/Person.h"

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

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

    // 创建一个Publisher，发布名为/person_info的topic，消息类型为learning_topic::Person，队列长度10
    ros::Publisher person_info_pub = n.advertise<learning_topic::Person>("/person_info", 10);

    // 设置循环的频率
    ros::Rate loop_rate(1);

    int count = 0;
    while (ros::ok())
    {
        // 初始化learning_topic::Person类型的消息
    	learning_topic::Person person_msg;
		person_msg.name = "Tom";
		person_msg.age  = 18;
		person_msg.sex  = learning_topic::Person::male;

        // 发布消息
		person_info_pub.publish(person_msg);

       	ROS_INFO("Publish Person Info: name:%s  age:%d  sex:%d", 
				  person_msg.name.c_str(), person_msg.age, person_msg.sex);

        // 按照循环频率延时
        loop_rate.sleep();
    }

    return 0;
}

# 将下列代码加到CMakeLists.txt
# 如何配置 CMakeLists.txt 中的编译规则
# · 设置需要编译的代码和生成的可执行文件
# · 设置链接库
# · 添加依赖项
$ add_executable(person_publisher src/person_publisher.cpp)
$ target_link_libraries(person_publisher ${catkin_LIBRARIES})
$ add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)

# 编译并运行发布者
$ cd ~/catkin_ws
$ catkin_make

# 创建person_subscriber.cpp文件
$ touch person_subscriber.cpp

# 如何实现一个订阅者？
# (1)初始化ROS节点；
# (2)订阅需要的话题；
# (3)循环等待话题消息，接收到消息后进入回调函数；
# (4)在回调函数中完成消息处理。

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将订阅/person_info话题，自定义消息类型learning_topic::Person
 */
 
#include <ros/ros.h>
#include "learning_topic/Person.h"

// 接收到订阅的消息后，会进入消息回调函数
void personInfoCallback(const learning_topic::Person::ConstPtr& msg)
{
    // 将接收到的消息打印出来
    ROS_INFO("Subcribe Person Info: name:%s  age:%d  sex:%d", 
			 msg->name.c_str(), msg->age, msg->sex);
}

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

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

    // 创建一个Subscriber，订阅名为/person_info的topic，注册回调函数personInfoCallback
    ros::Subscriber person_info_sub = n.subscribe("/person_info", 10, personInfoCallback);

    // 循环等待回调函数
    ros::spin();

    return 0;
}
# 将下列代码加到CMakeLists.txt
# 如何配置 CMakeLists.txt 中的编译规则
# · 设置需要编译的代码和生成的可执行文件
# · 设置链接库
# · 添加依赖项
$ add_executable(person_subscriber src/person_subscriber.cpp)
$ target_link_libraries(person_subscriber ${catkin_LIBRARIES})
$ add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messages_cpp)

# 编译并运行发布者
$ cd ~/catkin_ws
$ catkin_make

Python

# 创建person_publisher.py文件
$ touch person_publisher.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

########################################################################
####          Copyright 2020 GuYueHome (www.guyuehome.com).          ###
########################################################################

# 该例程将发布/person_info话题，自定义消息类型learning_topic::Person

import rospy
from learning_topic.msg import Person

def velocity_publisher():
	# ROS节点初始化
    rospy.init_node('person_publisher', anonymous=True)

	# 创建一个Publisher，发布名为/person_info的topic，消息类型为learning_topic::Person，队列长度10
    person_info_pub = rospy.Publisher('/person_info', Person, queue_size=10)

	#设置循环的频率
    rate = rospy.Rate(10) 

    while not rospy.is_shutdown():
		# 初始化learning_topic::Person类型的消息
    	person_msg = Person()
    	person_msg.name = "Tom";
    	person_msg.age  = 18;
    	person_msg.sex  = Person.male;

		# 发布消息
        person_info_pub.publish(person_msg)
    	rospy.loginfo("Publsh person message[%s, %d, %d]", 
				person_msg.name, person_msg.age, person_msg.sex)

		# 按照循环频率延时
        rate.sleep()

if __name__ == '__main__':
    try:
        velocity_publisher()
    except rospy.ROSInterruptException:
        pass

# 直接运行脚本文件不需要编译，但是运行前记得改文件属性，允许文件作为程序执行
$ python3 person_publisher.py


# 创建person_subscriber.py文件
$ touch person_subscriber.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

########################################################################
####          Copyright 2020 GuYueHome (www.guyuehome.com).          ###
########################################################################

# 该例程将订阅/person_info话题，自定义消息类型learning_topic::Person

import rospy
from learning_topic.msg import Person

def personInfoCallback(msg):
    rospy.loginfo("Subcribe Person Info: name:%s  age:%d  sex:%d", 
			 msg.name, msg.age, msg.sex)

def person_subscriber():
	# ROS节点初始化
    rospy.init_node('person_subscriber', anonymous=True)

	# 创建一个Subscriber，订阅名为/person_info的topic，注册回调函数personInfoCallback
    rospy.Subscriber("/person_info", Person, personInfoCallback)

	# 循环等待回调函数
    rospy.spin()

if __name__ == '__main__':
    person_subscriber()

# 直接运行脚本文件不需要编译，但是运行前记得改文件属性，允许文件作为程序执行
$ python3 person_subscriber.py

服务(Service)编程实现

客户端Client的编程实现

C++

$ cd ~/catkin_ws/src
# 创建功能包
$ catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim

# 创建turtle_spawn.cpp文件
$ touch turtle_spawn.cpp

# 如何实现一个客户端？
# （1）初始化ROS节点；
# （2）创建一个Client实例；
# （3）发布服务请求数据；
# （4）等待Server处理之后的应答结果。

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn
 */

#include <ros/ros.h>
#include <turtlesim/Spawn.h>

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

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

    // 发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
	ros::service::waitForService("/spawn");
	ros::ServiceClient add_turtle = node.serviceClient<turtlesim::Spawn>("/spawn");

    // 初始化turtlesim::Spawn的请求数据
	turtlesim::Spawn srv;
	srv.request.x = 2.0;
	srv.request.y = 2.0;
	srv.request.name = "turtle2";

    // 请求服务调用
	ROS_INFO("Call service to spwan turtle[x:%0.6f, y:%0.6f, name:%s]", 
			 srv.request.x, srv.request.y, srv.request.name.c_str());

	add_turtle.call(srv);

	// 显示服务调用结果
	ROS_INFO("Spwan turtle successfully [name:%s]", srv.response.name.c_str());

	return 0;
};

# 将下列代码加到CMakeLists.txt
# 如何配置 CMakeLists.txt 中的编译规则
# · 设置需要编译的代码和生成的可执行文件
# · 设置链接库
$ add_executable(turtle_spawn src/turtle_spawn.cpp)
$ target_link_libraries(turtle_spawn ${catkin_LIBRARIES})

# 编译并运行发布者
$ cd ~/catkin_ws
$ catkin_make

# 设置环境变量并将语句加入到.bashrc
$ source devel/setup.bash

$ roscore
//启动小海龟仿真器节点
$ rosrun turtlesim turtlesim_node
$ rosrun learning_service turtle_spawn.cpp

Python

# 创建turtle_spawn.py文件
$ touch turtle_spawn.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

########################################################################
####          Copyright 2020 GuYueHome (www.guyuehome.com).          ###
########################################################################

# 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn

import sys
import rospy
from turtlesim.srv import Spawn

def turtle_spawn():
	# ROS节点初始化
    rospy.init_node('turtle_spawn')

	# 发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
    rospy.wait_for_service('/spawn')
    try:
        add_turtle = rospy.ServiceProxy('/spawn', Spawn)

		# 请求服务调用，输入请求数据
        response = add_turtle(2.0, 2.0, 0.0, "turtle2")
        return response.name
    except rospy.ServiceException, e:
        print "Service call failed: %s"%e

if __name__ == "__main__":
	#服务调用并显示调用结果
    print "Spwan turtle successfully [name:%s]" %(turtle_spawn())


# 直接运行脚本文件不需要编译，但是运行前记得改文件属性，允许文件作为程序执行
$ python3 turtle_spawn.py

服务端Server的编程实现

C++

# 创建turtle_command_server.cpp文件
$ touch turtle_command_server.cpp

# 如何实现一个服务器？
# （1）初始化ROS节点；
# （2）创建Server实例；
# （3）循环等待服务请求，进入回调函数；
# （4）在回调函数中完成服务功能的处理，并反馈应答数据。

/***********************************************************************
Copyright 2020 GuYueHome (www.guyuehome.com).
***********************************************************************/

/**
 * 该例程将执行/turtle_command服务，服务数据类型std_srvs/Trigger
 */
 
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <std_srvs/Trigger.h>

ros::Publisher turtle_vel_pub;
bool pubCommand = false;

// service回调函数，输入参数req，输出参数res
bool commandCallback(std_srvs::Trigger::Request  &req,
         			std_srvs::Trigger::Response &res)
{
	pubCommand = !pubCommand;

    // 显示请求数据
    ROS_INFO("Publish turtle velocity command [%s]", pubCommand==true?"Yes":"No");

	// 设置反馈数据
	res.success = true;
	res.message = "Change turtle command state!"

    return true;
}

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

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

    // 创建一个名为/turtle_command的server，注册回调函数commandCallback
    ros::ServiceServer command_service = n.advertiseService("/turtle_command", commandCallback);

	// 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
	turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 10);

    // 循环等待回调函数
    ROS_INFO("Ready to receive turtle command.");

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

	while(ros::ok())
	{
		// 查看一次回调函数队列
    	ros::spinOnce();
		
		// 如果标志为true，则发布速度指令
		if(pubCommand)
		{
			geometry_msgs::Twist vel_msg;
			vel_msg.linear.x = 0.5;
			vel_msg.angular.z = 0.2;
			turtle_vel_pub.publish(vel_msg);
		}

		//按照循环频率延时
	    loop_rate.sleep();
	}

    return 0;
}

# 将下列代码加到CMakeLists.txt
# 如何配置 CMakeLists.txt 中的编译规则
# · 设置需要编译的代码和生成的可执行文件
# · 设置链接库
$ add_executable(turtle_command_server src/turtle_command_server.cpp)
$ target_link_libraries(turtle_command_server ${catkin_LIBRARIES})

# 编译并运行发布者
$ cd ~/catkin_ws
$ catkin_make

# 设置环境变量并将语句加入到.bashrc
$ source devel/setup.bash

$ roscore
//启动小海龟仿真器节点
$ rosrun turtlesim turtlesim_node
$ rosrun learning_service turtle_command_server
$ rosservice call /turtle_command "{}"

# 查看服务数据结构std_srvs/Trigger的内容
$ rossrv show std_srvs/Trigger

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
ROS相关知识点

（1）具有一定的类型和数据结构，包括ROS提供的标准类型和用户自定义类型；（2）不同节点可使用不同的编程语言，可分布式运行在不同的主机；（2）跟踪和记录话题 / 服务通信，辅助节点相互查找、建立连接；（3）提供参数服务器，节点使用此服务器存储和检索运行时的参数。（1）执行具体任务的进程、独立运行的可执行文件；（1）可通过网络访问的共享、多变量字典；的配置参数，不适合存储动态配置的数据。（3）节点在系统中的名称必须是。（2）使用编程语言无关的。（2）使用编程语言无关的。
复制链接

扫一扫

评论 1

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。