如何将从 rospy.Subscriber 数据获得的数据提供给变量？

Question

我写了一个示例订阅者。我想将从 rospy.Subscriber 获得的数据提供给另一个变量，以便我稍后可以在程序中使用它进行处理。目前我可以看到订阅者正在运行，因为当我使用 rospy.loginfo() 函数时，我可以看到正在打印的订阅值。虽然我不知道如何将这些数据存储到另一个变量中。我曾尝试使用赋值运算符“=”将其直接分配给变量，但出现错误。

我尝试使用 rospy.loginfo 编写回调函数来打印订阅对象的位置数据。我已经订阅了 JointState 并且它包含头、位置、速度和努力数组。使用 rospy.loginfo 我可以验证订阅者是否正在订阅。但是当我尝试将它直接分配给变量时，出现错误。

我正在显示来自回调函数的日志信息，如下所示

def callback(data):
   rospy.loginfo(data.position)
   global listen
    listen = rospy.Subscriber("joint_states", JointState, 
    callback)
    rospy.spin()

这很好用。但是当我稍微修改代码以分配订阅的值时，我收到以下错误即

   listen1 = rospy.Subscriber("joint_states", JointState, 
   callback=None)
   listen = listen1.position
   #rospy.loginfo(listen)
   print(listen)
   rospy.spin()```

The error is as follows, 
 ```listen = listen1.position
    AttributeError: 'Subscriber' object has no attribute 'position'

编辑：这是我在程序中定义的节点，

    #rospy.loginfo(msg.data)
    global tactile_states
    tactile_states = data.data

def joint_callback(data):
    #rospy.loginfo(data.position)
    global g_joint_states 
    global g_position
    global g_pos1
    g_joint_states = data
    #for i in len(data.position):
        #g_position[i] = data.position[i]
    g_position = data.position
    if len(data.position) > 0:
        print("jointstate more than 0")
        g_pos1 = data.position[0]
    #print(g_position)


def joint_modifier(*args):
    #choice describes what the node is supposed to do whether act as publisher or subscribe to joint states or tactile sensors
    rospy.init_node('joint_listener_publisher', anonymous=True)
    pub1 = rospy.Publisher('joint_states', JointState, queue_size = 10)
    if(len(args)>1):
        choice = args[0]
        joint_name = args[1]
        position = args[2]
    else:
        choice = args[0]
    if (choice == 1):
        rate = rospy.Rate(1)
        robot_configuration = JointState()
        robot_configuration.header = Header()
        robot_configuration.name = [joint_name]
        robot_configuration.position = [position]
        robot_configuration.velocity = [10]
        robot_configuration.effort = [100]
        while not rospy.is_shutdown():
            robot_configuration.header.stamp = rospy.Time.now()
            rospy.loginfo(robot_configuration)
            break
        pub1.publish(robot_configuration)
        rospy.sleep(2)
    if (choice == 2):
        #rospy.Timer(rospy.Duration(2), joint_modifier)
        listen = rospy.Subscriber("joint_states", JointState, joint_callback)
        rospy.spin()
    if (choice == 3):
        #rospy.Timer(rospy.Duration(2), joint_modifier)
        tactile_sub = rospy.Subscriber("/sr_tactile/touch/ff", Float64, tactile_callback)
        rospy.spin()

这就是我在程序主体内调用节点的方式，

           joint_modifier(2)
           print("printing g_position")
           print(g_position)#to check the format of g_position
           print("printed g _position")
           leg_1 = Leg_attribute(g_position[0], g_position[1], g_position[2], velocity1 = 10, velocity2 = 10, velocity3 = 10, effort1 = 100, effort2 = 100, effort3 = 100, acceleration=1)

以这种方式调用时，程序会停留在joint_modifier(2)该函数具有rospy.spin().

Answer 1

您使用的样式不是很标准。我假设您已经在 ROS wiki 上看到了该示例，我已对其进行了修改以演示下面的标准用法。

主要是，针对您发布的代码，您需要listen在回调之外具有全局范围。这是为了存储data您想要的对象，而不是订阅者对象。rospy.spin() 永远不会进入回调，只会进入主节点函数/部分。订阅者对象listen1不经常使用，不会返回任何内容，也不存储它获取的数据。也就是说，您需要 Subscriber() 来进行非 None 回调。它更像是 a bind，将 给予data，callback而不是从订阅者返回它。这就是为什么listen1 (Subscriber)没有属性position (JointState)。

import rospy
from sensor_msgs.msg import JointState

# Subscribers
#     joint_sub (sensor_msgs/JointState): "joint_states"

# This is where you store all your data you recieve
g_joint_states = None
g_positions = None
g_pos1 = None

def timer_callback(event): # Type rospy.TimerEvent
    print('timer_cb (' + str(event.current_real) + '): g_positions is')
    print(str(None) if g_positions is None else str(g_positions))

