Question

我写了一个样本订户。我想将从rospy.Subscriber获得的数据输入另一个变量，以便以后可以在程序中使用它进行处理。目前，我可以看到订阅服务器正在运行，因为当我使用rospy.loginfo（）函数时，可以看到正在打印订阅的值。虽然我不知道如何将这些数据存储到另一个变量中。我曾尝试使用赋值运算符'='将其直接赋值给变量，但出现错误。

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

我正在通过回调函数显示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上看到了example，我对其进行了修改，以在下面演示标准用法。

首先，解决您发布的代码，您需要使listen在回调之外具有全局作用域。这是为了存储所需的data，而不是Subscriber对象。 rospy.spin（）永远不会进入回调，而只会进入主节点函数/节。很少使用的订阅者对象listen1不返回任何内容，也不存储所获取的数据。也就是说，您需要Subscriber（）具有非None回调。它更像是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消息时，都会将其发送给该订阅者。订阅者使用回调处理，处理和处理味精（数据）：when（！）我收到一条消息，运行回调。

因此，主程序从某个发布者那里收到了一个新的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等）的实际调用和执行位置。当有数据时，它仅运行。

从根本上来说，我认为由于这种混乱，您的程序结构有缺陷；您的功能不执行您认为的功能。这就是建立节点的方式。

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

我希望此代码示例能够阐明：

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模块具有要调用的 no 函数。它具有已定义的回调结构和它们之间共享的全局数据，所有这些回调都已初始化并注册在__init__中。

如何将从rospy.Subscriber数据获得的数据输入变量？

1 个答案: