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_suspension(): dp = DomainParticipant(0) pub = Publisher(dp) with pytest.raises(DDSException) as exc: pub.suspend() assert exc.value.code == DDSException.DDS_RETCODE_UNSUPPORTED with pytest.raises(DDSException) as exc: pub.resume() assert exc.value.code == DDSException.DDS_RETCODE_UNSUPPORTED
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 __init__(self, args, dp, eqos, waitset): self.dp = dp if args.topic: self.topic_name = args.topic self.dynamic = False else: self.topic_name = args.dynamic self.dynamic = True self.seq = -1 # Sequence number counter self.eqos = eqos # Entity qos self.entities = {} # Store writers and readers self.file = args.filename # Write to file or not self.track_samples = {} # Track read samples if needs to write to file try: self.listener = QosListener() self.pub = Publisher(dp, qos=self.eqos.publisher_qos) self.sub = Subscriber(dp, qos=self.eqos.subscriber_qos, listener=self.listener) if self.dynamic: ds, tmap = discover_datatype(self.dp, self.topic_name) self.entity = self.create_entities(ds, self.topic_name) self.type_map = tmap print(f"Discovered datatype dynamically:{ds}") else: for type in datatypes: self.entities[type] = self.create_entities( type, self.topic_name + type.postfix()) except DDSException: raise Exception( "The arguments inputted are considered invalid for cyclonedds." ) self.read_cond = ReadCondition( (self.entities[Integer] if not self.dynamic else self.entity).reader, ViewState.Any | InstanceState.Alive | SampleState.NotRead) waitset.attach(self.read_cond)
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 pub(self, qos=None, listener=None): self._pub = Publisher(self.dp, qos=qos, listener=listener) return self._pub
def test_initialize_publisher(): dp = DomainParticipant(0) pub = Publisher(dp) assert isgoodentity(pub)
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()
* 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)