如何实现跨不同ROS系统的通信

文章目录

当涉及到在机器人操作系统（ROS）环境中的通信时，标准做法通常是在同一个ROS网络内通过话题和服务进行。但在某些特定情况下，比如当你有两个分布在不同网络中的ROS系统时，标准的通信方法可能不太适用。此时，一个可行的解决方案是建立一个直连的TCP通信，允许跨ROS系统的节点之间直接传输消息。本文将实现一个进行TCP通信节点示例程序。

一、场景概述

想象一下，有两台计算机A和B，每台上都运行着一个独立的ROS系统。我们的目标是让系统A中的节点监听话题testa，并将接收到的消息通过TCP发送给系统B中的节点。同样，系统B中的节点将监听话题testb并通过TCP将消息回传给系统A。

这种设置的一个典型应用场景是多机器人协作，其中机器人位于不同的网络环境中，或者需要与不支持ROS的遗留系统交互。

二、实现步骤

准备工作

首先，确保两台计算机都安装了ROS，并且需要使两台设备能互ping
在本示例中我是在局域网中的两台设备中进行演示的
闲言少叙，我们直接开始分析以下的程序

系统A

在系统A上，创建一个节点tcp_publisher_a.py，它订阅话题testa并将消息发送给系统B。
完整程序如下：

#!/usr/bin/env python
import rospy
from std_msgs.msg import String
import socket

def on_message_received(msg):
    rospy.loginfo("Received message on 'testa': %s", msg.data)
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as tcp_socket:
            # 连接到系统B的TCP服务器
            tcp_socket.connect(('SYSTEM_B_IP', 10000))
            rospy.loginfo("Sending message to System B")
            tcp_socket.sendall(msg.data.encode('utf-8'))
    except Exception as e:
        rospy.logerr("Could not send message to System B: %s", e)

def testa_listener():
    rospy.init_node('testa_listener', anonymous=True)
    rospy.Subscriber('testa', String, on_message_received)
    rospy.spin()

if __name__ == '__main__':
    testa_listener()

这个Python程序是为了作为机器人操作系统（Robot Operating System，简称ROS）网络的一部分而设计的。它监听特定的ROS主题上的消息，并在收到消息后，通过TCP套接字连接将该消息转发到另一个系统（称为”System B”）。该程序使用了rospy库，这是ROS的Python客户端库，以及socket库用于网络通信。

运行示例：

以下是对程序各个部分的详细分析：

导入模块

import rospy
from std_msgs.msg import String
import socket

rospy是ROS的Python客户端API，提供了与ROS交互所需的功能。
std_msgs.msg是提供标准ROS消息类型的包。这里导入了消息类型String。
socket是Python模块，提供了对BSD套接字接口的访问，允许通过网络进行通信。

回调函数

def callback(msg):
    rospy.loginfo("Received on testa: %s", msg.data)
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
            sock.connect(('SYSTEM_B_IP', 10000))
            rospy.loginfo("Sending message to System B")
            sock.sendall(msg.data.encode('utf-8'))
    except socket.error as exc:
        rospy.logerr("Caught exception socket.error : %s", exc)

callback是一个函数，当在ROS主题’testa’上接收到新消息时调用。
rospy.loginfo用于记录接收到的消息。
使用socket.socket(socket.AF_INET, socket.SOCK_STREAM)创建了一个TCP套接字。
AF_INET表示使用的是IPv4。
SOCK_STREAM表示它是一个TCP套接字。
套接字尝试连接到’SYSTEM_B_IP’的10000端口。’SYSTEM_B_IP’应该替换为System B的实际IP地址。
成功连接后，会打印另一个日志消息，表示消息正在发送到System B。
从ROS主题收到的消息通过.encode(‘utf-8’)转换为UTF-8编码的字节串，然后通过套接字发送。
如果在尝试建立连接或发送数据时出现socket.error异常，将通过rospy.logerr记录错误信息。

三、监听器函数

def listener():
    rospy.init_node('testa_listener', anonymous=True)
    rospy.Subscriber('testa', String, callback)
    rospy.spin()

listener函数初始化了一个名为’testa_listener’的ROS节点。
rospy.init_node用于初始化节点，anonymous=True表示在节点名称后添加随机数以确保名称的唯一性。
rospy.Subscriber创建了一个订阅者，订阅名为’testa’的主题，并指定当有消息到达时调用callback函数。
rospy.spin()是一个不会返回的循环，它会保持程序运行并等待消息到达。

主函数

if __name__ == '__main__':
    listener()

当Python脚本作为主程序运行时（而不是被导入到另一个脚本中），listener()函数会被调用，启动整个流程。

注意事项
需要确保ROS环境已经设置好，并且此脚本在ROS网络中的适当位置运行。
‘SYSTEM_B_IP’必须被替换为正确的目标IP地址。
程序没有处理发送消息后的响应或确认，只是单向发送。
rospy.spin()会阻塞当前线程，所以如果需要执行其他任务，应该考虑将监听过程放在另一个线程或使用异步方式。

四、系统B

在系统B上，创建一个节点tcp_publisher_b.py，它订阅话题testb并将消息发送到系统A。

#!/usr/bin/env python
import rospy
from std_msgs.msg import String
import socket

def tcp_server():
    rospy.init_node('tcp_server', anonymous=True)
    pub = rospy.Publisher('testb', String, queue_size=10)

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('', 10000))  # 绑定所有可用的接口
    server_socket.listen(1)
    rospy.loginfo("TCP Server listening on port 10000")

    while not rospy.is_shutdown():
        rospy.loginfo("Waiting for connection...")
        connection, client_address = server_socket.accept()
        rospy.loginfo("Connected with %s", client_address)
        try:
            while True:
                data = connection.recv(1024)
                if data:
                    message = data.decode('utf-8')
                    rospy.loginfo("Publishing received message to 'testb': %s", message)
                    pub.publish(message)
                else:
                    break
        finally:
            connection.close()

if __name__ == '__main__':
    tcp_server()

服务端接收信息示例：

五、分析

这个Python程序是一个基于ROS (Robot Operating System) 的TCP服务器，它监听特定端口上的TCP连接，并将接收到的数据发布到ROS主题。以下是对程序的详尽分析：
导入模块

import rospy
from std_msgs.msg import String
import socket

rospy 是ROS的Python客户端API，提供了与ROS交互所需的功能。
std_msgs.msg 是提供标准ROS消息类型的包。这里导入了消息类型 String。
socket 是Python模块，提供了对BSD套接字接口的访问，允许通过网络进行通信。

TCP服务器函数

def tcp_server():
    rospy.init_node('tcp_server', anonymous=True)
    pub = rospy.Publisher('testb', String, queue_size=10)

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('', 10000))  # 绑定所有可用的接口
    server_socket.listen(1)
    rospy.loginfo("TCP Server listening on port 10000")

    while not rospy.is_shutdown():
        rospy.loginfo("Waiting for connection...")
        connection, client_address = server_socket.accept()
        rospy.loginfo("Connected with %s", client_address)
        try:
            while True:
                data = connection.recv(1024)
                if data:
                    message = data.decode('utf-8')
                    rospy.loginfo("Publishing received message to 'testb': %s", message)
                    pub.publish(message)
                else:
                    break
        finally:
            connection.close()

tcp_server 函数首先初始化一个名为 ‘tcp_server’ 的ROS节点。anonymous=True 参数确保每次启动该节点时都有一个独一无二的名称，避免节点名称冲突。

创建了一个 Publisher 对象 pub，用于发布消息到名为 ‘testb’ 的ROS主题，队列大小设置为10。

创建了一个TCP套接字，并绑定到主机的空字符串地址和端口10000上。空字符串意味着服务器将接受任何可用网络接口的连接。

通过 server_socket.listen(1) 开始监听传入的连接，这里的参数1指定了操作系统可以挂起的最大连接数。

进入一个循环，循环体内首先检查 rospy.is_shutdown()，以确定是否应该退出循环，这通常是响应于ROS节点关闭的信号。

使用 server_socket.accept() 阻塞等待一个新的连接。当一个新的客户端连接时，它返回一个新的套接字对象 connection 和客户端的地址 client_address。

一旦建立连接，程序将打印客户端地址，并进入另一个循环接收数据。使用 connection.recv(1024) 接收数据，这里的1024表示最大数据量的字节数。

如果收到数据，则将其解码为UTF-8格式的字符串，并打印日志信息，然后通过之前创建的 Publisher 对象将消息发布到 ‘testb’ 主题。

如果没有收到数据（data 为空），则退出接收循环。

无论是因为接收到空数据还是由于其他异常，最终都会关闭与客户端的连接。

主函数

if __name__ == '__main__':
    tcp_server()

当Python脚本作为主程序运行时，tcp_server() 函数会被调用，启动TCP服务器。

注意事项

需要确保ROS环境已经设置好，并且此脚本在ROS网络中的适当位置运行。

服务器使用 rospy 的日志功能来记录信息，便于调试和跟踪。

TCP服务器会一直运行，直到ROS节点被关闭。

这个程序仅支持同时处理一个客户端连接,如果需要同时处理多个连接，可以考虑使用多线程或异步IO来接收来自不同客户端的连接。

如果客户端发送的数据超过1024字节，数据将被截取，只有前1024字节会被接收和处理。如果需要处理更大的数据，需要增加recv方法的缓冲区大小或实现某种形式的分块接收逻辑。

补充

tcp_server() 函数完成的工作如下：

1.使用 rospy.init_node 初始化了一个名为 ‘tcp_server’ 的ROS节点。anonymous=True 参数使得每次启动该节点时，都会在节点名称后附加一个随机数，以确保节点名称的唯一性。

2.创建了一个 Publisher 对象 pub，用于将接收到的字符串消息发布到名为 ‘testb’ 的ROS主题。queue_size=10 表示消息队列的大小，这决定了在处理消息之前可以积累多少未处理的消息。

3.创建了一个TCP套接字 server_socket，使用IPv4(socket.AF_INET) 和TCP 协议(socket.SOCK_STREAM)。

4.套接字绑定到所有可用接口的端口10000上。在 server_socket.bind((‘’, 10000)) 调用中，空字符串 ‘’ 表示服务器将接受任何可用网络接口上的连接。

5.通过 server_socket.listen(1)，服务器开始监听传入的连接请求。参数 1 指定了操作系统可以挂起的最大连接数，即服务器未处理的连接队列长度。

6.进入一个循环，循环的继续条件是 rospy.is_shutdown() 返回 False，这是一个检查ROS节点是否接收到了关闭信号（如Ctrl+C）的方法。

7.在循环内部，首先打印等待连接的日志信息，然后使用 server_socket.accept() 阻塞等待一个新的连接。当有新的连接请求时，accept() 方法返回一个新的套接字对象 connection 和客户端的地址 client_address。

8.当有客户端连接后，进入另一个无限循环，不断地接收来自客户端的数据。使用 connection.recv(1024) 接收最多1024字节的数据。

9.如果接收到数据，它将数据解码为UTF-8格式的字符串，打印相关的日志信息，然后将解码后的字符串作为 String 类型的消息发布到 ‘testb’ 主题。

10.如果接收到的数据为空，这意味着客户端已经关闭了连接，于是退出接收循环。