def joint_callback(data): # data of type JointState
    # Each subscriber gets 1 callback, and the callback either
    # stores information and/or computes something and/or publishes
    # It _does not!_ return anything
    global g_joint_states, g_positions, g_pos1
    rospy.loginfo(data.position)
    g_joint_states = data
    g_positions = data.position
    if len(data.position) > 0:
        g_pos1 = data.position[0]
    print(g_positions)

# In your main function, only! here do you subscribe to topics
def joint_logger_node():
    # Init ROS
    rospy.init_node('joint_logger_node', anonymous=True)

    # Subscribers
    # Each subscriber has the topic, topic type, AND the callback!
    rospy.Subscriber('joint_states', JointState, joint_callback)
    # Rarely need to hold onto the object with a variable: 
    #     joint_sub = rospy.Subscriber(...)
    rospy.Timer(rospy.Duration(2), timer_callback)

    # spin() simply keeps python from exiting until this node is stopped
    # This is an infinite loop, the only code that gets ran are callbacks
    rospy.spin()
    # NO CODE GOES AFTER THIS, NONE! USE TIMER CALLBACKS!
    # unless you need to clean up resource allocation, close(), etc when program dies

if __name__ == '__main__':
    joint_logger_node()

编辑 1： Subscriber()、spin() 和 _callback(s) 的作用似乎有些混乱。在Python中有点晦涩难懂，但是有一个主程序来管理所有节点，并在它们之间发送节点。在每个节点中，我们向主程序注册该节点存在以及它有哪些发布者和订阅者。通过注册，意味着我们告诉主程序，“嘿，我想要那个主题！”；在您的情况下，对于您的（未声明的）joint_sub 订阅者，“嘿，我想要JointState该joint_states主题的所有消息！” 主程序每次（从某个发布者处）收到一条新消息时joint_states JointState，都会将其发送给该订阅者。订阅者通过回调处理、处理和处理消息（数据）：当（！）我收到消息时，运行回调。

因此主程序收到joint_states JointState来自某个发布者的新消息。然后，因为我们向它注册了订阅者，所以它会将其发送到该节点。rospy.spin() 是一个等待该数据的无限循环。这就是它的作用（主要是）：

def rospy.spin():
    while rospy.ok():
        for new_msg in get_new_messages from master():
            if I have a subscriber to new_msg:
                my_subscriber.callback(new_msg)

rospy.spin() 是回调、joint_callback（和/或timer_callback等）实际被调用和执行的地方。它仅在有数据时运行。

更根本的是，我认为由于这种混乱，你的程序结构是有缺陷的；你的功能并没有像你想象的那样做。这就是你应该如何制作你的节点。

1. 将执行神经网络的数学部分（所有真正的非 ros 代码）放入一个单独的模块中，并创建一个函数来运行它。
2. 如果您只想在收到数据时运行它，请在回调中运行它。如果要发布结果，请在回调中发布。
3. 不要调用main函数！这if __name__ == '__main__': my_main_function()应该是它被调用的唯一地方，这将调用您的代码。我重复一遍：声明订阅者/发布者/init/定时器/参数的主函数仅在 中运行if __name__ ...，并且该函数运行您的代码。要让它运行您的代码，请将您的代码放在回调中。定时器回调对此很方便。

我希望这个代码示例能够澄清：

import rospy
from std_msgs.msg import Header
from sensor_msgs.msg import JointState
import my_nn as nn # nn.run(data)

# Subscribers
#     joint_sub (sensor_msgs/JointState): "joint_states"

# Publishers
#     joint_pub (sensor_msgs/JointState): "target_joint_states"

joint_pub = None

def joint_callback(data): # data of type JointState
    pub_msg = JointState() # Make a new msg to publish results
    pub_msg.header = Header()
    pub_msg.name = data.name
    pub_msg.velocity = [10] * len(data.name)
    pub_msg.effort = [100] * len(data.name)
    # This next line might not be quite right for what you want to do,
    # But basically, run the "real code" on the data, and get the
    # result to publish back out
    pub_msg.position = nn.run(data.position) # Run NN on data, store results
    joint_pub.publish(pub_msg) # Send it when ready!

if __name__ == '__main__':
    # Init ROS
    rospy.init_node('joint_logger_node', anonymous=True)
    # Subscribers
    rospy.Subscriber('joint_states', JointState, joint_callback)
    # Publishers
    joint_pub = rospy.Publisher('target_joint_states', JointState, queue_size = 10)
    # Spin
    rospy.spin()
    # No more code! This is not a function to call, but its
    # own program! This is an executable! Run your code in
    # a callback!

请注意，我们设计为 ros 节点的 python 模块没有可调用的函数。它具有定义的回调结构和它们之间共享的全局数据，所有这些都在主函数 / 中初始化和注册if __name__ == '__main__'。