def __init__(self, topic, client_id, callback, node_handle, msg_type=None):
""" Register a subscriber on the specified topic.
Keyword arguments:
topic -- the name of the topic to register the subscriber on
client_id -- the ID of the client subscribing
callback -- this client's callback, that will be called for incoming
messages
node_handle -- Handle to a rclpy node to create the publisher.
msg_type -- (optional) the type to register the subscriber as. If not
provided, an attempt will be made to infer the topic type
Throws:
TopicNotEstablishedException -- if no msg_type was specified by the
caller and the topic is not yet established, so a topic type cannot
be inferred
TypeConflictException -- if the msg_type was specified by the
caller and the topic is established, and the established type is
different to the user-specified msg_type
"""
# First check to see if the topic is already established
topics_names_and_types = dict(node_handle.get_topic_names_and_types())
topic_type = topics_names_and_types.get(topic)
# If it's not established and no type was specified, exception
if msg_type is None and topic_type is None:
raise TopicNotEstablishedException(topic)
# topic_type is a list of types or None at this point; only one type is supported.
if topic_type is not None:
if len(topic_type) > 1:
node_handle.get_logger().warning(
'More than one topic type detected: {}'.format(topic_type))
topic_type = topic_type[0]
# Use the established topic type if none was specified
if msg_type is None:
msg_type = topic_type
# Load the message class, propagating any exceptions from bad msg types
msg_class = ros_loader.get_message_class(msg_type)
# Make sure the specified msg type and established msg type are same
msg_type_string = msg_class_type_repr(msg_class)
if topic_type is not None and topic_type != msg_type_string:
raise TypeConflictException(topic, topic_type, msg_type_string)
# Create the subscriber and associated member variables
# Subscriptions is initialized with the current client to start with.
self.subscriptions = {client_id: callback}
self.lock = Lock()
self.topic = topic
self.msg_class = msg_class
self.node_handle = node_handle
# TODO(@jubeira): add support for other QoS.
self.subscriber = node_handle.create_subscription(
msg_class, topic, self.callback, 10)
self.new_subscriber = None
self.new_subscriptions = {}
def __init__(self,
topic,
msg_type=None,
latched_client_id=None,
queue_size=100):
""" Register a publisher on the specified topic.
Keyword arguments:
topic -- the name of the topic to register the publisher to
msg_type -- (optional) the type to register the publisher as. If not
provided, an attempt will be made to infer the topic type
latch -- (optional) if a client requested this publisher to be latched,
provide the client_id of that client here
Throws:
TopicNotEstablishedException -- if no msg_type was specified by the
caller and the topic is not yet established, so a topic type cannot
be inferred
TypeConflictException -- if the msg_type was specified by the
caller and the topic is established, and the established type is
different to the user-specified msg_type
"""
# First check to see if the topic is already established
topic_type = get_topic_type(topic)[0]
# If it's not established and no type was specified, exception
if msg_type is None and topic_type is None:
raise TopicNotEstablishedException(topic)
# Use the established topic type if none was specified
if msg_type is None:
msg_type = topic_type
# Load the message class, propagating any exceptions from bad msg types
msg_class = ros_loader.get_message_class(msg_type)
# Make sure the specified msg type and established msg type are same
if topic_type is not None and topic_type != msg_class._type:
raise TypeConflictException(topic, topic_type, msg_class._type)
# Create the publisher and associated member variables
self.clients = {}
self.latched_client_id = latched_client_id
self.topic = topic
self.msg_class = msg_class
self.publisher = Publisher(topic,
msg_class,
latch=(latched_client_id != None),
queue_size=queue_size)
self.listener = PublisherConsistencyListener()
self.listener.attach(self.publisher)
def verify_type(self, msg_type):
""" Verify that the subscriber subscribes to messages of this type.
Keyword arguments:
msg_type -- the type to check this subscriber against
Throws:
Exception -- if ros_loader cannot load the specified msg type
TypeConflictException -- if the msg_type is different than the type of
this publisher
"""
if not ros_loader.get_message_class(msg_type) is self.msg_class:
raise TypeConflictException(self.topic, self.msg_class._type,
msg_type)
return
def __init__(self, topic, msg_type=None):
""" Register a subscriber on the specified topic.
Keyword arguments:
topic -- the name of the topic to register the subscriber on
msg_type -- (optional) the type to register the subscriber as. If not
provided, an attempt will be made to infer the topic type
Throws:
TopicNotEstablishedException -- if no msg_type was specified by the
caller and the topic is not yet established, so a topic type cannot
be inferred
TypeConflictException -- if the msg_type was specified by the
caller and the topic is established, and the established type is
different to the user-specified msg_type
"""
# First check to see if the topic is already established
topic_type = get_topic_type(topic)[0]
# If it's not established and no type was specified, exception
if msg_type is None and topic_type is None:
raise TopicNotEstablishedException(topic)
# Use the established topic type if none was specified
if msg_type is None:
msg_type = topic_type
if msg_type == "__AnyMsg":
msg_class = AnyMsg
else:
# Load the message class, propagating any exceptions from bad msg types
msg_class = ros_loader.get_message_class(msg_type)
# Make sure the specified msg type and established msg type are same
if topic_type is not None and topic_type != msg_class._type:
raise TypeConflictException(topic, topic_type, msg_class._type)
# Create the subscriber and associated member variables
self.subscriptions = {}
self.lock = Lock()
self.topic = topic
self.msg_class = msg_class
self.subscriber = Subscriber(topic, msg_class, self.callback)
def __init__(self,
topic,
node_handle,
msg_type=None,
latched_client_id=None,
queue_size=100):
""" Register a publisher on the specified topic.
Keyword arguments:
topic -- the name of the topic to register the publisher to
node_handle -- Handle to a rclpy node to create the publisher.
msg_type -- (optional) the type to register the publisher as. If not
provided, an attempt will be made to infer the topic type
latch -- (optional) if a client requested this publisher to be latched,
provide the client_id of that client here
Throws:
TopicNotEstablishedException -- if no msg_type was specified by the
caller and the topic is not yet established, so a topic type cannot
be inferred
TypeConflictException -- if the msg_type was specified by the
caller and the topic is established, and the established type is
different to the user-specified msg_type
"""
# First check to see if the topic is already established
topics_names_and_types = dict(node_handle.get_topic_names_and_types())
topic_type = topics_names_and_types.get(topic)
# If it's not established and no type was specified, exception
if msg_type is None and topic_type is None:
raise TopicNotEstablishedException(topic)
# topic_type is a list of types or None at this point; only one type is supported.
if topic_type is not None:
if len(topic_type) > 1:
node_handle.get_logger().warning(
'More than one topic type detected: {}'.format(topic_type))
topic_type = topic_type[0]
# Use the established topic type if none was specified
if msg_type is None:
msg_type = topic_type
# Load the message class, propagating any exceptions from bad msg types
msg_class = ros_loader.get_message_class(msg_type)
# Make sure the specified msg type and established msg type are same
msg_type_string = msg_class_type_repr(msg_class)
if topic_type is not None and topic_type != msg_type_string:
raise TypeConflictException(topic, topic_type, msg_type_string)
# Create the publisher and associated member variables
self.clients = {}
self.latched_client_id = latched_client_id
self.topic = topic
self.node_handle = node_handle
self.msg_class = msg_class
# Adding a lifespan solves the problem of late-joining subscribers
# without the need of a custom message publisher implementation.
publisher_qos = QoSProfile(depth=queue_size,
durability=QoSDurabilityPolicy.
RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL)
# For latched clients, no lifespan has to be specified (i.e. latch forever).
# Otherwise we want to keep the messages for a second to prevent late-joining subscribers from
# missing messages.
if latched_client_id is None:
publisher_qos.lifespan = Duration(seconds=1)
else:
publisher_qos.depth = 1
self.publisher = node_handle.create_publisher(
msg_class, topic, qos_profile=publisher_qos)