class Topicmanger:
def __init__(self, args, dp, qos, waitset):
self.topic_name = args.topic
self.seq = -1
try:
int_topic = Topic(dp, self.topic_name + "int", Integer, qos=qos)
str_topic = Topic(dp, self.topic_name, String, qos=qos)
self.int_writer = DataWriter(dp, int_topic, qos=qos)
self.int_reader = DataReader(dp, int_topic, qos=qos)
self.str_writer = DataWriter(dp, str_topic, qos=qos)
self.str_reader = DataReader(dp, str_topic, qos=qos)
except DDSException:
raise SystemExit("Error: The arguments inputted are considered invalid for cyclonedds.")
self.read_cond = ReadCondition(self.int_reader, ViewState.Any | InstanceState.Alive | SampleState.NotRead)
waitset.attach(self.read_cond)
def write(self, input):
self.seq += 1
if type(input) is int:
msg = Integer(self.seq, input)
self.int_writer.write(msg)
else:
msg = String(self.seq, input)
self.str_writer.write(msg)
def read(self):
for sample in self.int_reader.take(N=100):
print("Subscribed:", sample)
for sample in self.str_reader.take(N=100):
print("Subscribed:", sample)
def test_writeto_writer():
dp = DomainParticipant(0)
tp = Topic(dp, "Message", Message)
pub = Publisher(dp)
dw = DataWriter(pub, tp)
msg = Message(message="TestMessage")
dw.write(msg)
assert dw.wait_for_acks(duration(seconds=1))
def test_writer_instance_handle():
dp = DomainParticipant(0)
tp = Topic(dp, "MessageKeyed", MessageKeyed)
pub = Publisher(dp)
dw = DataWriter(pub, tp)
msg = MessageKeyed(user_id=1, message="Hello")
handle = dw.register_instance(msg)
assert handle > 0
dw.write(msg)
dw.unregister_instance_handle(handle)
def test_data_representation_writer_v2_v0_unmatch():
qosv0 = Qos(Policy.DataRepresentation(use_cdrv0_representation=True))
qosv2 = Qos(Policy.DataRepresentation(use_xcdrv2_representation=True))
dp = DomainParticipant(0)
tp = Topic(dp, "Message", Message)
dr = DataReader(dp, tp, qos=qosv2)
dw = DataWriter(dp, tp, qos=qosv0)
msg = Message("Hello")
dw.write(msg)
assert dr.read_next() == None
def test_data_representation_writer_v2_match():
qos = Qos(Policy.DataRepresentation(use_xcdrv2_representation=True))
dp = DomainParticipant(0)
tp = Topic(dp, "XMessage", XMessage)
dr = DataReader(dp, tp, qos=qos)
dw = DataWriter(dp, tp, qos=qos)
assert dw._use_version_2 == True
msg = XMessage("Hello")
dw.write(msg)
assert dr.read_next() == msg
def test_keyed_type_alignment():
dp = DomainParticipant()
tp = Topic(dp, "Test", KeyedArrayType)
dw = DataWriter(dp, tp)
dr = DataReader(dp, tp)
samp1 = KeyedArrayType(['u' * 17, 's' * 13, 'b' * 23],
['u' * 3, 's' * 5, 'b' * 7], [-1] * 3, [-1] * 3,
[-1] * 3, [-1] * 3)
dw.write(samp1)
samp2 = dr.read()[0]
assert KeyedArrayType.cdr.key(samp1) == KeyedArrayType.cdr.key(samp2)
def test_dynamic_publish_complex():
dp = DomainParticipant()
tp = Topic(dp, 'DynTest', XStruct)
rd = DataReader(dp, tp)
type_id = XStruct.__idl__.get_type_id()
datatype, tmap = get_types_for_typeid(dp, type_id, duration(seconds=1))
assert datatype
assert datatype.__idl__.get_type_id() == XStruct.__idl__.get_type_id()
tp = Topic(dp, 'DynTest', datatype)
wr = DataWriter(dp, tp)
wr.write(datatype(A=tmap['XUnion'](A=tmap['XEnum'].V1), k=1))
assert rd.read()[0].k == 1
def test_reader_readnext_takenext():
dp = DomainParticipant(0)
tp = Topic(dp, "Message__DONOTPUBLISH", Message)
sub = Subscriber(dp)
pub = Publisher(dp)
dr = DataReader(sub, tp)
dw = DataWriter(pub, tp)
msg = Message("Hello")
dw.write(msg)
assert dr.read_next() == msg
assert dr.read_next() is None
dw.write(msg)
assert dr.take_next() == msg
assert dr.take_next() is None
def test_dynamic_subscribe_complex():
dp = DomainParticipant()
tp = Topic(dp, 'DynTest', XStruct)
wr = DataWriter(dp, tp)
type_id = XStruct.__idl__.get_type_id()
datatype, tmap = get_types_for_typeid(dp, type_id, duration(seconds=1))
assert datatype
assert datatype.__idl__.get_type_id() == XStruct.__idl__.get_type_id()
tp = Topic(dp, 'DynTest', datatype)
dr = DataReader(dp, tp)
wr.write(XStruct(A=XUnion(A=XEnum.V1), k=1))
assert dr.read()[0].k == 1
def test_reader_readiter():
dp = DomainParticipant(0)
tp = Topic(dp, "Message", Message)
sub = Subscriber(dp)
pub = Publisher(dp)
dr = DataReader(sub, tp)
dw = DataWriter(pub, tp)
msg = Message("Hello")
dw.write(msg)
read = False
for msgr in dr.read_iter(timeout=duration(milliseconds=10)):
assert not read
assert msg == msgr
read = True
def test_data_representation_writer_dualreader_match():
qosv0 = Qos(Policy.DataRepresentation(use_cdrv0_representation=True))
qosv2 = Qos(Policy.DataRepresentation(use_xcdrv2_representation=True))
qosv0v2 = Qos(
Policy.DataRepresentation(use_cdrv0_representation=True,
use_xcdrv2_representation=True))
dp = DomainParticipant(0)
tp = Topic(dp, "Message", Message)
dr = DataReader(dp, tp, qos=qosv0v2)
dwv0 = DataWriter(dp, tp, qos=qosv0)
dwv2 = DataWriter(dp, tp, qos=qosv2)
msg1 = Message("Hello")
dwv0.write(msg1)
assert dr.read_next() == msg1
msg2 = Message("Hi!")
dwv2.write(msg2)
assert dr.read_next() == msg2
def test_readcondition_read(common_setup):
tp = Topic(common_setup.dp, "hi_sayer", MessageKeyed)
dr = DataReader(common_setup.dp, tp)
dw = DataWriter(common_setup.dp, tp)
rc = ReadCondition(dr, SampleState.Any | ViewState.Any | InstanceState.NotAliveDisposed)
assert not rc.triggered
messages = [MessageKeyed(user_id=i, message=f"Hi {i}!") for i in range(5)]
for m in messages:
dw.write(m)
received = dr.read(N=5)
assert messages == received
dw.dispose(messages[1])
assert rc.triggered
received = dr.read(condition=rc)
assert len(received) == 1 and received[0] == messages[1]
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
"""
from cyclonedds.domain import DomainParticipant
from cyclonedds.pub import Publisher, DataWriter
from cyclonedds.sub import Subscriber, DataReader
from cyclonedds.topic import Topic
from pycdr import cdr
@cdr
class HelloWorld:
data: str
dp = DomainParticipant()
tp = Topic(dp, "Hello", HelloWorld)
pub = Publisher(dp)
dw = DataWriter(pub, tp)
sub = Subscriber(dp)
dr = DataReader(sub, tp)
dw.write(HelloWorld(data='Hello, World!'))
sample = dr.read()[0]
print(sample.data)
# Define a HelloWorld datatype with one member, data, with as type 'string'
# In IDL this would be defined as "struct HelloWorld { string data; };"
@dataclass
class HelloWorld(IdlStruct, typename="HelloWorld.Msg"):
data: str
# Create a DomainParticipant, your entrypoint to DDS
# The default domain id is 0.
dp = DomainParticipant()
# Create a Topic with topic name "Hello" and as datatype "HelloWorld" structs.
tp = Topic(dp, "Hello", HelloWorld)
# Create a DataWriter that can send structs on the "Hello" topic
dw = DataWriter(dp, tp)
# Create a DataReader that can receive structs on the "Hello" topic
dr = DataReader(dp, tp)
# Create a HelloWorld sample and write it to the network
sample = HelloWorld(data='Hello, World!')
dw.write(sample)
# Read samples from the network and print the data in the first one
# This should print "Hello, World!"
sample = dr.read()[0]
print(sample.data)
import time
import random
from cyclonedds.core import Qos, Policy
from cyclonedds.domain import DomainParticipant
from cyclonedds.pub import Publisher, DataWriter
from cyclonedds.topic import Topic
from cyclonedds.util import duration
from vehicles import Vehicle
qos = Qos(Policy.Reliability.BestEffort,
Policy.Deadline(duration(microseconds=10)),
Policy.Durability.Transient, Policy.History.KeepLast(10))
domain_participant = DomainParticipant(0)
topic = Topic(domain_participant, 'Vehicle', Vehicle, qos=qos)
publisher = Publisher(domain_participant)
writer = DataWriter(publisher, topic)
cart = Vehicle(name="Dallara IL-15", x=200, y=200)
while True:
cart.x += random.choice([-1, 0, 1])
cart.y += random.choice([-1, 0, 1])
writer.write(cart)
print(">> Wrote vehicle")
time.sleep(random.random() * 0.9 + 0.1)
def check_py_c_key_equivalence(log: Stream, ctx: FullContext, typename: str,
num_samples: int) -> bool:
datatype = ctx.get_datatype(typename)
if datatype.__idl__.keyless:
return True
samples = [
generate_random_instance(datatype, seed=i) for i in range(num_samples)
]
# We need to make sure the samples all have unique keys to make sure that we agree
# on sample ordering with C
keysamples = {}
for s in samples:
keysamples[datatype.__idl__.key(s)] = s
samples = list(keysamples.values())
dp = DomainParticipant()
tp = Topic(dp, typename, datatype)
dw = DataWriter(
dp,
tp,
qos=Qos(Policy.DataRepresentation(use_xcdrv2_representation=True),
Policy.History.KeepLast(len(samples)),
Policy.Reliability.Reliable(duration(seconds=2)),
Policy.DestinationOrder.BySourceTimestamp))
dw.set_status_mask(DDSStatus.PublicationMatched)
dw.take_status()
ctx.c_app.run(typename, len(samples))
now = time.time()
while (dw.take_status() & DDSStatus.PublicationMatched) == 0:
if time.time() - now > 4:
# timeout if C app did not start up within 4 seconds
ctx.c_app.result()
log << f"C-app did not communicate with Python:" << log.endl << log.indent
log << ctx.c_app.last_error << log.endl
log << log.dedent
return False
time.sleep(0.001)
time.sleep(0.5)
for sample in samples:
dw.write(sample)
time.sleep(0.002)
hashes = ctx.c_app.result()
success = True
if not hashes:
log << f"C-app did not return output, stderr:" << log.endl << log.indent
log << ctx.c_app.last_error << log.endl
log << f"stdout:" << log.endl
log << ctx.c_app.last_out << log.endl
log << log.dedent << "Example sample sent:" << log.endl << log.indent
log << samples[0] << log.endl << samples[0].serialize()
log << log.dedent
return False
if len(hashes) != len(samples):
log << f"C-app did not return as many samples as were sent, stderr:" << log.endl << log.indent
log << ctx.c_app.last_error << log.endl
log << f"stdout:" << log.endl
log << ctx.c_app.last_out << log.endl << log.dedent
log << log.dedent << "Example sample sent:" << log.endl << log.indent
log << samples[0] << log.endl << samples[0].serialize()
success = False
for i in range(min(len(hashes), len(samples))):
c_key = hashes[i]
py_key = datatype.__idl__.key(samples[i], use_version_2=True)
if not py_key == c_key:
log << "PY-C Keys do not match!" << log.endl << log.indent
log << "Instance: " << samples[i] << log.endl
log << "Serialized Instance:" << log.endl << samples[i].serialize()
log << "Python key:" << log.endl << py_key
log << "C key:" << log.endl << c_key
log << log.dedent
return False
return success
def test_enum_as_discriminator():
dp = DomainParticipant(0)
tp = Topic(dp, 'EnumDiscrTopic', MyUnion)
dw = DataWriter(dp, tp)
dw.write(MyUnion(a=9))
dw.write(MyUnion(b="Hello"))
from vehicles import Vehicle
# This is the publisher in the Vehicle Demo. It publishes a randomly moving
# vehicle updated every 0.1-1.0 seconds randomly. The 'Vehicle' class was
# generated from the vehicle.idl file with `idlc -l py vehicle.idl`
qos = Qos(
Policy.Reliability.BestEffort,
Policy.Deadline(duration(microseconds=10)),
Policy.Durability.Transient,
Policy.History.KeepLast(10)
)
domain_participant = DomainParticipant(0)
topic = Topic(domain_participant, 'Vehicle', Vehicle, qos=qos)
publisher = Publisher(domain_participant)
writer = DataWriter(publisher, topic)
vehicle = Vehicle(name="Dallara IL-15", x=200, y=200)
while True:
vehicle.x += random.choice([-1, 0, 1])
vehicle.y += random.choice([-1, 0, 1])
writer.write(vehicle)
print(">> Wrote vehicle")
time.sleep(random.random() * 0.9 + 0.1)
def test_pub_matched_cross_participant(hitpoint_factory):
hpf = hitpoint_factory
class MyListener(Listener):
def __init__(self):
super().__init__()
self.hitpoint_data_available = hpf()
self.hitpoint_pub_matched = hpf()
self.hitpoint_sub_matched = hpf()
def on_data_available(self, reader):
self.hitpoint_data_available.hit()
def on_publication_matched(self, writer,status):
self.hitpoint_pub_matched.hit()
def on_subscription_matched(self, reader, status):
self.hitpoint_sub_matched.hit()
domain1_participant_listener = MyListener()
domain2_participant_listener = MyListener()
dp1 = DomainParticipant(listener=domain1_participant_listener)
dp2 = DomainParticipant(listener=domain2_participant_listener)
tp1 = Topic(dp1, "Message", Message)
tp2 = Topic(dp2, "Message", Message)
publisher_listener = MyListener()
pub = Publisher(dp1, listener=publisher_listener)
subscriber_listener = MyListener()
sub = Subscriber(dp2, listener=subscriber_listener)
datawriter_listener = MyListener()
datawriter = DataWriter(pub, tp1, listener=datawriter_listener)
datareader_listener = MyListener()
datareader = DataReader(sub, tp2, listener=datareader_listener)
datawriter.write(Message("hi!"))
# Assertions, _only_ datawriter should publication match,
# _only_ datareader should subscriber match and receive data
assert datawriter_listener.hitpoint_pub_matched.was_hit()
assert datareader_listener.hitpoint_sub_matched.was_hit()
assert datareader_listener.hitpoint_data_available.was_hit()
assert domain1_participant_listener.hitpoint_pub_matched.was_not_hit()
assert domain1_participant_listener.hitpoint_sub_matched.was_not_hit()
assert domain1_participant_listener.hitpoint_data_available.was_not_hit()
assert domain2_participant_listener.hitpoint_pub_matched.was_not_hit()
assert domain2_participant_listener.hitpoint_sub_matched.was_not_hit()
assert domain2_participant_listener.hitpoint_data_available.was_not_hit()
assert publisher_listener.hitpoint_pub_matched.was_not_hit()
assert publisher_listener.hitpoint_sub_matched.was_not_hit()
assert publisher_listener.hitpoint_data_available.was_not_hit()
assert subscriber_listener.hitpoint_pub_matched.was_not_hit()
assert subscriber_listener.hitpoint_sub_matched.was_not_hit()
assert subscriber_listener.hitpoint_data_available.was_not_hit()
assert datawriter_listener.hitpoint_sub_matched.was_not_hit()
assert datawriter_listener.hitpoint_data_available.was_not_hit()
assert datareader_listener.hitpoint_pub_matched.was_not_hit()
