【ROS2】初级：客户端-编写一个简单的发布者和订阅者（Python）

最新推荐文章于 2025-04-13 15:59:31 发布
最新推荐文章于 2025-04-13 15:59:31 发布
阅读量1.6k 收藏 32
点赞数 13
文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxyhjl/article/details/140241108
版权

目标：使用 Python 创建并运行一个发布者和订阅者节点。

 教程级别：初学者

 时间：20 分钟

 目录

  •  背景

  •  先决条件

  •  任务

    • 1. 创建一个包

    • 2. 编写发布者节点

    • 3. 编写订阅者节点

    • 4. 构建并运行

  •  摘要

  •  下一步

  •  相关内容

 背景

在本教程中，您将创建节点，这些节点通过主题相互传递字符串消息形式的信息。这里使用的示例是一个简单的“说话者”和“监听者”系统；一个节点发布数据，另一个节点订阅主题以便接收该数据。

这些示例中使用的代码可以在这里找到。

 先决条件

在之前的教程中，您学习了如何创建工作区和创建包。

建议具备基础的 Python 理解，但不是完全必需的。

 任务

1. 创建一个包

打开一个新的终端并且初始化您的 ROS 2 安装，这样 ros2 命令就会生效。

导航到在之前教程中创建的 ros2_ws 目录。

请记住，包应该在 src 目录中创建，而不是在工作区的根目录中。因此，请导航到 ros2_ws/src ，然后运行包创建命令：

cxy@ubuntu2404-cxy:~/ros2_ws/src$ ros2 pkg create --build-type ament_python --license Apache-2.0 py_pubsub
going to create a new package
package name: py_pubsub
destination directory: /home/cxy/ros2_ws/src
package format: 3
version: 0.0.0
description: TODO: Package description
maintainer: ['cxy <cxy@todo.todo>']
licenses: ['Apache-2.0']
build type: ament_python
dependencies: []
creating folder ./py_pubsub
creating ./py_pubsub/package.xml
creating source folder
creating folder ./py_pubsub/py_pubsub
creating ./py_pubsub/setup.py
creating ./py_pubsub/setup.cfg
creating folder ./py_pubsub/resource
creating ./py_pubsub/resource/py_pubsub
creating ./py_pubsub/py_pubsub/__init__.py
creating folder ./py_pubsub/test
creating ./py_pubsub/test/test_copyright.py
creating ./py_pubsub/test/test_flake8.py
creating ./py_pubsub/test/test_pep257.py

您的终端将返回一条消息，确认您的包 py_pubsub 及其所有必要的文件和文件夹已创建。

2. 编写发布者节点

导航到 ros2_ws/src/py_pubsub/py_pubsub 。请记住，这个目录是一个 Python 包，它的名称与其嵌套的 ROS 2 包的名称相同。

下载示例说话者代码，请输入以下命令：

cxy@ubuntu2404-cxy:~/ros2_ws/src/py_pubsub/py_pubsub$ wget https://raw.githubusercontent.com/ros2/examples/jazzy/rclpy/topics/minimal_publisher/examples_rclpy_minimal_publisher/publisher_member_function.py
--2024-07-06 11:23:35--  https://raw.githubusercontent.com/ros2/examples/jazzy/rclpy/topics/minimal_publisher/examples_rclpy_minimal_publisher/publisher_member_function.py
正在连接 127.0.0.1:2334... 已连接。
已发出 Proxy 请求，正在等待回应... 200 OK
长度：1576 (1.5K) [text/plain]
正在保存至: ‘publisher_member_function.py’


publisher_member_fu 100%[===================>]   1.54K  --.-KB/s    用时 0s    


2024-07-06 11:23:37 (6.48 MB/s) - 已保存 ‘publisher_member_function.py’ [1576/1576])

现在将有一个名为 publisher_member_function.py 的新文件与 __init__.py 相邻。

使用您喜欢的文本编辑器打开文件。

# 版权 2016 开源机器人基金会，公司。
#
# 根据 Apache 许可证，版本 2.0（“许可证”）许可；
# 除非符合许可证，否则不得使用此文件。
# 您可以在以下位置获取许可证副本：
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# 除非适用法律要求或书面同意，否则在许可证下分发的软件
# 将按“原样”基础分发，无任何明示或暗示的保证或条件。
# 请参阅许可证以了解管理权限和
# 许可证下的限制。


import rclpy  # 导入 ROS 客户端库
from rclpy.node import Node  # 从 rclpy.node 模块导入 Node 类


from std_msgs.msg import String  # 从 std_msgs.msg 模块导入 String 消息类型




class MinimalPublisher(Node):  # 定义一个名为 MinimalPublisher 的类，它继承自 Node 类


    def __init__(self):  # 定义类的初始化函数
        super().__init__('minimal_publisher')  # 调用父类（Node）的初始化函数，并设置节点名称为 'minimal_publisher'
        self.publisher_ = self.create_publisher(String, 'topic', 10)  # 创建一个发布者，消息类型为 String，主题名为 'topic'，队列长度为 10
        timer_period = 0.5  # 设置定时器的时间间隔，单位为秒
        self.timer = self.create_timer(timer_period, self.timer_callback)  # 创建一个定时器，每隔 timer_period 秒就调用一次 self.timer_callback 函数
        self.i = 0  # 初始化一个变量 i，用于记录发布的消息数量


    def timer_callback(self):  # 定义定时器回调函数
        msg = String()  # 创建一个 String 类型的消息对象
        msg.data = 'Hello World: %d' % self.i  # 设置消息的内容
        self.publisher_.publish(msg)  # 发布消息
        self.get_logger().info('Publishing: "%s"' % msg.data)  # 在终端上打印一条日志信息
        self.i += 1  # 每发布一条消息，就将 i 的值加 1




def main(args=None):  # 定义主函数
    rclpy.init(args=args)  # 初始化 ROS 客户端库


    minimal_publisher = MinimalPublisher()  # 创建一个 MinimalPublisher 类的实例


    rclpy.spin(minimal_publisher)  # 进入循环，等待消息到来


    # 显式销毁节点
    # （可选 - 否则当垃圾收集器销毁节点对象时
    # 它将自动完成）
    minimal_publisher.destroy_node()  # 销毁节点
    rclpy.shutdown()  # 关闭 ROS 客户端库




if __name__ == '__main__':  # 如果直接运行这个文件（而不是 import 这个文件）
    main()  # 调用主函数
检查代码 2.1

源代码中的第一行在注释后导入 rclpy ，以便可以使用其 Node 类。

import rclpy
from rclpy.node import Node

下一条语句导入了节点用来构建其在主题上传递的数据的内置字符串消息类型。

from std_msgs.msg import String

这些行代表节点的依赖项。请记住，依赖项需要添加到 package.xml 中，在下一节中您将执行此操作。

接下来，创建了 MinimalPublisher 类，它继承自（或是 Node 的子类）。

class MinimalPublisher(Node):

以下是类构造函数的定义。 super().__init__ 调用 Node 类的构造函数，并为其提供节点名称，在本例中为 minimal_publisher 。

create_publisher 声明该节点发布 std_msgs.msg 模块导入的类型为 String 的消息，通过名为 topic 的主题，且“队列大小”为 10。队列大小是必需的 QoS（服务质量）设置，如果订阅者接收消息不够快，它会限制排队消息的数量。

接下来，创建了一个定时器，每 0.5 秒执行一次回调。 self.i 是回调中使用的计数器。

def __init__(self):
    super().__init__('minimal_publisher')
    self.publisher_ = self.create_publisher(String, 'topic', 10)
    timer_period = 0.5  # seconds
    self.timer = self.create_timer(timer_period, self.timer_callback)
    self.i = 0

timer_callback 创建一条附加了计数器值的消息，并使用 get_logger().info 发布到控制台。

def timer_callback(self):
    msg = String()
    msg.data = 'Hello World: %d' % self.i
    self.publisher_.publish(msg)
    self.get_logger().info('Publishing: "%s"' % msg.data)
    self.i += 1

最后，主函数被定义。

def main(args=None):
    rclpy.init(args=args)


    minimal_publisher = MinimalPublisher()


    rclpy.spin(minimal_publisher)


    # Destroy the node explicitly
    # (optional - otherwise it will be done automatically
    # when the garbage collector destroys the node object)
    minimal_publisher.destroy_node()
    rclpy.shutdown()

