def test_find_extensions():
p_qos = dds.DomainParticipantQos()
p_qos << dds.EntityName("MyParticipant1")
assert p_qos.participant_name.name == "MyParticipant1"
p1 = dds.DomainParticipant(DOMAIN_ID, p_qos)
assert p1.qos.participant_name.name == "MyParticipant1"
p_qos << dds.EntityName("MyParticipant2")
p2 = dds.DomainParticipant(DOMAIN_ID, p_qos)
assert dds.DomainParticipant.find("MyParticipant1") == p1
assert dds.DomainParticipant.find("MyParticipant2") == p2
assert dds.DomainParticipant.find("MyParticipant3") == None
def replier_main(domain_id):
global request_serviced
participant = dds.DomainParticipant(domain_id)
qos_provider = dds.QosProvider.default
type_provider = dds.QosProvider('Primes.xml')
request_type = type_provider.type("PrimeNumberRequest")
reply_type = type_provider.type("PrimeNumberReply")
status_type = type_provider.type("PrimeNumberCalculationStatus")
def request_handler(request):
global request_serviced
request_serviced = True
if (request["n"] <= 0 or request["primes_per_reply"] <= 0
or request["primes_per_reply"] >
reply_type["primes"].type.bounds):
error_reply = dds.DynamicData(reply_type)
error_reply["status"] = status_type["REPLY_ERROR"]
print("Error, requester asked for too many primes per reply")
return error_reply
else:
print("Calculating prime numbers below {}...".format(request["n"]))
n = request["n"]
max_count = request["primes_per_reply"]
primes = dds.Int32Seq()
reply = dds.DynamicData(reply_type)
for m in xrange(1, n + 1):
if is_prime(m):
primes.append(m)
if len(primes) > max_count:
reply["status"] = status_type["REPLY_ERROR"]
print(
"Error: too many calculated primes for a single reply"
)
return reply
reply["primes"] = primes
reply["status"] = status_type["REPLY_COMPLETED"]
print("DONE")
return reply
replier = rti.request.SimpleReplier(
request_type,
reply_type,
participant,
request_handler,
service_name="PrimeCalculator",
datawriter_qos=qos_provider.datawriter_qos_from_profile(
"RequestReplyExampleProfiles::RequesterExampleProfile"),
datareader_qos=qos_provider.datareader_qos_from_profile(
"RequestReplyExampleProfiles::RequesterExampleProfile"))
print(
"Prime calculation replier started on domain {}...".format(domain_id))
while request_serviced:
request_serviced = False
time.sleep(20)
print("Timed out waiting for requests")
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
# Participant properties give access to the builtin readers
participant.participant_reader.bind_listener(
BuiltinParticipantListener(),
dds.StatusMask.data_available())
participant.subscription_reader.bind_listener(
BuiltinSubscriptionListener(),
dds.StatusMask.data_available())
msg_type = dds.QosProvider('msg.xml').type('builtin_topics_lib', 'msg')
topic = dds.DynamicData.Topic(participant, 'Example msg', msg_type)
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic)
instance = dds.DynamicData(msg_type)
# write samples in a loop, incrementing the 'x' field
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
instance['x'] = count
writer.write(instance, dds.InstanceHandle())
count += 1
assert count == 5
def test_data_reader_writer():
with dds.DomainParticipant(0) as participant:
topic = dds.StringTopicType.Topic(participant, "pub_sub_example")
# Create qos for both, add reliable and keep all
writer_qos = participant.implicit_publisher.default_datawriter_qos
writer_qos << dds.Reliability.reliable()
writer_qos << dds.History.keep_all()
writer_qos << dds.Durability.transient_local()
# Create the reader qos
reader_qos = participant.implicit_subscriber.default_datareader_qos
reader_qos << dds.Reliability.reliable()
reader_qos << dds.History.keep_all()
reader_qos << dds.Durability.transient_local()
writer = dds.StringTopicType.DataWriter(participant.implicit_publisher,
topic, writer_qos)
reader = dds.StringTopicType.DataReader(
participant.implicit_subscriber, topic, reader_qos)
# Need to have reader check for writer and vice versa here
# writer.wait_for_acknowledgments(1000)
count = 0
for i in range(1, 6):
writer.write("Hello World " + str(i))
while len(reader.read()) < 5:
time.sleep(0.001)
for x, y in reader.read():
count += 1
assert x == f"Hello World {count}"
assert count == 5
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
# Participant properties give access to the builtin readers
participant.participant_reader.bind_listener(
BuiltinParticipantListener(), dds.StatusMask.DATA_AVAILABLE
)
participant.subscription_reader.bind_listener(
BuiltinSubscriptionListener(), dds.StatusMask.DATA_AVAILABLE
)
participant.enable()
msg_type = dds.QosProvider("msg.xml").type("builtin_topics_lib", "msg")
topic = dds.DynamicData.Topic(participant, "Example msg", msg_type)
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic)
instance = dds.DynamicData(msg_type)
# write samples in a loop, incrementing the 'x' field
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
instance["x"] = count
writer.write(instance, dds.InstanceHandle())
count += 1
def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
wsqc_type = dds.QosProvider("waitset_cond.xml").type("wssc_lib", "Foo")
topic = dds.DynamicData.Topic(participant, "Example Foo", wsqc_type)
reader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic, reader_qos)
# Get the StatusCondition associated with the reader and set the mask to get liveliness updates
status_condition = dds.StatusCondition(reader)
status_condition.enabled_statuses = dds.StatusMask.LIVELINESS_CHANGED
# Create a ReadCondition to get any data
read_condition = dds.ReadCondition(reader, dds.DataState.any_data)
# Create WaitSet and attach conditions
waitset = dds.WaitSet()
waitset += status_condition
waitset += read_condition
count = Counter()
while (sample_count == 0) or (count.value < sample_count):
active = waitset.wait(4.0)
# Check conditions after wait to see if anything triggered
if status_condition in active:
status_handler(reader)
if read_condition in active:
rc_handler(reader, count)
def test_sending_dict():
s1 = dds.DynamicData(COORD_TYPE)
s1["x"] = 1
s1["y"] = 2
my_dict = {"x": 1, "y": 2}
with dds.DomainParticipant(0) as participant:
topic = dds.DynamicData.Topic(participant, "dictionary_test",
COORD_TYPE)
# Create qos for both, add reliable and keep all
writer_qos = participant.implicit_publisher.default_datawriter_qos
writer_qos << dds.Reliability.reliable()
writer_qos << dds.History.keep_all()
writer_qos << dds.Durability.transient_local()
# Create the reader qos
reader_qos = participant.implicit_subscriber.default_datareader_qos
reader_qos << dds.Reliability.reliable()
reader_qos << dds.History.keep_all()
reader_qos << dds.Durability.transient_local()
writer = dds.DynamicData.DataWriter(participant.implicit_publisher,
topic, writer_qos)
reader = dds.DynamicData.DataReader(participant.implicit_subscriber,
topic, reader_qos)
writer.write(my_dict)
while len(reader.read()) < 1:
time.sleep(0.001)
for s2 in reader.take():
print(s2.data)
print(type(s2.data))
# Makes for easy debugging
assert type(s2.data) == type(s1)
assert s2.data == s1
def run_example(domain_id, sample_count):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# Create a DomainParticipant with default Qos
with dds.DomainParticipant(domain_id) as participant:
# A QosProvider is used here to get the type from the file
# HelloWorld.xml
provider = dds.QosProvider(FILE)
provider_type = provider.type("HelloWorld")
# A Topic has a name and a datatype. Create a Topic named
# "HelloWorld Topic" with type HelloWorld
topic = dds.DynamicData.Topic(
participant, "Example HelloWorld", provider_type
)
# A Subscriber allows an application to create one or more DataReaders
# Subscriber QoS is configured in USER_QOS_PROFILES.xml
subscriber = dds.Subscriber(participant)
# This DataReader will read data of type HelloWorld on Topic
# "HelloWorld Topic". DataReader QoS is configured in
# USER_QOS_PROFILES.xml
reader = dds.DynamicData.DataReader(subscriber, topic)
# Obtain the DataReader's Status Condition
status_condition = dds.StatusCondition(reader)
# Enable the 'data available' status.
status_condition.enabled_statuses = dds.StatusMask.data_available()
# Initialize samples_read to zero
samples_read = 0
# Associate a handler with the status condition. This will run when the
# condition is triggered, in the context of the dispatch call (see below)
def handler(_): # condition argument is not used
nonlocal samples_read
nonlocal reader
samples_read += process_data(reader)
status_condition.set_handler(handler)
# Create a WaitSet and attach the StatusCondition
waitset = dds.WaitSet()
waitset += status_condition
# Catch control c interrupt
try:
while samples_read < sample_count:
# Dispatch will call the handlers associated to the WaitSet conditions
# when they activate
print(f"Hello World subscriber sleeping for 4 seconds...")
waitset.dispatch(dds.Duration(4)) # Wait up to 4s each time
except KeyboardInterrupt:
pass
def test_set_qos_exception():
p = dds.DomainParticipant(DOMAIN_ID, dds.DomainParticipantQos())
qos = p.qos
d = dds.Duration(77)
db = dds.Database()
db.shutdown_cleanup_period = d
qos << db
with pytest.raises(dds.ImmutablePolicyError):
p.qos = qos
def test_participant_creation_w_qos():
user_data_values = [10, 11, 12, 13, 14, 15]
qos = dds.DomainParticipantQos()
qos.user_data.value = user_data_values
qos.database.shutdown_cleanup_period = dds.Duration.from_milliseconds(100)
p = dds.DomainParticipant(DOMAIN_ID, qos)
retrieved_qos = p.qos
assert retrieved_qos.user_data.value == user_data_values
assert (
retrieved_qos.database.shutdown_cleanup_period
== dds.Duration.from_milliseconds(100)
)
def requester_main(domain_id, n, primes_per_reply):
participant = dds.DomainParticipant(domain_id)
qos_provider = dds.QosProvider.default
type_provider = dds.QosProvider('Primes.xml')
request_type = type_provider.type("PrimeNumberRequest")
reply_type = type_provider.type("PrimeNumberReply")
status_type = type_provider.type("PrimeNumberCalculationStatus")
requester = request.Requester(
request_type,
reply_type,
participant,
service_name="PrimeCalculator",
datawriter_qos=qos_provider.datawriter_qos_from_profile(
"RequestReplyExampleProfiles::RequesterExampleProfile"),
datareader_qos=qos_provider.datareader_qos_from_profile(
"RequestReplyExampleProfiles::RequesterExampleProfile"))
print("Waiting to discover replier on domain {}...".format(domain_id))
while requester.matched_replier_count == 0:
time.sleep(0.1)
prime_number_request = dds.DynamicData(request_type)
prime_number_request["n"] = n
prime_number_request["primes_per_reply"] = primes_per_reply
print(
"Sending a request to calculate the prime numbers <= {} in sequences of {} or fewer elements"
.format(n, primes_per_reply))
request_id = requester.send_request(prime_number_request)
max_wait = dds.Duration.from_seconds(20)
in_progress = True
while in_progress:
if not requester.wait_for_replies(max_wait,
related_request_id=request_id):
raise dds.TimeoutError("Timed out waitinf for replies")
for reply in (r.data for r in requester.take_replies(request_id)
if r.info.valid):
primes = reply["primes"]
for prime in primes:
print(prime)
if reply["status"] != status_type["REPLY_IN_PROGRESS"]:
in_progress = False
if reply["status"] == status_type["REPLY_ERROR"]:
raise RuntimeError("Error in replier")
print("DONE")
def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
ccf_type = dds.QosProvider("ccf.xml").type("ccf_lib", "Foo")
topic = dds.DynamicData.Topic(participant, "Example ccf", ccf_type)
# Register the custom filter with the Participant
participant.register_contentfilter(ccf.CustomFilterType(), "CustomFilter")
# Set a filter expression and the filter name, then create the CFT
custom_filter = dds.Filter("%0 %1 x", ["2", "divides"])
custom_filter.name = "CustomFilter"
topic = dds.DynamicData.ContentFilteredTopic(
topic, "ContentFilteredTopic", custom_filter
)
print("Filter: 2 divides x")
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic)
reader.bind_listener(CcfListener(), dds.StatusMask.DATA_AVAILABLE)
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
if count == 10:
# Update the filter parameters after 10 seconds
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 15 greater-than x
=========================="""
)
)
topic.filter_parameters = ["15", "greater-than"]
elif count == 20:
# Update the filter again after 20 seconds
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 3 divides x
=========================="""
)
)
topic.filter_parameters = ["3", "divides"]
count += 1
def run_example(domain_id, sample_count, sensor_id):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# Create a DomainParticipant with default Qos
participant = dds.DomainParticipant(domain_id)
# A Topic has a name and a datatype. Create a Topic named
# "ChocolateTemperature" with type Temperature
temperature_type = dds.QosProvider(FILE).type("Temperature")
topic = dds.DynamicData.Topic(participant, "ChocolateTemperature",
temperature_type)
# A Subscriber allows an application to create one or more DataReaders
# Subscriber QoS is configured in USER_QOS_PROFILES.xml
subscriber = dds.Subscriber(participant)
# This DataReader reads data of type Temperature on Topic
# "ChocolateTemperature". DataReader QoS is configured in
# USER_QOS_PROFILES.xml
reader = dds.DynamicData.DataReader(subscriber, topic)
# Obtain the DataReader's Status Condition
status_condition = dds.StatusCondition(reader)
# Enable the 'data available' status.
status_condition.enabled_statuses = dds.StatusMask.data_available()
# Associate a handler with the status condition. This will run when the
# condition is triggered, in the context of the dispatch call (see below)
samples_read = 0
def handler(_):
nonlocal samples_read
nonlocal reader
samples_read += process_data(reader)
status_condition.set_handler(handler)
# Create a WaitSet and attach the StatusCondition
waitset = dds.WaitSet()
waitset += status_condition
try:
# Dispatch will call the handlers associated to the WaitSet conditions
# when they activate
while sample_count is None or samples_read < sample_count:
print("ChocolateTemperature subcriber sleeping for 4 sec...")
waitset.dispatch(dds.Duration(4)) # Wait up to 4s each time
except KeyboardInterrupt:
pass
def replier_main(domain_id):
participant = dds.DomainParticipant(domain_id)
qos_provider = dds.QosProvider.default
type_provider = dds.QosProvider('Primes.xml')
request_type = type_provider.type("PrimeNumberRequest")
reply_type = type_provider.type("PrimeNumberReply")
status_type = type_provider.type("PrimeNumberCalculationStatus")
replier = rti.request.Replier(
request_type,
reply_type,
participant,
service_name="PrimeCalculator",
datawriter_qos=qos_provider.datawriter_qos_from_profile("RequestReplyExampleProfiles::RequesterExampleProfile"),
datareader_qos=qos_provider.datareader_qos_from_profile("RequestReplyExampleProfiles::RequesterExampleProfile"))
print("Prime calculation replier started on domain {}...".format(domain_id))
max_wait = dds.Duration.from_seconds(20)
requests = replier.receive_requests(max_wait)
while len(requests) > 0:
for request in (sample for sample in requests if sample.info.valid):
if (request.data["n"] <= 0 or
request.data["primes_per_reply"] <= 0 or
request.data["primes_per_reply"] > reply_type["primes"].type.bounds):
error_reply = dds.DynamicData(reply_type)
error_reply["status"] = status_type["REPLY_ERROR"]
replier.send_reply(error_reply, request.info)
else:
print("Calculating prime numbers below {}...".format(request.data["n"]))
n = request.data["n"]
max_count = request.data["primes_per_reply"]
primes = dds.Int32Seq()
reply = dds.DynamicData(reply_type)
for m in xrange(1, n + 1):
if is_prime(m):
primes.append(m)
if len(primes) == max_count:
reply["primes"] = primes
reply["status"] = status_type["REPLY_IN_PROGRESS"]
replier.send_reply(reply, request.info, final=False)
primes.clear()
reply["primes"] = primes
reply["status"] = status_type["REPLY_COMPLETED"]
replier.send_reply(reply, request.info)
print("DONE")
requests = replier.receive_requests(max_wait)
def test_retain_for_listener(set_after):
listener = dds.NoOpDomainParticipantListener()
if set_after:
p = utils.create_participant()
p.bind_listener(listener, dds.StatusMask.none())
else:
p = dds.DomainParticipant(DOMAIN_ID, dds.DomainParticipantQos(), listener)
def inner():
with dds.DomainParticipant.find(DOMAIN_ID) as new_p:
assert new_p != None
new_p.bind_listener(None, dds.StatusMask.none())
inner()
assert dds.DomainParticipant.find(DOMAIN_ID) == None
def subscriber_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
subscriber_qos = dds.QosProvider.default.subscriber_qos
subscriber = dds.Subscriber(participant, subscriber_qos)
coherent_type = dds.QosProvider("coherent.xml").type("coherent_lib", "coherent")
topic = dds.DynamicData.Topic(participant, "Example coherent", coherent_type)
datareader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(subscriber, topic, datareader_qos)
reader.bind_listener(CoherentListener(), dds.StatusMask.data_available())
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
wssc_type = dds.QosProvider("waitset_cond.xml").type("wssc_lib", "Foo")
topic = dds.DynamicData.Topic(participant, "Example Foo", wssc_type)
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic)
sample = dds.DynamicData(wssc_type)
count = 0
while (sample_count == 0) or (count < sample_count):
print("Writing Foo, count = {}".format(count))
sample["x"] = count
writer.write(sample)
count += 1
time.sleep(1)
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft")
topic = dds.DynamicData.Topic(participant, "Example cft", cft_type)
writer_qos = dds.QosProvider.default.datawriter_qos
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic, writer_qos)
sample = dds.DynamicData(cft_type)
count = 0
while (sample_count == 0) or (count < sample_count):
print("Writing cft, count={}".format(count))
sample["count"] = count
sample["name"] = "ODD" if count % 2 == 1 else "EVEN"
writer.write(sample)
time.sleep(1)
count += 1
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
wsqc_type = dds.QosProvider("waitset_query_cond.xml").type(
"wsqc_lib", "waitset_query_cond"
)
topic = dds.DynamicData.Topic(participant, "Example waitset_query_cond", wsqc_type)
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic)
instance = dds.DynamicData(wsqc_type)
count = 0
while (sample_count == 0) or (count < sample_count):
print("Writing waitset_query_cond, count = {}".format(count))
instance["x"] = count
instance["name"] = "ODD" if count % 2 == 1 else "EVEN"
writer.write(instance)
count += 1
time.sleep(1)
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
# We can register the custom filter on the writer side
participant.register_contentfilter(ccf.CustomFilterType(), "CustomFilter")
ccf_type = dds.QosProvider("ccf.xml").type("ccf_lib", "Foo")
topic = dds.DynamicData.Topic(participant, "Example ccf", ccf_type)
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic)
instance = dds.DynamicData(ccf_type)
count = 0
while (sample_count == 0) or (count < sample_count):
print("Writing ccf, count={}".format(count))
instance["x"] = count
writer.write(instance)
time.sleep(1)
count += 1
def subscriber_main(domain_id, sample_count, participant_auth):
participant_qos = dds.QosProvider.default.participant_qos
resource_limits_qos = participant_qos.resource_limits
max_participant_user_data = resource_limits_qos.participant_user_data_max_length
# Set the participant auth string as user data bytes
if len(participant_auth) > max_participant_user_data:
raise ValueError("participant user data exceeds resource limits")
else:
participant_qos.user_data.value = bytearray(participant_auth.encode())
participant = dds.DomainParticipant(domain_id, participant_qos)
participant.enable()
msg_type = dds.QosProvider("msg.xml").type("builtin_topics_lib", "msg")
topic = dds.DynamicData.Topic(participant, "Example msg", msg_type)
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic)
reader.bind_listener(MsgListener(), dds.StatusMask.data_available())
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
count += 1
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft")
topic = dds.DynamicData.Topic(participant, "Example cft", cft_type)
writer_qos = dds.QosProvider.default.datawriter_qos
writer = dds.DynamicData.DataWriter(dds.Publisher(participant), topic,
writer_qos)
instance = dds.DynamicData(cft_type)
handle = dds.InstanceHandle.nil()
# Output "ones" digit of count as 'x' field
count = 0
while (sample_count == 0) or (count < sample_count):
instance["count"] = count
instance["x"] = count % 10
print("Writing cft, count={}\tx={}".format(instance["count"],
instance["x"]))
writer.write(instance, handle)
time.sleep(1)
count += 1
def publisher_main(domain_id, sample_count):
participant = dds.DomainParticipant(domain_id)
publisher_qos = dds.QosProvider.default.publisher_qos
publisher = dds.Publisher(participant, publisher_qos)
coherent_type = dds.QosProvider("coherent.xml").type(
"coherent_lib", "coherent")
topic = dds.DynamicData.Topic(participant, "Example coherent",
coherent_type)
datawriter_qos = dds.QosProvider.default.datawriter_qos
writer = dds.DynamicData.DataWriter(publisher, topic, datawriter_qos)
sample = dds.DynamicData(coherent_type)
sample["id"] = 0
handle = writer.register_instance(sample)
num_samples = 7
count = 0
while (sample_count == 0) or (count < sample_count):
# Use a context manager to scope the coherent set writes
with dds.CoherentSet(publisher):
print("Begin Coherent Changes")
for i in xrange(num_samples):
time.sleep(1)
sample["field"] = chr(ord("a") + i)
sample["value"] = random.randint(0, 10)
print("Updating instance, {}->{}".format(
sample["field"], sample["value"]))
writer.write(sample, handle)
count += 1
print("End Coherent Changes")
writer.unregister_instance(handle)
def __init__(self, domain_id, use_dynamic_data, use_qos_object,
use_custom_topic, use_replier_cft, use_pub_sub_args,
use_callback_funcs, use_simple_replier):
qos = dds.DomainParticipantQos()
qos.database.shutdown_cleanup_period = dds.Duration.from_milliseconds(
100)
self._participant = dds.DomainParticipant(domain_id, qos)
if use_dynamic_data:
self._type = get_keyed_string_dynamic_type()
self.create_data_fnc = create_dynamic_rr_data
self.parse_data_fnc = parse_dynamic_rr_data
self.copy_sample_fnc = copy_dynamic_sample
create_topic_func = create_dynamic_topic
else:
self._type = type_cls = dds.KeyedStringTopicType
self.create_data_fnc = create_rr_data
self.parse_data_fnc = parse_rr_data
self.copy_sample_fnc = copy_sample
create_topic_func = create_topic
service_name = 'Test'
if use_qos_object:
request_writer_qos = request.Requester.default_writer_qos
request_reader_qos = request.Replier.default_reader_qos
reply_writer_qos = request.Replier.default_writer_qos
reply_reader_qos = request.Requester.default_reader_qos
else:
request_writer_qos = request_reader_qos = reply_writer_qos = reply_reader_qos = None
if use_custom_topic:
# Test with custom Topic object
request_topic = create_topic_func(self._participant, 'TestRequest')
# Test with custom string Topic name
reply_topic = 'TestReply'
else:
request_topic = reply_topic = None
if use_replier_cft:
replier_filter = dds.Filter("NOT (key MATCH 'filtered')")
request_reader_topic = create_topic_func(
self._participant,
'TestRequest') if request_topic is None else request_topic
if isinstance(self._type, dds.DynamicType):
request_reader_topic = dds.DynamicData.ContentFilteredTopic(
request_reader_topic, 'request_cft', replier_filter)
else:
request_reader_topic = dds.KeyedStringTopicType.ContentFilteredTopic(
request_reader_topic, 'request_cft', replier_filter)
else:
request_reader_topic = request_topic
if use_pub_sub_args:
publisher = dds.Publisher(self._participant)
subscriber = dds.Subscriber(self._participant)
else:
publisher = subscriber = None
self._cb = use_callback_funcs
self._request_queue = queue.Queue()
self._reply_queue = queue.Queue()
if use_callback_funcs:
def replier_callback(replier):
for sample in (s for s in replier.take_requests()
if s.info.valid):
self._request_queue.put(self.copy_sample_fnc(sample))
def requester_callback(requester):
for sample in (s for s in requester.take_replies()
if s.info.valid):
self._reply_queue.put(self.copy_sample_fnc(sample))
else:
replier_callback = requester_callback = None
self._requester = request.Requester(self._type, self._type,
self._participant, service_name,
request_topic, reply_topic,
request_writer_qos,
reply_reader_qos, publisher,
subscriber, requester_callback)
self._simple = use_simple_replier
if use_simple_replier:
def simple_replier_callback(request):
key, value = self.parse_data_fnc(request)
reply = self.create_data_fnc(key, value + ' reply')
return reply
self._replier = request.SimpleReplier(
self._type, self._type, self._participant,
simple_replier_callback, service_name, request_reader_topic,
reply_topic, reply_writer_qos, request_reader_qos, publisher,
subscriber)
else:
self._replier = request.Replier(self._type, self._type,
self._participant, service_name,
request_reader_topic, reply_topic,
reply_writer_qos,
request_reader_qos, publisher,
subscriber, replier_callback)
def run_example(domain_id, sample_count, sensor_id):
# A DomainParticipant allows an application to begin communicating in
# a DDS domain. Typically there is one DomainParticipant per application.
# DomainParticipant QoS is configured in USER_QOS_PROFILES.xml
participant = dds.DomainParticipant(domain_id)
# A Topic has a name and a datatype. Create a Topic named
# "ChocolateTemperature" with type Temperature
provider = dds.QosProvider(FILE)
temperature_type = provider.type("Temperature")
lot_status_kind_type = provider.type("LotStatusKind")
topic = dds.DynamicData.Topic(
participant, "ChocolateTemperature", temperature_type
)
# Exercise #2.1: Add a new Topic
lot_state_type = provider.type("ChocolateLotState")
lot_state_topic = dds.DynamicData.Topic(
participant, "ChocolateLotState", lot_state_type
)
# A Publisher allows an application to create one or more DataWriters
# Publisher QoS is configured in USER_QOS_PROFILES.xml
publisher = dds.Publisher(participant)
# This DataWriter writes data on Topic "ChocolateTemperature"
# DataWriter QoS is configured in USER_QOS_PROFILES.xml
writer = dds.DynamicData.DataWriter(publisher, topic)
# Create data sample for writing
temperature_sample = dds.DynamicData(temperature_type)
# Exercise #2.2: Add new DataWriter and data sample
lot_state_writer = dds.DynamicData.DataWriter(publisher, lot_state_topic)
lot_state_sample = dds.DynamicData(lot_state_type)
i = 0
try:
while sample_count is None or i < sample_count:
# Modify the data to be written here
temperature_sample["sensor_id"] = sensor_id
# Generate a number x where 30 <= x <= 32
temperature_sample["degrees"] = random.randint(30, 32)
# Exercise #2.3: Write data with new ChocolateLotState DataWriter
# Note: We're adding a writer but no reader, this exercise can be
# viewed using rtiddsspy
lot_state_sample["lot_id"] = i % 100
lot_state_sample["lot_status"] = lot_status_kind_type[
"PROCESSING"
].ordinal
lot_state_writer.write(lot_state_sample)
print(f"Writing ChocolateTemperature, count {i}")
writer.write(temperature_sample)
# Exercise 1.1: Change this to sleep 100 ms in between writing
# temperatures
time.sleep(4)
i += 1
except KeyboardInterrupt:
pass
def subscriber_main(domain_id, sample_count, is_cft):
participant = dds.DomainParticipant(domain_id)
cft_type = dds.QosProvider("cft.xml").type("cft_lib", "cft")
topic = dds.DynamicData.Topic(participant, "Example cft", cft_type)
if is_cft:
# Create a CFT that filters for incoming data within a range
topic = dds.DynamicData.ContentFilteredTopic(
topic, "ContentFilteredTopic", dds.Filter("x >= %0 AND x <= %1", ["1", "4"])
)
print(
textwrap.dedent(
"""
==========================
Using CFT
Filter: 1 <= x <= 4
=========================="""
)
)
else:
# Filtering disabled by default
print(
textwrap.dedent(
"""
==========================
Using Normal Topic
=========================="""
)
)
reader_qos = dds.QosProvider.default.datareader_qos
reader = dds.DynamicData.DataReader(dds.Subscriber(participant), topic, reader_qos)
reader.bind_listener(CftListener(), dds.StatusMask.DATA_AVAILABLE)
count = 0
while (sample_count == 0) or (count < sample_count):
time.sleep(1)
if is_cft:
if count == 10:
# After 10 seconds, udpdate the filter range
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 5 <= x <= 9
=========================="""
)
)
topic.filter_parameters = ["5", "9"]
if count == 20:
# After 20 seconds, update the filter again
print(
textwrap.dedent(
"""
==========================
Changing Filter Parameters
Filter: 3 <= x <= 9
=========================="""
)
)
topic.filter_parameters = ["3", "9"]
count += 1
def test_participant_creation_failure():
qos = dds.DomainParticipantQos()
qos.resource_limits.type_object_max_serialized_length = -2
with pytest.raises(dds.Error):
dds.DomainParticipant(0, qos)
def test_participant_creation_w_listener():
l = dds.NoOpDomainParticipantListener()
p = dds.DomainParticipant(DOMAIN_ID, dds.DomainParticipantQos(), l)
assert p.listener == l
p.close()
def test_participant_default_creation():
p = dds.DomainParticipant(DOMAIN_ID)
assert p.domain_id == DOMAIN_ID
def test_participant_creation_w_default_qos():
p = dds.DomainParticipant(DOMAIN_ID, dds.DomainParticipantQos())
assert p.domain_id == DOMAIN_ID
event_count = p.qos.event.max_count
assert event_count == dds.Event().max_count