首先初始化 rclpy 库，然后创建节点，再对节点进行“旋转”，以便调用其回调函数。

 2.2 添加依赖项 

返回到 ros2_ws/src/py_pubsub 目录， setup.py 、 setup.cfg 和 package.xml 文件已为您创建。

使用您的文本编辑器打开 package.xml 。

如前所述教程中提到的，确保填写 <description> 、 <maintainer> 和 <license> 标签：

<description>Examples of minimal publisher/subscriber using rclpy</description>
<maintainer email="you@email.com">Your Name</maintainer>
<license>Apache-2.0</license>

在上面的行之后，添加以下依赖项，对应于您节点的导入语句：

<exec_depend>rclpy</exec_depend>
<exec_depend>std_msgs</exec_depend>

此声明表示当代码执行时，包需要 rclpy 和 std_msgs 。

<?xml version="1.0"?>  <!-- XML 文件的版本 -->
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>  <!-- XML 文件的模式定义 -->
<package format="3">  <!-- 定义一个 ROS 包，格式为 3 -->
  <name>py_pubsub</name>  <!-- 包的名称 -->
  <version>0.0.0</version>  <!-- 包的版本号 -->
  <description>Examples of minimal publisher/subscriber using rclpy</description>  <!-- 包的描述 -->
  <maintainer email="cxy@126.com">cxy</maintainer>  <!-- 包的维护者和他的电子邮件地址 -->
  <license>Apache-2.0</license>  <!-- 包的许可证 -->


  <exec_depend>rclpy</exec_depend>  <!-- 运行此包需要的依赖包 -->
  <exec_depend>std_msgs</exec_depend>  <!-- 运行此包需要的依赖包 -->
  <test_depend>ament_copyright</test_depend>  <!-- 测试此包需要的依赖包 -->
  <test_depend>ament_flake8</test_depend>  <!-- 测试此包需要的依赖包 -->
  <test_depend>ament_pep257</test_depend>  <!-- 测试此包需要的依赖包 -->
  <test_depend>python3-pytest</test_depend>  <!-- 测试此包需要的依赖包 -->


  <export>  <!-- 导出的信息 -->
    <build_type>ament_python</build_type>  <!-- 构建类型 -->
  </export>
</package>

确保保存文件。

2.3 添加一个入口点 

打开 setup.py 文件。再次，将 maintainer 、 maintainer_email 、 description 和 license 字段与您的 package.xml 匹配：

maintainer='YourName',
maintainer_email='you@email.com',
description='Examples of minimal publisher/subscriber using rclpy',
license='Apache-2.0',

在 entry_points 字段的 console_scripts 括号内添加以下行：

entry_points={
        'console_scripts': [
                'talker = py_pubsub.publisher_member_function:main',
        ],
},

别忘了保存。

 2.4 检查 setup.cfg

setup.cfg 文件的内容应该会像这样自动正确填充：

[develop]
script_dir=$base/lib/py_pubsub
[install]
install_scripts=$base/lib/py_pubsub

这只是告诉 setuptools 将你的可执行文件放在 lib ，因为 ros2 run 会在那里查找它们。

您现在可以构建您的包，源本地设置文件，并运行它，但让我们先创建订阅者节点，这样您就可以看到完整系统的运作。

3. 编写订阅者节点

返回 ros2_ws/src/py_pubsub/py_pubsub 以创建下一个节点。在您的终端输入以下代码：

cxy@ubuntu2404-cxy:~/ros2_ws/src/py_pubsub/py_pubsub$ wget https://raw.githubusercontent.com/ros2/examples/jazzy/rclpy/topics/minimal_subscriber/examples_rclpy_minimal_subscriber/subscriber_member_function.py
--2024-07-06 11:46:47--  https://raw.githubusercontent.com/ros2/examples/jazzy/rclpy/topics/minimal_subscriber/examples_rclpy_minimal_subscriber/subscriber_member_function.py
正在连接 127.0.0.1:2334... 已连接。
已发出 Proxy 请求，正在等待回应... 200 OK
长度： 1469 (1.4K) [text/plain]
正在保存至: ‘subscriber_member_function.py’


subscriber_member_f 100%[===================>]   1.43K  --.-KB/s    用时 0s    


2024-07-06 11:46:49 (11.7 MB/s) - 已保存 ‘subscriber_member_function.py’ [1469/1469])

现在目录中应该有这些文件：

614d3b992d8881cbd7d6ce3b09498eb3.png

3.1 检查代码

打开 subscriber_member_function.py 使用你的文本编辑器。

# 版权 2016 开源机器人基金会，公司。
#
# 根据 Apache 许可证，版本 2.0（“许可证”）许可；
# 除非符合许可证，否则不得使用此文件。
# 您可以在以下位置获取许可证副本：
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# 除非适用法律要求或书面同意，否则在许可证下分发的软件
# 将按“原样”基础分发，无任何明示或暗示的保证或条件。
# 请参阅许可证以了解管理权限和
# 许可证下的限制。


import rclpy  # 导入 ROS 客户端库
from rclpy.node import Node  # 从 rclpy.node 模块导入 Node 类


from std_msgs.msg import String  # 从 std_msgs.msg 模块导入 String 消息类型




class MinimalSubscriber(Node):  # 定义一个名为 MinimalSubscriber 的类，它继承自 Node 类


    def __init__(self):  # 定义类的初始化函数
        super().__init__('minimal_subscriber')  # 调用父类（Node）的初始化函数，并设置节点名称为 'minimal_subscriber'
        self.subscription = self.create_subscription(
            String,
            'topic',
            self.listener_callback,
            10)  # 创建一个订阅者，消息类型为 String，主题名为 'topic'，队列长度为 10，当收到消息时调用 self.listener_callback 函数
        self.subscription  # 防止未使用变量警告


    def listener_callback(self, msg):  # 定义监听回调函数
        self.get_logger().info('I heard: "%s"' % msg.data)  # 在终端上打印一条日志信息，内容为收到的消息




def main(args=None):  # 定义主函数
    rclpy.init(args=args)  # 初始化 ROS 客户端库


    minimal_subscriber = MinimalSubscriber()  # 创建一个 MinimalSubscriber 类的实例


    rclpy.spin(minimal_subscriber)  # 进入循环，等待消息到来


    # 显式销毁节点
    # （可选 - 否则当垃圾收集器销毁节点对象时
    # 它将自动完成）
    minimal_subscriber.destroy_node()  # 销毁节点
    rclpy.shutdown()  # 关闭 ROS 客户端库




if __name__ == '__main__':  # 如果直接运行这个文件（而不是 import 这个文件）
    main()  # 调用主函数

订阅者节点的代码与发布者的几乎相同。构造函数使用与发布者相同的参数创建一个订阅者。回想一下主题教程中提到的，发布者和订阅者使用的主题名称和消息类型必须匹配，才能使它们能够通信。

self.subscription = self.create_subscription(
    String,
    'topic',
    self.listener_callback,
    10)

订阅者的构造函数和回调不包括任何定时器定义，因为它不需要定时器。一旦收到消息，它的回调就会被调用。

回调定义只是将一个信息消息和它收到的数据一起打印到控制台。回想一下发布者定义 msg.data = 'Hello World: %d' % self.i

def listener_callback(self, msg):
    self.get_logger().info('I heard: "%s"' % msg.data)

main 的定义几乎完全相同，只是将发布者的创建和旋转替换为订阅者。

minimal_subscriber = MinimalSubscriber()


rclpy.spin(minimal_subscriber)

由于此节点与发布者具有相同的依赖项，因此无需向 package.xml 添加任何新内容。 setup.cfg 文件也可以保持不变。

3.2 添加一个入口点 

重新打开 setup.py ，并在发布者入口点下面添加订阅者节点的入口点。 entry_points 字段现在应该如下所示：

entry_points={
        'console_scripts': [
                'talker = py_pubsub.publisher_member_function:main',
                'listener = py_pubsub.subscriber_member_function:main',
        ],
},

请确保保存文件，然后您的发布/订阅系统应该就绪。

from setuptools import find_packages, setup  # 导入 setuptools 库的 find_packages 和 setup 函数


package_name = 'py_pubsub'  # 定义包名


setup(  # 调用 setup 函数来配置包
    name=package_name,  # 包名
    version='0.0.0',  # 包的版本号
    packages=find_packages(exclude=['test']),  # 使用 find_packages 函数查找包，排除名为 'test' 的包
    data_files=[  # 数据文件列表
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),  # 第一个数据文件的路径和文件名
        ('share/' + package_name, ['package.xml']),  # 第二个数据文件的路径和文件名
    ],
    install_requires=['setuptools'],  # 安装此包需要的其他包
    zip_safe=True,  # 此包可以安全地从 zip 文件中导入
    maintainer='cxy',  # 维护者的名字
    maintainer_email='cxy@126.com',  # 维护者的电子邮件地址
    description='Examples of minimal publisher/subscriber using rclpy',  # 包的描述
    license='Apache-2.0',  # 包的许可证
    tests_require=['pytest'],  # 测试此包需要的其他包
    entry_points={  # 入口点
        'console_scripts': [  # 控制台脚本入口点
          'talker = py_pubsub.publisher_member_function:main',  # 当运行 'talker' 命令时，会调用 'py_pubsub.publisher_member_function' 模块的 'main' 函数
          'listener = py_pubsub.subscriber_member_function:main',  # 当运行 'listener' 命令时，会调用 'py_pubsub.subscriber_member_function' 模块的 'main' 函数
        ],
    },
)

4. 构建并运行

您可能已经在 ROS 2 系统中安装了 rclpy 和 std_msgs 包。在构建之前，在工作空间的根目录（ ros2_ws ）运行 rosdep 以检查缺失的依赖项是一个好习惯：

rosdep install -i --from-path src --rosdistro jazzy -y

仍在您的工作区的根目录中， ros2_ws ，构建您的新包：

cxy@ubuntu2404-cxy:~/ros2_ws$ colcon build --packages-select py_pubsub
Starting >>> py_pubsub
Finished <<< py_pubsub [3.03s]           


Summary: 1 package finished [11.2s]

打开一个新的终端，导航到 ros2_ws ，并且导入设置文件：

source install/setup.bash

现在运行 talker 节点：

ros2 run py_pubsub talker

终端应该每 0.5 秒发布一次信息消息，如下：

cxy@ubuntu2404-cxy:~/ros2_ws$ source install/setup.bash
cxy@ubuntu2404-cxy:~/ros2_ws$ ros2 run py_pubsub talker
[INFO] [1720238366.729769667] [minimal_publisher]: Publishing: "Hello World: 0"
[INFO] [1720238367.169861013] [minimal_publisher]: Publishing: "Hello World: 1"
[INFO] [1720238367.669947277] [minimal_publisher]: Publishing: "Hello World: 2"
[INFO] [1720238368.170122810] [minimal_publisher]: Publishing: "Hello World: 3"
[INFO] [1720238368.670373114] [minimal_publisher]: Publishing: "Hello World: 4"

打开另一个终端，再次从 ros2_ws 内部加载设置文件，然后启动监听节点：

cxy@ubuntu2404-cxy:~/ros2_ws$ source install/setup.bash
cxy@ubuntu2404-cxy:~/ros2_ws$ 
cxy@ubuntu2404-cxy:~/ros2_ws$ ros2 run py_pubsub listener
[INFO] [1720238372.201524573] [minimal_subscriber]: I heard: "Hello World: 11"
[INFO] [1720238372.671306025] [minimal_subscriber]: I heard: "Hello World: 12"
[INFO] [1720238373.169087107] [minimal_subscriber]: I heard: "Hello World: 13"
[INFO] [1720238373.671070379] [minimal_subscriber]: I heard: "Hello World: 14"
[INFO] [1720238374.171012765] [minimal_subscriber]: I heard: "Hello World: 15"

监听器将开始向控制台打印消息，从发布者当时的消息计数开始，如下：

08531899a9d108d4508572b17b4ea5be.png

在每个终端输入 Ctrl+C 以停止节点旋转。

 摘要

您创建了两个节点，用于通过主题发布和订阅数据。在运行它们之前，您已将它们的依赖项和入口点添加到包配置文件中。

 下一步

接下来，您将使用服务/客户端模型创建另一个简单的 ROS 2 包。同样，您可以选择用 C++ https://docs.ros.org/en/jazzy/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Cpp-Service-And-Client.html 或 Python https://docs.ros.org/en/jazzy/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Service-And-Client.html 编写。

 相关内容 

有几种方法可以在 Python 中编写发布者和订阅者；请查看 ros2/examples 仓库中的 minimal_publisher 和 minimal_subscriber 包。https://github.com/ros2/examples/tree/jazzy/rclpy/topics

ROS2快速入门Python篇-版本梳理、环境搭建、源码架构介绍
techfuture的博客
04-18 4339
模块功能rclcpp这是 ROS 2 的 C++ 客户端库。它提供了一个面向对象的接口，用于创建节点、发布和订阅主题、调用服务等。rclcpp 提供了一个类似于 ROS 1 的 roscpp 的接口，但是专门为 ROS 2 的分布式架构设计。rclpy与 rclcpp 类似，rclpy 是 ROS 2 的 Python 客户端库。它允许开发者使用 Python 来编写 ROS 2 节点，并与 ROS 2 系统进行交互。rosidl。
[ PyQt使用Socket/TCP通信 ] : 智能车上位机系统，pyqt下的socket通信，python实现服务器+客户端，文本+视频不定长字节传输，超详细,小白都能看懂
共享IT之美，共创机器未来
04-05 2246
socket通信（tcp）视频+文本传输，涉及到半包问题。
【编写简单的发布者和订阅者 （Python）——ROS2+ubuntu22.04】
dongbao520的博客
04-07 1398
一个节点发布数据，另一个节点订阅主题，以便它可以接收该数据。订阅者的构造函数和回调不包含任何计时器定义，因为它不需要计时器定义。订阅者节点的代码与发布者的代码几乎相同。回想一下，包应该在目录中创建，而不是在工作区的根目录中创建。重新打开订阅服务器节点的入口点，并将其添加到发布者的入口点下方。中的内容，发布者和订阅者使用的主题名称和消息类型必须匹配，才能允许他们进行通信。您的终端将返回一条消息，验证您的包及其所有必要文件和文件夹的创建。定义几乎完全相同，将发布者的创建和旋转替换为订阅者。
ROS2基础篇
最新发布
雷东宸的博客
04-13 1205
万字入门ROS2基础篇！
ROS2 编写发布和订阅
持之以恒2016
03-27 1572
创建src目录 $ mkdir ros-demo $ cd ros-demo/ $ mkdir src $ cd src/ 创建工程 $ ros2 pkg create --build-type ament_cmake cpp_pubsub 配置代码提示 在ros-demo目录下新建.vscode文件夹，创建c_cpp_properties.json文件，把ros的头文件包含进来 文件内容如下 { "configurations": [ { "brows
简单的发布者/订阅者（Python）
liuzubing的博客
10-24 3821
自己在使用ROS的过程中一直使用Python编程语言，因此在此只介绍基于Python的发布者/订阅者代码，有兴趣的可以到官网参考C++的代码。 1、编写代码前的准备工作 在前面已经介绍了如何创建一个ROS空间，以及如何创建自定义的消息和服务，在这里默认你已经掌握了上述内容。假设我已经在自己的用户目录下创建了一个名为ROSworkspace的工作空间，在工作空间的src文件夹下已经创建了一个名为
ROS2 小白学习入门 话题发布和订阅(C++实现)
weixin_43541103的博客
08-30 2360
ROS2 小白入门应用 话题发布和订阅（C++实现）
ROS2中的发布/订阅模型（古月居ros2学习笔记）
sibo_shang的博客
08-07 1469
常用的usb相机驱动一般都是通用的，ROS中也集成了usb相机的标准驱动，我们只需要通过这样一行指令，就可以安装好，无论你用什么样的相机，只要符合usb接口协议，就可以直接使用ROS中的相机驱动节点，发布标准的图像话题了。话题数据传输的特性是从一个节点到另外一个节点，发送数据的对象称之为发布者，接收数据的对象称之为订阅者，每一个话题都需要有一个名字，传输的数据也需要有固定的数据类型。这样，我们的代码又得到了进一步精简，刚才自己写的图像发布节点换成了这样一句指令，视觉识别节点不需要做任何变化。
ROS入门21讲课件&源码.zip
09-26
ROS（Robot Operating System，机器人操作系统）是一个开源操作系统框架，专为设计和开发复杂机器人系统而构建。本资源包“ROS入门21讲课件&源码.zip”提供了学习ROS的初级教程，包括课件和源码，是初学者踏入ROS...
ROS学习入门：基本概念与命令详解
"这篇文档是ROS(机器人操作系统)学习的基础教程，主要针对初学者，涵盖了ROS的基本概念、命令、...这份初级教程为初学者提供了一个全面的ROS入门指南，涵盖了从基础概念到实际操作的各个环节，是学习ROS的宝贵资料。
ros(kinetic) 初级教程
04-03
总之，这个ROS Kinetic初级教程将带你入门ROS的基本概念和操作，通过实践编写发布者、订阅者以及消息服务的节点，你将对ROS的通信机制有深入的理解，并能构建简单的机器人应用程序。在后续的学习中，你可以进一步...
ROS维基小结（2）——ROS初级教程总结
yangtao420902的博客
04-17 419
ROS初级教程总结一，文件系统工具1.1 rospack1.2 roscd1.3 pwd1.4 roscd log1.5 rosls1.6 tab键自动补全二，创建一个ROS包2.1 创建一个功能包2.2包依赖三，ROS节点3.1 rosnode3.2 rosrun四，ROS Topics4.1 rqt_graph4.2 rostopic4.2.1 rostopic echo4.2.2 rosto...
使用python写的发布者和订阅者
aniclever的博客
03-29 608
使用python做的发布者和订阅者
【ros实验一】使用ros话题机制实现消息发布与订阅，并分别封装成launch文件(python)
lingying77的博客
10-04 2429
定义一个字段来存储斐波那契数列的值。
ROS学习笔记——简单的消息发布器和订阅器 (Python版)
Blvin.Don
03-18 3813
写一个简单的消息发布器和订阅器 (Python) 1.创建ROS功能包 切换到src文件夹下 cd ~/catkin_ws/src 在src文件夹下创建一个名为hello_world的包 cakin_create_pkg hello_world std_msgs rospy 在hello_world包被成功创建之后，需要添加两个Python文件或脚本，用于演示主题的订阅和发...
ROS 2客户端库(Client Libraries)
天涯的专栏
07-30 1471
概述 客户端库是允许用户实现其ROS代码的API。它们是用户用来访问ROS概念（如节点，主题，服务等）的内容。客户端库有各种编程语言，因此用户可以使用最适合其应用程序的语言编写ROS代码。例如，您可能更喜欢在Python中编写可视化工具，因为它可以更快地进行原型设计迭代，而对于系统中与效率相关的部分，可以在C ++中更好地实现节点。 使用不同客户端库编写的节点能够彼此共享消息，因为所有客户端库...
ROS 2边学边练（14）-- 写一个简单的发布者和订阅者（C++）
DIANZI520SUA的专栏
04-05 1964
本篇主要介绍并举例了订阅者节点和发布者节点编写的过程要素。
3. ros2之订阅者创建+订阅消息
2302_76761277的博客
08-25 593
这里订阅的是 第2章 中 my_topic01 的话题。
使用Python 实现发布/订阅（Pub/Sub）模式
Aaron_945的博客
06-03 1411
发布/订阅模式是一种强大的消息通信模式，它通过将消息的发布和接收解耦来提高系统的灵活性和可扩展性。在本文中，我们介绍了发布/订阅模式的设计思路，并使用Python语言实现了一个简单的发布/订阅系统。该系统包含主题、发布者、订阅者和消息队列等核心组件，并提供了基本的发布和订阅功能。你可以根据自己的需求对该系统进行扩展和优化，以满足更复杂的消息通信需求。
深入理解ROS话题通信：发布者与订阅者
标题中提及的"ROS学习笔记5源码-发布者与订阅者.zip"表明了该文档是一份学习ROS编程的笔记，涵盖了使用C++编写发布者（publisher）与订阅者（subscriber）代码的知识点。 ### 知识点详解 #### 1. ROS的话题（Topic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值