public void TestAttachCondition() { // Initialize WaitSet waitSet = new WaitSet(); GuardCondition guardCondition = new GuardCondition(); // Test with null parameter ReturnCode result = waitSet.AttachCondition(null); Assert.AreEqual(ReturnCode.BadParameter, result); // Test with correct parameter result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); // Attach again should return OK but not actually add another condition to the WaitSet result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); List <Condition> conditions = new List <Condition>(); result = waitSet.GetConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(1, conditions.Count); Assert.AreEqual(guardCondition, conditions[0]); }
public void TestGetConditions() { // Initialize WaitSet waitSet = new WaitSet(); GuardCondition guardCondition = new GuardCondition(); GuardCondition otherGuardCondition = new GuardCondition(); ReturnCode result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); result = waitSet.AttachCondition(otherGuardCondition); Assert.AreEqual(ReturnCode.Ok, result); // Test with null parameter result = waitSet.GetConditions(null); Assert.AreEqual(ReturnCode.BadParameter, result); // Test with correct parameter List <Condition> conditions = new List <Condition>() { null }; result = waitSet.GetConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(2, conditions.Count); Assert.IsNotNull(conditions[0]); Assert.IsNotNull(conditions[1]); Assert.IsTrue(conditions[0] != conditions[1]); Assert.IsTrue(guardCondition == conditions[0] || guardCondition == conditions[1]); Assert.IsTrue(otherGuardCondition == conditions[0] || otherGuardCondition == conditions[1]); }
/// <summary> /// Creates a DomainParticipant, Topic, Subscriber and DataReader<HelloWorld>. /// </summary> public HelloWorldSubscriber(int domainId) { // Enable network capture. // This must be called before any other network capture function, and // before creating any participant for which we want to capture traffic. NetworkCapture.Enable(); // Start communicating in a domain, usually one participant per application // Load QoS profile from USER_QOS_PROFILES.xml file participant = DomainParticipantFactory.Instance.CreateParticipant(domainId); // A Topic has a name and a datatype. Topic <HelloWorld> topic = participant.CreateTopic <HelloWorld>( "Network capture shared memory example"); // Create a subscriber Subscriber subscriber = participant.CreateSubscriber(); // Create a DataReader, loading QoS profile from USER_QOS_PROFILES.xml. reader = subscriber.CreateDataReader(topic); // Obtain the DataReader's Status Condition StatusCondition statusCondition = reader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) statusCondition.Triggered += ProcessData; // Create a WaitSet and attach the StatusCondition waitset.AttachCondition(statusCondition); }
public void TestDetachCondition() { // Initialize WaitSet waitSet = new WaitSet(); GuardCondition guardCondition = new GuardCondition(); ReturnCode result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); // Test with null parameter result = waitSet.DetachCondition(null); Assert.AreEqual(ReturnCode.BadParameter, result); // Test with correct parameter result = waitSet.DetachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); // Test again the same condition result = waitSet.DetachCondition(guardCondition); Assert.AreEqual(ReturnCode.PreconditionNotMet, result); // Detach a not attached condition GuardCondition notAttachedCondition = new GuardCondition(); result = waitSet.DetachCondition(notAttachedCondition); Assert.AreEqual(ReturnCode.PreconditionNotMet, result); }
static void Main(string[] args) { DDSEntityManager mgr = new DDSEntityManager("Listener"); ReturnCode status = ReturnCode.Error; ListenerDataListener myListener; String partitionName = "Listener Example"; int count = 0; // create Domain Participant mgr.createParticipant(partitionName); // create Type MsgTypeSupport msgTS = new MsgTypeSupport(); mgr.registerType(msgTS); // create Topic mgr.createTopic("ListenerData_Msg"); // create Subscriber mgr.createSubscriber(); // create DataReader mgr.createReader(false); IDataReader dreader = mgr.getReader(); myListener = new ListenerDataListener(); myListener.MsgDR = dreader as MsgDataReader; Console.WriteLine("=== [ListenerDataSubscriber] SetListener"); StatusKind kind = StatusKind.DataAvailable | StatusKind.RequestedDeadlineMissed; status = myListener.MsgDR.SetListener(myListener, kind); ErrorHandler.checkStatus(status, "DataReader.SetListener"); Console.WriteLine("=== [ListenerDataSubscriber] Ready..."); myListener.terminated = false; WaitSet ws = new WaitSet(); ws.AttachCondition(myListener.guardCond); ICondition[] cond = null; while (!myListener.terminated && count < 1500) { Console.WriteLine("=== [SubscriberUsingListener] waiting waitset ..."); ws.Wait(ref cond, Duration.Infinite); myListener.guardCond.SetTriggerValue(false); ++count; } Console.WriteLine("===[ListenerDataSubscriber] Market Closed."); mgr.getSubscriber().DeleteDataReader(myListener.MsgDR); mgr.deleteSubscriber(); mgr.deleteTopic(); mgr.deleteParticipant(); }
public ShapeWaitSet(ShapeTypeDataReader dataReader, Action <ShapeTypeDataReader> dataAvailableFunc) { _dataAvailableFunc = dataAvailableFunc; _dataReader = dataReader; _waitSet = new WaitSet(); _thread = new Thread(DoThreadActivity) { IsBackground = true }; _cancelCondition = new GuardCondition(); _statusCondition = dataReader.StatusCondition; _waitSet.AttachCondition(_statusCondition); _waitSet.AttachCondition(_cancelCondition); _statusCondition.EnabledStatuses = StatusKind.DataAvailableStatus; _thread.Start(); }
/// <summary> /// Main function, receiving structured command-line arguments /// via the System.Console.DragonFruit package. /// For example: dotnet run -- --domain-id 54 --sample-count 5 /// </summary> /// <param name="domainId">The domain ID to create the DomainParticipant</param> /// <param name="sampleCount">The number of data samples to receive before exiting</param> public static void Main(int domainId = 0, int sampleCount = int.MaxValue) { // 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 // // A participant needs to be Disposed to release middleware resources. // The 'using' keyword indicates that it will be Disposed when this // scope ends. using DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create dynamically-typed // Topic named "HelloWorld Topic" with the type definition of // "HelloWorld" in hello_world.xml. To get the type we use a QosProvider var provider = new QosProvider("../hello_world.xml"); Topic <DynamicData> topic = participant.CreateTopic( "Example HelloWorld", provider.GetType("HelloWorld")); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // This DataReader reads data of type Temperature on Topic // "ChocolateTemperature". DataReader QoS is configured in // USER_QOS_PROFILES.xml DataReader <DynamicData> reader = subscriber.CreateDataReader(topic); // Obtain the DataReader's Status Condition StatusCondition statusCondition = reader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) int samplesRead = 0; statusCondition.Triggered += _ => samplesRead += ProcessData(reader); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); while (samplesRead < sampleCount) { // Dispatch will call the handlers associated to the WaitSet // conditions when they activate Console.WriteLine("HelloWorld subscriber sleeping for 4 sec..."); waitset.Dispatch(Duration.FromSeconds(4)); } }
private void RunExample(int domainId, int sampleCount) { // 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 DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create a Topic named // "ChocolateTemperature" with type Temperature // In this example we use a DynamicType defined in XML, which creates // a DynamicData topic. var provider = new QosProvider("../chocolate_factory.xml"); Topic <DynamicData> topic = participant.CreateTopic( "ChocolateTemperature", provider.GetType("Temperature")); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // This DataReader reads data of type Temperature on Topic // "ChocolateTemperature". DataReader QoS is configured in // USER_QOS_PROFILES.xml DataReader <DynamicData> reader = subscriber.CreateDataReader(topic); // Obtain the DataReader's Status Condition StatusCondition statusCondition = reader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) int samplesRead = 0; statusCondition.Triggered += _ => samplesRead += ProcessData(reader); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); while (samplesRead < sampleCount && !shutdownRequested) { // Dispatch will call the handlers associated to the WaitSet // conditions when they activate Console.WriteLine("ChocolateTemperature subscriber sleeping for 4 sec..."); waitset.Dispatch(Duration.FromSeconds(4)); } }
public RTIReader( DataReader <T> reader, ITypeHelper <T> dataType, Parameters arguments) { this.reader = reader; dataTypeHelper = dataType; if (arguments.UseReadThread) { WaitSetProperty property = new WaitSetProperty( (int)arguments.WaitsetEventCount, Duration.FromMilliseconds(arguments.WaitsetDelayUsec / 1000)); waitset = new WaitSet(property); StatusCondition readerStatus = reader.StatusCondition; readerStatus.EnabledStatuses = StatusMask.DataAvailable; waitset.AttachCondition(readerStatus); } }
/// <summary> /// Process the data received by the readers /// </summary> public Task Run(int _, CancellationToken cancellationToken) { var condition = subscriber.StatusCondition; condition.EnabledStatuses = StatusMask.DataOnReaders; condition.Triggered += ProcessData; var waitSet = new WaitSet(); waitSet.AttachCondition(condition); return(Task.Run(() => { while (!cancellationToken.IsCancellationRequested) { waitSet.Dispatch(Duration.FromSeconds(1)); } }, cancellationToken)); }
private void RunExample(int domainId, string sensorId) { // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // Uses TemperingApplication QoS profile to set participant name. var qosProvider = new QosProvider("./qos_profiles.xml"); var participantQos = qosProvider.GetDomainParticipantQos( "ChocolateFactoryLibrary::TemperingApplication"); DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId, participantQos); // A Topic has a name and a datatype. Topic <Temperature> temperatureTopic = participant.CreateTopic <Temperature>( CHOCOLATE_TEMPERATURE_TOPIC.Value); Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>( CHOCOLATE_LOT_STATE_TOPIC.Value); // A Publisher allows an application to create one or more DataWriters // Create Publisher with default QoS. Publisher publisher = participant.CreatePublisher(); // Create DataWriter of Topic "ChocolateTemperature" // using ChocolateTemperatureProfile QoS profile for Streaming Data DataWriter <Temperature> temperatureWriter = publisher.CreateDataWriter( temperatureTopic, qos: qosProvider.GetDataWriterQos("ChocolateFactoryLibrary::ChocolateTemperatureProfile")); // Create DataWriter of Topic "ChocolateLotState" // using ChocolateLotStateProfile QoS profile for State Data DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter( lotStateTopic, qos: qosProvider.GetDataWriterQos("ChocolateFactoryLibrary::ChocolateLotStateProfile")); // A Subscriber allows an application to create one or more DataReaders Subscriber subscriber = participant.CreateSubscriber(); // This DataReader reads data of type Temperature on Topic // "ChocolateTemperature" using ChocolateLotStateProfile QoS // profile for State Data. // // We will handle the "requested incompatible qos" event. By doing // it as a preEnableAction, we avoid a race condition in which // the event could trigger right after the reader creation but // right before adding the event handler. DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader( lotStateTopic, qos: qosProvider.GetDataReaderQos("ChocolateFactoryLibrary::ChocolateLotStateProfile"), preEnableAction: reader => reader.RequestedIncompatibleQos += OnRequestedIncompatibleQos); // Obtain the DataReader's Status Condition StatusCondition statusCondition = lotStateReader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) statusCondition.Triggered += _ => ProcessLot(lotStateReader, lotStateWriter); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); // Create a thread to periodically publish the temperature Console.WriteLine($"ChocolateTemperature Sensor with ID: {sensorId} starting"); var temperatureTask = Task.Run( () => PublishTemperature(temperatureWriter, sensorId)); while (!shutdownRequested) { // Wait for ChocolateLotState Console.WriteLine("Waiting for lot"); waitset.Dispatch(Duration.FromSeconds(4)); } temperatureTask.Wait(); }
static void Main(string[] args) { if (args.Length != 1) { Console.WriteLine("*** [ContentFilteredTopicDataSubscriber] Subscription string not specified"); Console.WriteLine("*** usage : ContentFilteredTopicDataSubscriber <subscription_string>"); Environment.Exit(-1); } ITopic topic; DDSEntityManager mgr = new DDSEntityManager("ContentFilteredTopic"); String partitionName = "ContentFilteredTopic example"; // Create DomainParticipant mgr.createParticipant(partitionName); // Create Type StockTypeSupport msgTS = new StockTypeSupport(); mgr.registerType(msgTS); // Create Topic topic = mgr.createTopic("StockTrackerExclusive"); // ContentFilteredTopic mgr.createContentFilter("MyStockTopic", topic, args[0]); Console.WriteLine("=== [ContentFilteredTopicDataSubscriber] Subscription filter : ticker = '{0}'", args[0]); // create Subscriber mgr.createSubscriber(); // create DataReader mgr.createReader(true); // Read Events IDataReader dreader = mgr.getReader(); StockDataReader WaitSetReader = dreader as StockDataReader; // Create WaitSet IWaitSet w = new WaitSet(); // Status Condition IStatusCondition status; status = dreader.StatusCondition; status.SetEnabledStatuses(StatusKind.DataAvailable); ReturnCode result = ReturnCode.Error; result = w.AttachCondition(status); ErrorHandler.checkHandle(status, "DataReader.StatusCondition"); ErrorHandler.checkStatus(result, "WaitSet.AttachCondition"); DDS.ICondition[] conditionList; DDS.SampleInfo[] infoSeq; Stock[] stockSeq; Console.WriteLine("=== [ContentFilteredTopicDataSubscriber] Ready ..."); bool terminate = false; int count = 0; while (!terminate && count < 1500) { /** * Wait until data will be available */ Duration wait_timeout = new Duration(Duration.InfiniteSec, Duration.InfiniteNanoSec); conditionList = null; result = w.Wait(ref conditionList, wait_timeout); ErrorHandler.checkStatus(result, "WaitSet.Wait"); stockSeq = null; infoSeq = null; /** * Read Data */ result = WaitSetReader.Take(ref stockSeq, ref infoSeq, Length.Unlimited, SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any); ErrorHandler.checkStatus(result, "StockDataReader.Take"); /** * Display Data */ for (int i = 0; i < stockSeq.Length; i++) { if (infoSeq[i].ValidData) { if (stockSeq[i].price == -1) { // We read the last expected sample => exit terminate = true; break; } Console.WriteLine("=== [ContentFilteredTopicDataSubscriber] receives stockQuote : ( {0} , {1} )", stockSeq[i].ticker, stockSeq[i].price); } } result = WaitSetReader.ReturnLoan(ref stockSeq, ref infoSeq); ErrorHandler.checkStatus(result, "StockDataReader.ReturnLoan"); Thread.Sleep(200); ++count; } Console.WriteLine("=== [ContentFilteredTopicDataSubscriber] Market Closed"); // clean up mgr.getSubscriber().DeleteDataReader(WaitSetReader); mgr.deleteSubscriber(); mgr.deleteContentFilteredTopic(); mgr.deleteTopic(); mgr.deleteParticipant(); }
private void RunExample(int domainId, string stationKind) { if (!Enum.TryParse <StationKind>(stationKind, out var currentStation)) { throw new ArgumentException("Invalid station"); } // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // Uses TemperingApplication QoS profile to set participant name. var qosProvider = new QosProvider("./qos_profiles.xml"); // By specifying a default library, we can later refer to the // profiles without the library name qosProvider.DefaultLibrary = "ChocolateFactoryLibrary"; DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant( domainId, qosProvider.GetDomainParticipantQos("IngredientApplication")); Topic <Temperature> temperatureTopic = participant.CreateTopic <Temperature>("ChocolateTemperature"); Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>("ChocolateLotState"); ContentFilteredTopic <ChocolateLotState> filteredLotStateTopic = participant.CreateContentFilteredTopic( name: "FilteredLot", relatedTopic: lotStateTopic, filter: new Filter( expression: "next_station = %0", parameters: new string[] { $"'{stationKind}'" })); Publisher publisher = participant.CreatePublisher(); // Create DataWriter of Topic "ChocolateLotState" // using ChocolateLotStateProfile QoS profile for State Data DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter( lotStateTopic, qosProvider.GetDataWriterQos("ChocolateLotStateProfile")); Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState", filtered by // next_station, and using ChocolateLotStateProfile QoS profile for // State Data. DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader( filteredLotStateTopic, qosProvider.GetDataReaderQos("ChocolateLotStateProfile")); // Monitor the DataAvailable status StatusCondition statusCondition = lotStateReader.StatusCondition; statusCondition.EnabledStatuses = StatusMask.DataAvailable; statusCondition.Triggered += _ => ProcessLot(currentStation, lotStateReader, lotStateWriter); var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); while (!shutdownRequested) { // Wait for ChocolateLotState Console.WriteLine("Waiting for lot"); waitset.Dispatch(Duration.FromSeconds(10)); } }
static void Main(string[] args) { int domain = DDS.DomainId.Default; /* Create a DomainParticipant */ DomainParticipantFactory dpf = DomainParticipantFactory.Instance; IDomainParticipant participant = dpf.CreateParticipant( domain, null, StatusKind.Any); ErrorHandler.checkHandle( participant, "DDS.DomainParticipantFactory.CreateParticipant"); /* Register the required datatype for ChatMessage. */ ChatMessageTypeSupport chatMessageTS = new ChatMessageTypeSupport(); string chatMessageTypeName = chatMessageTS.TypeName; ReturnCode status = chatMessageTS.RegisterType( participant, chatMessageTypeName); ErrorHandler.checkStatus( status, "Chat.ChatMessageTypeSupport.RegisterType"); /* Register the required datatype for NameService. */ NameServiceTypeSupport nameServiceTS = new NameServiceTypeSupport(); ErrorHandler.checkHandle( nameServiceTS, "new NameServiceTypeSupport"); string nameServiceTypeName = nameServiceTS.TypeName; status = nameServiceTS.RegisterType( participant, nameServiceTypeName); ErrorHandler.checkStatus( status, "Chat.NameServiceTypeSupport.RegisterType"); /* Set the ReliabilityQosPolicy to RELIABLE. */ TopicQos reliableTopicQos = new TopicQos(); status = participant.GetDefaultTopicQos(ref reliableTopicQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.get_DefaultTopicQos"); reliableTopicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; /* Make the tailored QoS the new default. */ status = participant.SetDefaultTopicQos(reliableTopicQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.SetDefaultTopicQos"); /* Use the changed policy when defining the ChatMessage topic */ ITopic chatMessageTopic = participant.CreateTopic( "Chat_ChatMessage", chatMessageTypeName, reliableTopicQos); ErrorHandler.checkHandle( chatMessageTopic, "DDS.DomainParticipant.CreateTopic (ChatMessage)"); /* Set the DurabilityQosPolicy to TRANSIENT. */ TopicQos settingTopicQos = new TopicQos(); status = participant.GetDefaultTopicQos(ref settingTopicQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.GetDefaultTopicQos"); settingTopicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos; /* Create the NameService Topic. */ ITopic nameServiceTopic = participant.CreateTopic( "Chat_NameService", nameServiceTypeName, settingTopicQos); ErrorHandler.checkHandle( nameServiceTopic, "DDS.DomainParticipant.CreateTopic"); /* Adapt the default SubscriberQos to read from the * "ChatRoom" Partition. */ SubscriberQos subQos = new SubscriberQos(); status = participant.GetDefaultSubscriberQos(ref subQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.GetDefaultSubscriberQos"); subQos.Partition.Name = new string[1]; subQos.Partition.Name[0] = "ChatRoom"; /* Create a Subscriber for the UserLoad application. */ ISubscriber chatSubscriber = participant.CreateSubscriber(subQos); ErrorHandler.checkHandle( chatSubscriber, "DDS.DomainParticipant.CreateSubscriber"); /* Create a DataReader for the NameService Topic * (using the appropriate QoS). */ DataReaderQos nsQos = null; status = chatSubscriber.GetDefaultDataReaderQos(ref nsQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.GetDefaultDataReaderQos"); status = chatSubscriber.CopyFromTopicQos(ref nsQos, settingTopicQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.CopyFromTopicQos"); IDataReader parentReader = chatSubscriber.CreateDataReader( nameServiceTopic, nsQos, null, StatusKind.Any); ErrorHandler.checkHandle( parentReader, "DDS.Subscriber.CreateDatareader (NameService)"); NameServiceDataReader nameServer = parentReader as NameServiceDataReader; /* Adapt the DataReaderQos for the ChatMessageDataReader to * keep track of all messages. */ DataReaderQos messageQos = new DataReaderQos(); status = chatSubscriber.GetDefaultDataReaderQos(ref messageQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.GetDefaultDataReaderQos"); status = chatSubscriber.CopyFromTopicQos( ref messageQos, reliableTopicQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.CopyFromTopicQos"); messageQos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos; /* Create a DataReader for the ChatMessage Topic * (using the appropriate QoS). */ parentReader = chatSubscriber.CreateDataReader( chatMessageTopic, messageQos); ErrorHandler.checkHandle( parentReader, "DDS.Subscriber.CreateDataReader (ChatMessage)"); /* Narrow the abstract parent into its typed representative. */ ChatMessageDataReader loadAdmin = parentReader as ChatMessageDataReader; /* Initialize the Query Arguments. */ string[] parameters = { "0" }; /* Create a QueryCondition that will contain all messages * with userID=ownID */ IQueryCondition singleUser = loadAdmin.CreateQueryCondition("userID=%0", parameters); ErrorHandler.checkHandle(singleUser, "DDS.DataReader.CreateQuerycondition"); /* Create a ReadCondition that will contain new users only */ IReadCondition newUser = nameServer.CreateReadCondition(SampleStateKind.NotRead, ViewStateKind.New, InstanceStateKind.Alive); ErrorHandler.checkHandle(newUser, "DDS.DataReader.create_readcondition"); /* Obtain a StatusCondition that triggers only when a Writer * changes Liveliness */ IStatusCondition leftUser = loadAdmin.StatusCondition; ErrorHandler.checkHandle(leftUser, "DDS.DataReader.GetStatusCondition"); status = leftUser.SetEnabledStatuses(StatusKind.LivelinessChanged); ErrorHandler.checkStatus(status, "DDS.StatusCondition.SetEnabledStatuses"); /* Create a bare guard which will be used to close the room */ escape = new GuardCondition(); /* Create a waitset and add the ReadConditions */ WaitSet userLoadWS = new WaitSet(); status = userLoadWS.AttachCondition(newUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (newUser)"); status = userLoadWS.AttachCondition(leftUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (leftUser)"); status = userLoadWS.AttachCondition(escape); ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (escape)"); /* Initialize and pre-allocate the GuardList used to obtain * the triggered Conditions. */ ICondition[] guardList = new ICondition[3]; /* Remove all known Users that are not currently active. */ NameService[] nsMsgs = null; SampleInfo[] nsInfos = null; status = nameServer.Take(ref nsMsgs, ref nsInfos, Length.Unlimited, SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.NotAlive); ErrorHandler.checkStatus( status, "Chat.NameServiceDataReader.Take"); status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos); ErrorHandler.checkStatus( status, "Chat.NameServiceDataReader.ReturnLoan"); /* Start the sleeper thread. */ new Thread(new UserLoad().doWait).Start(); bool closed = false; int prevCount = 0; ChatMessage[] msgs = null; SampleInfo[] msgInfos = null; while (!closed) { /* Wait until at least one of the Conditions in the * waitset triggers. */ status = userLoadWS.Wait(ref guardList, Duration.Infinite); ErrorHandler.checkStatus(status, "DDS.WaitSet.Wait"); /* Walk over all guards to display information */ foreach (ICondition guard in guardList) { if (guard == newUser) { /* The newUser ReadCondition contains data */ status = nameServer.ReadWithCondition(ref nsMsgs, ref nsInfos, newUser); ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.read_w_condition"); foreach (NameService ns in nsMsgs) { Console.WriteLine("New user: "******"Chat.NameServiceDataReader.ReturnLoan"); } else if (guard == leftUser) { // Some liveliness has changed (either a DataWriter // joined or a DataWriter left) LivelinessChangedStatus livelinessStatus = new LivelinessChangedStatus(); status = loadAdmin.GetLivelinessChangedStatus(ref livelinessStatus); ErrorHandler.checkStatus(status, "DDS.DataReader.getLivelinessChangedStatus"); if (livelinessStatus.AliveCount < prevCount) { /* A user has left the ChatRoom, since a DataWriter * lost its liveliness. Take the effected users * so they will not appear in the list later on. */ status = nameServer.Take( ref nsMsgs, ref nsInfos, Length.Unlimited, SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.NotAliveNoWriters); ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.Take"); foreach (NameService nsMsg in nsMsgs) { /* re-apply query arguments */ parameters[0] = nsMsg.userID.ToString(); status = singleUser.SetQueryParameters(parameters); ErrorHandler.checkStatus(status, "DDS.QueryCondition.SetQueryParameters"); /* Read this user's history */ status = loadAdmin.TakeWithCondition( ref msgs, ref msgInfos, singleUser); ErrorHandler.checkStatus( status, "Chat.ChatMessageDataReader.TakeWithCondition"); /* Display the user and his history */ Console.WriteLine("Departed user {0} has sent {1} messages ", nsMsg.name, msgs.Length); status = loadAdmin.ReturnLoan(ref msgs, ref msgInfos); ErrorHandler.checkStatus(status, "Chat.ChatMessageDataReader.ReturnLoan"); } status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos); ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.ReturnLoan"); } prevCount = livelinessStatus.AliveCount; } else if (guard == escape) { Console.WriteLine("UserLoad has terminated."); closed = true; } else { //System.Diagnostics.Debug.Fail("Unknown Condition"); } } /* for */ } /* while (!closed) */ /* Remove all Conditions from the WaitSet. */ status = userLoadWS.DetachCondition(escape); ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (escape)"); status = userLoadWS.DetachCondition(leftUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (leftUser)"); status = userLoadWS.DetachCondition(newUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (newUser)"); /* Free all resources */ status = participant.DeleteContainedEntities(); ErrorHandler.checkStatus(status, "DDS.DomainParticipant.DeleteContainedEntities"); status = dpf.DeleteParticipant(participant); ErrorHandler.checkStatus(status, "DDS.DomainParticipantFactory.DeleteParticipant"); }
private void RunExample( int domainId = 0, uint lotsToProcess = 10) { // Exercise #1.1: Add QoS provider // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // Exercise #1.2: Load DomainParticipant QoS profile DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create a Topic named // "ChocolateLotState" with type ChocolateLotState. Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>( CHOCOLATE_LOT_STATE_TOPIC.Value); // Add a Topic for Temperature to this application Topic <Temperature> temperatureTopic = participant.CreateTopic <Temperature>( CHOCOLATE_TEMPERATURE_TOPIC.Value); // A Publisher allows an application to create one or more DataWriters // Publisher QoS is configured in USER_QOS_PROFILES.xml Publisher publisher = participant.CreatePublisher(); // This DataWriter writes data on Topic "ChocolateLotState" // Exercise #4.1: Load ChocolateLotState DataWriter QoS profile after // debugging incompatible QoS DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter(lotStateTopic); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState". // Exercise #1.3: Update the lotStateReader and temperatureReader // to use correct QoS DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader(lotStateTopic); // Add a DataReader for Temperature to this application DataReader <Temperature> temperatureReader = subscriber.CreateDataReader(temperatureTopic); // Obtain the DataReader's Status Condition StatusCondition temperatureStatusCondition = temperatureReader.StatusCondition; temperatureStatusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate a handler with the status condition. This will run when the // condition is triggered, in the context of the dispatch call (see below) temperatureStatusCondition.Triggered += _ => MonitorTemperature(temperatureReader); // Do the same with the lotStateReader's StatusCondition StatusCondition lotStateStatusCondition = lotStateReader.StatusCondition; lotStateStatusCondition.EnabledStatuses = StatusMask.DataAvailable; int lotsProcessed = 0; lotStateStatusCondition.Triggered += _ => lotsProcessed += MonitorLotState(lotStateReader); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(lotStateStatusCondition); // Add the new DataReader's StatusCondition to the Waitset waitset.AttachCondition(temperatureStatusCondition); // Start publishing in a separate thread var startLotTask = Task.Run(() => PublishStartLot(lotStateWriter, lotsToProcess)); while (!shutdownRequested && lotsProcessed < lotsToProcess) { waitset.Dispatch(Duration.FromSeconds(4)); } startLotTask.Wait(); }
public void Run() { #if DBCallTests DDS.Test.DatabaseTests(); #endif Console.WriteLine("Press enter to enter..."); Console.ReadLine(); Data.DataTest detectionData = new Data.DataTest(); detectionData.TestId = 3214; detectionData.Emergency = true; detectionData.TestStr = "not really"; //detectionData.SeqInt[3] = 23; #if TestMarshaling //Tactical.DetectionTypeSupport support = new Tactical.DetectionTypeSupport(); //Tactical.Detection cachedObj = new Tactical.Detection(); //support.Copy(cachedObj, detectionData); //SampleMarshaler marshaler = SampleMarshalerFactory.CreateMarshaler(detectionData); //using (SampleMarshalHelper helper = new SampleMarshalHelper(marshaler)) //{ // DDS.OpenSplice.Gapi.Test.test_detection(helper.GapiPtr); // Tactical.Detection detectionData2 = new Tactical.Detection(); // SampleMarshaler marshaler2 = SampleMarshalerFactory.CreateMarshaler(detectionData2); // marshaler2.CopyOut(helper.GapiPtr, 0); //} //Duration d = new Duration(234, 2343); //int sec; //uint nanosec; //DDS.OpenSplice.Gapi.Test.test_duration(d, out sec, out nanosec); //LivelinessChangedStatus status; //DDS.OpenSplice.Gapi.Test.get_liveliness_changed_status(out status); //Time t = new Time(1, 2); //int size = Marshal.SizeOf(t); //IntPtr ptr = Marshal.AllocHGlobal(size); //Marshal.StructureToPtr(t, ptr, true); #endif //DDS.Test.TestDataReaderQos(); //DDS.Test.TestTopicQos(); // Create a DomainParticipantFactory DomainParticipantFactory dpf = DomainParticipantFactory.Instance; Console.WriteLine("DomainParticipantFactory: " + dpf); // Tailor the DomainPartipantFactoryQos; DomainParticipantFactoryQos dpfQos = null; ReturnCode result = dpf.GetQos(ref dpfQos); Console.WriteLine("DomainParticipantFactory.get_qos: {0}", result); Console.WriteLine("DomainParticipantFactoryQos.entity_factory.autoenable_created_entities: " + dpfQos.EntityFactory.AutoenableCreatedEntities); dpfQos.EntityFactory.AutoenableCreatedEntities = false; result = dpf.SetQos(dpfQos); Console.WriteLine("DomainParticipantFactory.set_qos: {0}", result); // Get the QOS settings for the Factory... Check values without additional changes DomainParticipantFactoryQos dpf2Qos = null; result = dpf.GetQos(ref dpf2Qos); Console.WriteLine("DomainParticipantFactory.get_qos: {0}", result); Console.WriteLine("DomainParticipantFactoryQos.entity_factory.autoenable_created_entities: " + dpf2Qos.EntityFactory.AutoenableCreatedEntities); // Create the domainParticipant itself. DomainParticipantQos dpQos = new DomainParticipantQos(); dpQos.UserData.Value = new byte[] { (byte)1, (byte)2, (byte)3 }; dpQos.EntityFactory.AutoenableCreatedEntities = true; dpQos.ListenerScheduling.SchedulingClass.Kind = SchedulingClassQosPolicyKind.ScheduleDefault; dpQos.ListenerScheduling.SchedulingPriorityKind.Kind = SchedulingPriorityQosPolicyKind.PriorityRelative; dpQos.ListenerScheduling.SchedulingPriority = 0; dpQos.WatchdogScheduling.SchedulingClass.Kind = SchedulingClassQosPolicyKind.ScheduleDefault; dpQos.WatchdogScheduling.SchedulingPriorityKind.Kind = SchedulingPriorityQosPolicyKind.PriorityRelative; dpQos.WatchdogScheduling.SchedulingPriority = 4; IDomainParticipant dp = dpf.CreateParticipant(null, dpQos); Console.Write("DomainParticipant: "); Console.WriteLine(dp != null ? "yes" : "no"); if (dp.ContainsEntity(0)) { Console.WriteLine("contains_entity with nil handle incorrect"); } if (dp.ContainsEntity(100)) { Console.WriteLine("contains_entity with incorrect handle incorrect"); } Time currentTime; dp.GetCurrentTime(out currentTime); Console.WriteLine("Current Local Time: {0}", currentTime.ToDatetime().ToLocalTime()); // And look up this DomainParticipant. IDomainParticipant dp2 = dpf.LookupParticipant(null); DomainParticipantQos dp2Qos = null; Console.Write("lookup DomainParticipant: "); Console.WriteLine(dp2 != null ? "Success" : "Fail"); result = dp2.GetQos(ref dp2Qos); Console.WriteLine("DomainParticipant.get_qos: {0}", result); Console.WriteLine("DomainParticipantQos.entity_factory.autoenable_created_entities: " + dp2Qos.EntityFactory.AutoenableCreatedEntities); // Create a new PublisherQos and set some values... PublisherQos publisherQos = new PublisherQos(); publisherQos.EntityFactory.AutoenableCreatedEntities = true; publisherQos.Partition.Name = new string[] { "howdy" }; //, "neighbor", "partition" }; // true not supported in 4.1 ?? publisherQos.Presentation.OrderedAccess = false; // Create the Publisher dp.Enable(); IPublisher publisher = dp.CreatePublisher(publisherQos); Console.WriteLine("Create Publisher: {0}", publisher); //DataWriterQos dwQos; //publisher.GetDefaultDataWriterQos(out dwQos); // Create a Detection Type Support and register it's type Data.DataTestTypeSupport support = new Data.DataTestTypeSupport(); string test2 = support.TypeName; Console.WriteLine("Register Typesupport"); result = support.RegisterType(dp, support.TypeName); Console.WriteLine("Register Typesupport Result: {0}", result); // Create a topic for the Detection type TopicQos topicQos = null; result = dp.GetDefaultTopicQos(ref topicQos); //topicQos.Ownership.Kind = OwnershipQosPolicyKind.ExclusiveOwnershipQos; //DDS.Test.TestTopicQos2(ref topicQos); // Add a listener to the topic ITopic topic = dp.CreateTopic("Data_DataTest", support.TypeName, topicQos, this, StatusKind.InconsistentTopic); topicQos.History.Depth = 5; ITopic topic2 = dp.CreateTopic("Data_DataTest", support.TypeName, topicQos); // ErrorCode errorCode; // string msg; // result = ErrorInfo.Update(); // result = ErrorInfo.GetCode(out errorCode); // result = ErrorInfo.GetMessage(out msg); // Create a DataWriter for the topic Data.IDataTestDataWriter dataWriter = publisher.CreateDataWriter(topic) as Data.IDataTestDataWriter; // Create a SubscriberQos object and set the partition name SubscriberQos subscriberQos = null; result = dp.GetDefaultSubscriberQos(ref subscriberQos); subscriberQos.Partition.Name = new string[] { "howdy" }; // Create the subscriber ISubscriber sub = dp.CreateSubscriber(subscriberQos); // Verify that the subsciber was created... if (sub == null) { Console.WriteLine("Subscriber not created"); return; } DDS.DataReaderQos readerQos = null; sub.GetDefaultDataReaderQos(ref readerQos); //readerQos.SubscriptionKeys.KeyList = new string[] { "test" }; //readerQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos; //readerQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; // Create a DataReader for the Detection topic Data.IDataTestDataReader dataReader = sub.CreateDataReader(topic, readerQos, this, StatusKind.DataAvailable) as Data.IDataTestDataReader; // Create a filtered detection topic (only read detections that have an id != 4) IContentFilteredTopic filteredTopic = dp.CreateContentFilteredTopic("Another", topic, "TestId <> %0", "4"); string[] testParams = null; result = filteredTopic.GetExpressionParameters(ref testParams); result = filteredTopic.SetExpressionParameters("hello", "test"); result = filteredTopic.GetExpressionParameters(ref testParams); // Create a DataReader to read the filtered topic IDataReader reader2 = sub.CreateDataReader(filteredTopic); IQueryCondition queryCondition = dataReader.CreateQueryCondition( "TestId = %0", "234"); // just for testing... //GC.Collect(); // WaitSet WaitSet waitSet = new WaitSet(); // either use status conditions...or IStatusCondition sc = reader2.StatusCondition; sc.SetEnabledStatuses(StatusKind.DataAvailable); waitSet.AttachCondition(sc); IStatusCondition sc2 = reader2.StatusCondition; // read conditions... // IReadCondition readCond = reader2.CreateReadCondition(); // waitSet.AttachCondition(readCond); ICondition[] cond = null; //waitSet.Wait(ref cond, Duration.Infinite); Console.WriteLine("Press enter to write data"); Console.ReadLine(); detectionData.SequenceTest = new int[1];// new System.Collections.Generic.List<int>(); //detectionData.SequenceTest.Add(4); detectionData.SequenceTest[0] = 4; // Write detection data result = dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 234; dataWriter.Write(detectionData, InstanceHandle.Nil); detectionData = new Data.DataTest(); detectionData.TestId = 235; dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 236; dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 237; dataWriter.Write(detectionData); Console.WriteLine("Press enter to read data"); Console.ReadLine(); // Read the data SampleInfo[] infos = null; Data.DataTest[] dataValues = null; // result = dataReader.ReadWithCondition(ref dataValues, ref infos, DDS.Length.Unlimited, queryCondition); result = dataReader.Read(ref dataValues, ref infos); Console.WriteLine("dataReader: {0}", dataReader); if (dataValues != null) { Console.WriteLine("Number of samples received: {0}", dataValues.Length); for (int index = 0; index < dataValues.Length; index++) { Console.WriteLine("TestId: {0}, ProviderId: {1}, Emergency: {2}, TestStr: {3}", dataValues[index].TestId, dataValues[index].ProviderId, dataValues[index].Emergency, dataValues[index].TestStr); Console.WriteLine("info: ValidData: {0}, InstHandle: {1}, PubHandle:{2}, SourceTS: {3}, ArrivalTS: {4}, sample: {5}, view: {6}, instance: {7}", infos[index].ValidData, infos[index].InstanceHandle, infos[index].PublicationHandle, infos[index].SourceTimestamp, infos[index].ArrivalTimestamp, infos[index].SampleState, infos[index].ViewState, infos[index].InstanceState); } } Console.WriteLine("Press enter to cleanup"); Console.ReadLine(); Console.WriteLine("DeleteContainedEntities"); result = dp.DeleteContainedEntities(); // If you don't use DeleteContainedEntities then you must delete everything that was created //result = sub.DeleteDataReader(dataReader); //result = publisher.DeleteDataWriter(dataWriter); //result = dp.DeleteTopic(topic); //result = dp.DeletePublisher(publisher); //result = dp.DeleteSubscriber(sub); Console.WriteLine("DeleteParticipant"); result = dpf.DeleteParticipant(dp); Console.WriteLine("Press enter to exit"); Console.ReadLine(); }
private void RunExample(int domainId, string sensorId) { // 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 DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create Topics using the types // defined in chocolate_factory.xml var provider = new QosProvider("../chocolate_factory.xml"); Topic <Temperature> temperatureTopic = participant.CreateTopic( "ChocolateTemperature", types.Temperature); Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic( "ChocolateLotState", types.ChocolateLotState); // A Publisher allows an application to create one or more DataWriters // Publisher QoS is configured in USER_QOS_PROFILES.xml Publisher publisher = participant.CreatePublisher(); // Create DataWriters of Topics "ChocolateTemperature" & "ChocolateLotState" // DataWriter QoS is configured in USER_QOS_PROFILES.xml DataWriter <Temperature> temperatureWriter = publisher.CreateDataWriter(temperatureTopic); DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter(lotStateTopic); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // This DataReader reads data of type Temperature on Topic // "ChocolateTemperature". DataReader QoS is configured in // USER_QOS_PROFILES.xml DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader(lotStateTopic); // Obtain the DataReader's Status Condition StatusCondition statusCondition = lotStateReader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) statusCondition.Triggered += _ => ProcessLot(lotStateReader, lotStateWriter); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); // Create a thread to periodically publish the temperature Console.WriteLine($"ChocolateTemperature Sensor with ID: {sensorId} starting"); var temperatureTask = Task.Run( () => PublishTemperature(temperatureWriter, sensorId)); while (!shutdownRequested) { // Wait for ChocolateLotState Console.WriteLine("Waiting for lot"); waitset.Dispatch(Duration.FromSeconds(4)); } temperatureTask.Wait(); }
static void Main(string[] args) { DDSEntityManager mgr = new DDSEntityManager("WaitSet"); String partitionName = "WaitSet example"; // create Domain Participant mgr.createParticipant(partitionName); // create Type MsgTypeSupport msgTS = new MsgTypeSupport(); mgr.registerType(msgTS); // create Topic mgr.createTopic("WaitSetData_Msg"); // create Subscriber mgr.createSubscriber(); // create DataReader mgr.createReader(false); // Read Events IDataReader dreader = mgr.getReader(); MsgDataReader WaitSetReader = dreader as MsgDataReader; // Create a WaitSet WaitSet w = new WaitSet(); // Create a ReadCondition IReadCondition readCond = WaitSetReader.CreateReadCondition(SampleStateKind.NotRead, ViewStateKind.New, InstanceStateKind.Alive); ErrorHandler.checkHandle(readCond, "DataReader.CreateReadCondition"); // Create a QueryCondition String[] queryStr = { "Hello again" }; Console.WriteLine("=== [WaitSetDataSubscriber] Query : message = \"Hello again"); IQueryCondition queryCond = WaitSetReader.CreateQueryCondition("message=%0", queryStr); ErrorHandler.checkHandle(queryCond, "DataReader.CreateQueryCondition"); // Obtain a StatusCondition IStatusCondition statusCond; statusCond = dreader.StatusCondition; statusCond.SetEnabledStatuses(StatusKind.LivelinessChanged); ErrorHandler.checkHandle(statusCond, "DataReader.StatusCondition"); GuardCondition escape; escape = new GuardCondition(); ReturnCode result; result = w.AttachCondition(statusCond); ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (status)"); result = w.AttachCondition(readCond); ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (read)"); result = w.AttachCondition(queryCond); ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (query)"); result = w.AttachCondition(escape); ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (guard)"); /* Initialize and pre-allocate the GuardList used to obtain * the triggered Conditions. */ ICondition[] guardList = new ICondition[4]; DDS.SampleInfo[] infoSeq = null; Msg[] msgSeq = null; bool escaped = false; bool writerLeft = false; int prevCount = 0; int count = 0; Console.WriteLine("=== [WaitSetDataSubscriber] Ready ..."); while (!escaped && count < 20) { /** * Wait until data will be available */ Duration wait_timeout = new Duration(Duration.InfiniteSec, Duration.InfiniteNanoSec); result = w.Wait(ref guardList, wait_timeout); ErrorHandler.checkStatus(result, "WaitSet.Wait"); /* Walk over all guards to display information */ foreach (ICondition guard in guardList) { if (guard == readCond) { result = WaitSetReader.ReadWithCondition(ref msgSeq, ref infoSeq, Length.Unlimited, readCond); ErrorHandler.checkStatus(result, "WaitSetReader.ReadWithCondition"); foreach (Msg msg in msgSeq) { Console.WriteLine(" --- New message received --- "); Console.WriteLine(" userID: {0}", msg.userID); Console.WriteLine(" Message : \"{0}", msg.message); } result = WaitSetReader.ReturnLoan(ref msgSeq, ref infoSeq); ErrorHandler.checkStatus(result, "WaitSet.ReturnLoan"); } else if (guard == queryCond) { result = WaitSetReader.TakeWithCondition(ref msgSeq, ref infoSeq, Length.Unlimited, queryCond); ErrorHandler.checkStatus(result, "WaitSetReader.TakeWithCondition"); foreach (Msg msg in msgSeq) { Console.WriteLine(" --- New message received with QueryCondition --- "); Console.WriteLine(" userID: {0}", msg.userID); Console.WriteLine(" Message : \" {0}", msg.message); } result = WaitSetReader.ReturnLoan(ref msgSeq, ref infoSeq); ErrorHandler.checkStatus(result, "WaitSet.ReturnLoan"); } else if (guard == statusCond) { LivelinessChangedStatus livelinessStatus = new LivelinessChangedStatus(); result = WaitSetReader.GetLivelinessChangedStatus(ref livelinessStatus); ErrorHandler.checkStatus(result, "DataReader.getLivelinessChangedStatus"); if (livelinessStatus.AliveCount < prevCount) { Console.WriteLine("!!! A WaitSetDataWriter lost its liveliness"); writerLeft = true; Console.WriteLine("Triggering escape condition."); ReturnCode status = escape.SetTriggerValue(true); } else { Console.WriteLine("!!! A WaitSetDataWriter joined"); } prevCount = livelinessStatus.AliveCount; } else if (guard == escape) { Console.WriteLine("WaitSetSubscriber has terminated."); escaped = true; ReturnCode status = escape.SetTriggerValue(false); } else { // Unknown Condition } } ++count; } // Detach all Conditions from the WaitSet result = w.DetachCondition(escape); ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (escape)"); result = w.DetachCondition(readCond); ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (readCond)"); result = w.DetachCondition(queryCond); ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (queryCond)"); result = w.DetachCondition(statusCond); ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (statusCond)"); Console.WriteLine("=== [Subscriber] Closed"); // clean up WaitSetReader.DeleteReadCondition(readCond); WaitSetReader.DeleteReadCondition(queryCond); mgr.getSubscriber().DeleteDataReader(WaitSetReader); mgr.deleteSubscriber(); mgr.deleteTopic(); mgr.deleteParticipant(); }
static void Main(string[] args) { bool automatic = true; if (args.Length > 1) { automatic = args[0].Equals("true"); } string hostName; DDSEntityManager mgr = new DDSEntityManager("BuiltInTopics"); // create domain participant mgr.createParticipant("BuiltInTopics"); // Resolve the built-in Subscriber ISubscriber builtInSubscriber = mgr.getParticipant().BuiltInSubscriber; // Lookup the DataReader for the DCPSParticipant built-in Topic IDataReader reader = builtInSubscriber.LookupDataReader("DCPSParticipant"); // Cast the DataReader to a ParticipantBuiltInTopicDataReader ParticipantBuiltinTopicDataDataReader participantReader = reader as ParticipantBuiltinTopicDataDataReader; ErrorHandler.checkHandle(participantReader, "ParticipantBuiltInTopicDataReader narrow"); // Allocate a new typed seq for data samples ParticipantBuiltinTopicData[] data = null; // Allocate a new seq for sample infos SampleInfo[] info = null; Console.WriteLine("=== [BuiltInTopicsDataSubscriber] : Waiting for historical data ... "); participantReader.WaitForHistoricalData(Duration.Infinite); Console.WriteLine("=== [BuiltInTopicsDataSubscriber] : done"); // Create a new ReadCondition for the reader that matches all samples IReadCondition readCond = participantReader.CreateReadCondition(SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any); ErrorHandler.checkHandle(readCond, "DataReader.CreateReadCondition"); // Create a waitset and add the ReadCondition created above WaitSet aWaitSet = new WaitSet(); ReturnCode status = aWaitSet.AttachCondition(readCond); ErrorHandler.checkStatus(status, "WaitSet.AttachCondition"); // Initialize and pre-allocate the seq used to obtain the triggered Conditions. ICondition[] condSeq = new ICondition[0]; // Allocate a map store node information later on // The key of map is the id of the node and the value is the // number of active participants on that node. A Dictionary is used // as an UnorderedMap. Dictionary <int, int> nodes = new Dictionary <int, int>(); // Allocate a map to store node information later on. // The key of the map is the id of the node and the value is the // name of the node. A Dictionary is used as an UnorderedMap. Dictionary <int, string> nodeNames = new Dictionary <int, string>(); Console.WriteLine("=== [BuiltInTopicsDataSubscriber] Ready ..."); // Block the current thread until the attached condition becomes true // or the user interrupts. status = aWaitSet.Wait(ref condSeq, Duration.Infinite); ErrorHandler.checkStatus(status, "WaitSet.Wait"); bool done = false; // Continue processing until interrupted. while (!done) { // Take all the available data from the reader status = participantReader.Take(ref data, ref info, Length.Unlimited, SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any); ErrorHandler.checkStatus(status, "ParticipantBuiltinTopicDataDataReader.Take"); // Verify the data has been taken if (status == ReturnCode.Ok) { // Iterate the list of taken samples. for (int i = 0; i < data.Length; i++) { // Resolve the node identification int nodeId = data[i].Key[0]; // Initialise the number of participants for a node int participantCount = 0; // Check if we saw a participant for the node before. if (nodes.ContainsKey(nodeId)) { participantCount = nodes[nodeId]; } // Check sample info to see whether the instance is ALIVE. if (info[i].InstanceState == InstanceStateKind.Alive) { // The splicedaemon publishes the host-name in the // user_data field if (data[i].UserData.Value.Length != 0) { hostName = Encoding.UTF8.GetString(data[i].UserData.Value); nodeNames[nodeId] = hostName; } else { hostName = null; } // Increase the number of participants. participantCount++; // Update the number of participants for the node. nodes[nodeId] = participantCount; // If it's the first participant, report the node is up. if (participantCount == 1) { Console.WriteLine("=== [BuiltInTopicsDataSubscriber] Node ' {0} ' started (Total nodes running: {1} ) participantCount = {2}", nodeId, nodes.Count, participantCount); } if (hostName != null) { Console.WriteLine("=== [BuiltInTopicsDataSubscriber] Hostname for node ' {0} ' is hostname: {1}", nodeId, hostName); } } else { // Decrease the number of participants. participantCount--; // If no more participants exist, report the node is down. if (participantCount == 0) { hostName = nodeNames[nodeId]; nodeNames.Remove(nodeId); nodes.Remove(nodeId); if (hostName != null) { Console.WriteLine("=== [BuiltInTopicsDataSubscriber] Node {0} ({1}) stopped (Total nodes running: ({2})", nodeId, hostName, nodes.Count); } else { Console.WriteLine("=== [BuiltInTopicsDataSubscriber] Node {0} stopped (Total nodes running : {1})", nodeId, nodes.Count); } } else if (participantCount > 0) { nodes[nodeId] = participantCount; } } } } status = participantReader.ReturnLoan(ref data, ref info); ErrorHandler.checkStatus(status, "ParticipantReader.ReturnLoan"); if (!automatic) { // Block the current thread until the attached condition becomes // true or the user interrupts. Console.WriteLine("=== [BuiltInTopicsDataSubscriber] Waiting ... "); status = aWaitSet.Wait(ref condSeq, Duration.Infinite); done = (status != ReturnCode.Ok); } else { done = true; } } // Delete read condition status = participantReader.DeleteReadCondition(readCond); ErrorHandler.checkStatus(status, "DataReader.DeleteReadCondition"); // Recursively delete all entities in the DomainParticipant. mgr.getParticipant().DeleteContainedEntities(); // Delete DomainParticipant mgr.getDomainParticipantFactory().DeleteParticipant(mgr.getParticipant()); }
public void TestDetachConditions() { // Initialize WaitSet waitSet = new WaitSet(); GuardCondition guardCondition = new GuardCondition(); GuardCondition otherGuardCondition = new GuardCondition(); GuardCondition anotherGuardCondition = new GuardCondition(); ReturnCode result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); result = waitSet.AttachCondition(otherGuardCondition); Assert.AreEqual(ReturnCode.Ok, result); result = waitSet.AttachCondition(anotherGuardCondition); Assert.AreEqual(ReturnCode.Ok, result); // Test with null parameter result = waitSet.DetachConditions(null); Assert.AreEqual(ReturnCode.Ok, result); // Test with empty list parameter List <Condition> conditions = new List <Condition>(); result = waitSet.DetachConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); // Test with single element list parameter conditions = new List <Condition>() { guardCondition }; result = waitSet.DetachConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); conditions = new List <Condition>() { null }; result = waitSet.GetConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(2, conditions.Count); Assert.IsNotNull(conditions[0]); Assert.IsNotNull(conditions[1]); Assert.IsTrue(conditions[0] != conditions[1]); Assert.IsTrue(anotherGuardCondition == conditions[0] || anotherGuardCondition == conditions[1]); Assert.IsTrue(otherGuardCondition == conditions[0] || otherGuardCondition == conditions[1]); // Detach the other conditions conditions = new List <Condition>() { otherGuardCondition, anotherGuardCondition }; result = waitSet.DetachConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); conditions = new List <Condition>() { null }; result = waitSet.GetConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(0, conditions.Count); // Detach a not attached conditions GuardCondition notAttachedCondition = new GuardCondition(); conditions = new List <Condition>() { notAttachedCondition }; result = waitSet.DetachConditions(conditions); Assert.AreEqual(ReturnCode.PreconditionNotMet, result); }
private void RunExample(int domainId, string sensorId) { // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // Uses TemperingApplication QoS profile to set participant name. var qosProvider = new QosProvider("./qos_profiles.xml"); var participantQos = qosProvider.GetDomainParticipantQos( "ChocolateFactoryLibrary::TemperingApplication"); DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId, participantQos); // Create the topics Topic <Temperature> temperatureTopic = participant.CreateTopic <Temperature>("ChocolateTemperature"); Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>("ChocolateLotState"); // Exercise #1.1: Create a Content-Filtered Topic that filters out // chocolate lot state unless the next_station = TEMPERING_CONTROLLER // A Publisher allows an application to create one or more DataWriters // Create Publisher with default QoS. Publisher publisher = participant.CreatePublisher(); // Create DataWriter of Topic "ChocolateTemperature" // using ChocolateTemperatureProfile QoS profile for Streaming Data DataWriter <Temperature> temperatureWriter = publisher.CreateDataWriter( temperatureTopic, qos: qosProvider.GetDataWriterQos("ChocolateFactoryLibrary::ChocolateTemperatureProfile")); // Create DataWriter of Topic "ChocolateLotState" // using ChocolateLotStateProfile QoS profile for State Data DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter( lotStateTopic, qos: qosProvider.GetDataWriterQos("ChocolateFactoryLibrary::ChocolateLotStateProfile")); // A Subscriber allows an application to create one or more DataReaders Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState". // using ChocolateLotStateProfile QoS profile for State Data // Exercise #1.2: Change the DataReader's Topic to use a // Content-Filtered Topic DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader( lotStateTopic, qos: qosProvider.GetDataReaderQos("ChocolateFactoryLibrary::ChocolateLotStateProfile"), preEnableAction: reader => reader.RequestedIncompatibleQos += OnRequestedIncompatibleQos); // Obtain the DataReader's Status Condition StatusCondition statusCondition = lotStateReader.StatusCondition; // Enable the 'data available' status. statusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate an event handler with the status condition. // This will run when the condition is triggered, in the context of // the dispatch call (see below) statusCondition.Triggered += _ => ProcessLot(lotStateReader, lotStateWriter); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(statusCondition); // Create a thread to periodically publish the temperature Console.WriteLine($"ChocolateTemperature Sensor with ID: {sensorId} starting"); var temperatureTask = Task.Run( () => PublishTemperature(temperatureWriter, sensorId)); while (!shutdownRequested) { // Wait for ChocolateLotState Console.WriteLine("Waiting for lot"); waitset.Dispatch(Duration.FromSeconds(10)); } temperatureTask.Wait(); }
private void RunExample( int domainId = 0, uint lotsToProcess = 10) { // 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 DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create a Topic named // "ChocolateLotState" with type ChocolateLotState // In this example we use a DynamicType defined in XML, which creates // a DynamicData topic. Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic( "ChocolateLotState", types.ChocolateLotState); // Exercise #4.1: Add a Topic for Temperature to this application Topic <Temperature> temperatureTopic = participant.CreateTopic( "ChocolateTemperature", types.Temperature); // A Publisher allows an application to create one or more DataWriters // Publisher QoS is configured in USER_QOS_PROFILES.xml Publisher publisher = participant.CreatePublisher(); // This DataWriter writes data on Topic "ChocolateLotState" // DataWriter QoS is configured in USER_QOS_PROFILES.xml DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter(lotStateTopic); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState". // DataReader QoS is configured in USER_QOS_PROFILES.xml DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader(lotStateTopic); // Exercise #4.2: Add a DataReader for Temperature to this application DataReader <Temperature> temperatureReader = subscriber.CreateDataReader(temperatureTopic); // Obtain the DataReader's Status Condition StatusCondition temperatureStatusCondition = temperatureReader.StatusCondition; temperatureStatusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate a handler with the status condition. This will run when the // condition is triggered, in the context of the dispatch call (see below) temperatureStatusCondition.Triggered += _ => MonitorTemperature(temperatureReader); // Do the same with the lotStateReader's StatusCondition StatusCondition lotStateStatusCondition = lotStateReader.StatusCondition; lotStateStatusCondition.EnabledStatuses = StatusMask.DataAvailable; int lotsProcessed = 0; lotStateStatusCondition.Triggered += _ => lotsProcessed += MonitorLotState(lotStateReader); // Create a WaitSet and attach the StatusCondition WaitSet waitset = new WaitSet(); waitset.AttachCondition(lotStateStatusCondition); // Exercise #4.3: Add the new DataReader's StatusCondition to the Waitset waitset.AttachCondition(temperatureStatusCondition); var startLotTask = Task.Run(() => PublishStartLot(lotStateWriter, lotsToProcess)); while (!shutdownRequested && lotsProcessed < lotsToProcess) { waitset.Dispatch(Duration.FromSeconds(4)); } startLotTask.Wait(); }
// Exercise #4.4: Add monitor_temperature function private void RunExample( int domainId = 0, uint lotsToProcess = 10) { // 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 DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId); // A Topic has a name and a datatype. Create a Topic named // "ChocolateLotState" with type ChocolateLotState. Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>( "ChocolateLotState"); // Exercise #4.1: Add a Topic for Temperature to this application // A Publisher allows an application to create one or more DataWriters // Publisher QoS is configured in USER_QOS_PROFILES.xml Publisher publisher = participant.CreatePublisher(); // This DataWriter writes data on Topic "ChocolateLotState" // DataWriter QoS is configured in USER_QOS_PROFILES.xml DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter(lotStateTopic); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState". // DataReader QoS is configured in USER_QOS_PROFILES.xml DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader(lotStateTopic); // Exercise #4.2: Add a DataReader for Temperature to this application // Obtain the DataReader's Status Condition StatusCondition lotStateStatusCondition = lotStateReader.StatusCondition; // Enable the 'data available' status. lotStateStatusCondition.EnabledStatuses = StatusMask.DataAvailable; int lotsProcessed = 0; lotStateStatusCondition.Triggered += _ => lotsProcessed += MonitorLotState(lotStateReader); // Create a WaitSet and attach the StatusCondition WaitSet waitset = new WaitSet(); waitset.AttachCondition(lotStateStatusCondition); // Exercise #4.3: Add the new DataReader's StatusCondition to the Waitset // Start publishing in a separate thread var startLotTask = Task.Run(() => PublishStartLot(lotStateWriter, lotsToProcess)); while (!shutdownRequested && lotsProcessed < lotsToProcess) { waitset.Dispatch(Duration.FromSeconds(4)); } startLotTask.Wait(); }
private void RunExample( int domainId = 0, uint lotsToProcess = 10) { // Loads the QoS from the qos_profiles.xml file. var qosProvider = new QosProvider("./qos_profiles.xml"); // A DomainParticipant allows an application to begin communicating in // a DDS domain. Typically there is one DomainParticipant per application. // Load DomainParticipant QoS profile var participantQos = qosProvider.GetDomainParticipantQos( "ChocolateFactoryLibrary::MonitoringControlApplication"); DomainParticipant participant = DomainParticipantFactory.Instance .CreateParticipant(domainId, participantQos); // A Topic has a name and a datatype. Create a Topic with type // ChocolateLotState. Topic name is a constant defined in the IDL file. Topic <ChocolateLotState> lotStateTopic = participant.CreateTopic <ChocolateLotState>("ChocolateLotState"); // Add a Topic for Temperature to this application Topic <Temperature> temperatureTopic = participant.CreateTopic <Temperature>("ChocolateTemperature"); ContentFilteredTopic <Temperature> filteredTemperatureTopic = participant.CreateContentFilteredTopic( name: "FilteredTemperature", relatedTopic: temperatureTopic, filter: new Filter( expression: "degrees > %0 or degrees < %1", parameters: new string[] { "32", "30" })); // A Publisher allows an application to create one or more DataWriters // Publisher QoS is configured in USER_QOS_PROFILES.xml Publisher publisher = participant.CreatePublisher(); // This DataWriter writes data on Topic "ChocolateLotState" var writerQos = qosProvider.GetDataWriterQos( "ChocolateFactoryLibrary::ChocolateLotStateProfile"); DataWriter <ChocolateLotState> lotStateWriter = publisher.CreateDataWriter(lotStateTopic, writerQos); // A Subscriber allows an application to create one or more DataReaders // Subscriber QoS is configured in USER_QOS_PROFILES.xml Subscriber subscriber = participant.CreateSubscriber(); // Create DataReader of Topic "ChocolateLotState". // DataReader QoS is configured in USER_QOS_PROFILES.xml var readerQos = qosProvider.GetDataReaderQos( "ChocolateFactoryLibrary::ChocolateLotStateProfile"); DataReader <ChocolateLotState> lotStateReader = subscriber.CreateDataReader(lotStateTopic, readerQos); // Add a DataReader for Temperature to this application readerQos = qosProvider.GetDataReaderQos( "ChocolateFactoryLibrary::ChocolateTemperatureProfile"); DataReader <Temperature> temperatureReader = subscriber.CreateDataReader(filteredTemperatureTopic, readerQos); // Obtain the DataReader's Status Condition StatusCondition temperatureStatusCondition = temperatureReader.StatusCondition; temperatureStatusCondition.EnabledStatuses = StatusMask.DataAvailable; // Associate a handler with the status condition. This will run when the // condition is triggered, in the context of the dispatch call (see below) temperatureStatusCondition.Triggered += _ => MonitorTemperature(temperatureReader); // Do the same with the lotStateReader's StatusCondition StatusCondition lotStateStatusCondition = lotStateReader.StatusCondition; lotStateStatusCondition.EnabledStatuses = StatusMask.DataAvailable; int lotsProcessed = 0; lotStateStatusCondition.Triggered += _ => lotsProcessed += MonitorLotState(lotStateReader); // Create a WaitSet and attach the StatusCondition var waitset = new WaitSet(); waitset.AttachCondition(lotStateStatusCondition); // Add the new DataReader's StatusCondition to the Waitset waitset.AttachCondition(temperatureStatusCondition); // Start publishing in a separate thread var startLotTask = Task.Run(() => PublishStartLot(lotStateWriter, lotsToProcess)); while (!shutdownRequested && lotsProcessed < lotsToProcess) { waitset.Dispatch(Duration.FromSeconds(4)); } startLotTask.Wait(); }
public void TestWait() { // Initialize WaitSet waitSet = new WaitSet(); GuardCondition guardCondition = new GuardCondition(); ReturnCode result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); // Test with null conditions result = waitSet.Wait(null); Assert.AreEqual(ReturnCode.BadParameter, result); // Attach again should return OK but not actually add another condition to the WaitSet result = waitSet.AttachCondition(guardCondition); Assert.AreEqual(ReturnCode.Ok, result); List <Condition> conditions = new List <Condition>(); result = waitSet.GetConditions(conditions); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(1, conditions.Count); Assert.AreEqual(guardCondition, conditions[0]); // Test thread wait infinite int count = 0; Thread thread = new Thread(() => { result = waitSet.Wait(conditions); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(1, conditions.Count); Assert.AreEqual(guardCondition, conditions[0]); guardCondition.TriggerValue = false; count++; }); thread.Start(); guardCondition.TriggerValue = true; thread.Join(); Assert.AreEqual(1, count); // Test timeout count = 0; thread = new Thread(() => { result = waitSet.Wait(conditions, new Duration { Seconds = 0, NanoSeconds = 100000000 }); Assert.AreEqual(ReturnCode.Timeout, result); Assert.IsNotNull(conditions); Assert.AreEqual(0, conditions.Count); count++; }); thread.Start(); thread.Join(); Assert.AreEqual(1, count); // Test exit before timeout count = 0; thread = new Thread(() => { result = waitSet.Wait(conditions, new Duration { Seconds = 5 }); Assert.AreEqual(ReturnCode.Ok, result); Assert.IsNotNull(conditions); Assert.AreEqual(1, conditions.Count); Assert.AreEqual(guardCondition, conditions[0]); Assert.IsTrue(guardCondition.TriggerValue); guardCondition.TriggerValue = false; count++; }); thread.Start(); guardCondition.TriggerValue = true; thread.Join(); Assert.AreEqual(1, count); }
static void Main(string[] args) { bool useListener = true; OpenDDSharp.Ace.Init(); ParticipantService participantService = ParticipantService.Instance; DomainParticipantFactory domainFactory = participantService.GetDomainParticipantFactory(args); DomainParticipantQos qos = new DomainParticipantQos(); qos.EntityFactory.AutoenableCreatedEntities = false; qos.UserData.Value = Encoding.UTF8.GetBytes("sometext"); DomainParticipant participant = domainFactory.CreateParticipant(42, qos); if (participant == null) { throw new Exception("Could not create the participant"); } DomainParticipantQos aux = new DomainParticipantQos(); ReturnCode ret = participant.GetQos(aux); aux.EntityFactory.AutoenableCreatedEntities = true; ret = participant.SetQos(aux); if (participant != null) { TestStructTypeSupport support = new TestStructTypeSupport(); string typeName = support.GetTypeName(); ReturnCode result = support.RegisterType(participant, typeName); if (result != ReturnCode.Ok) { throw new Exception("Could not register the type"); } Topic topic = participant.CreateTopic("TopicName", typeName); Publisher publisher = participant.CreatePublisher(); if (publisher == null) { throw new Exception("Could not create the publisher"); } DataWriter dw = publisher.CreateDataWriter(topic); if (dw == null) { throw new Exception("Could not create the datawriter"); } TestStructDataWriter dataWriter = new TestStructDataWriter(dw); Subscriber subscriber = participant.CreateSubscriber(); if (subscriber == null) { throw new Exception("Could not create the subscribre"); } MyDataListener listener = null; if (useListener) { listener = new MyDataListener(); } DataReader dataReader = subscriber.CreateDataReader(topic, listener, StatusKind.DataAvailableStatus); if (dataReader == null) { throw new Exception("Could not create the datareader"); } WaitSet waitSet = null; StatusCondition statusCondition = null; if (!useListener) { waitSet = new WaitSet(); statusCondition = dataReader.StatusCondition; waitSet.AttachCondition(statusCondition); statusCondition.EnabledStatuses = StatusKind.DataAvailableStatus; new System.Threading.Thread(delegate() { ICollection <Condition> conditions = new List <Condition>(); Duration duration = new Duration { Seconds = Duration.InfiniteSeconds }; waitSet.Wait(conditions, duration); foreach (Condition cond in conditions) { if (cond == statusCondition && cond.TriggerValue) { StatusCondition sCond = (StatusCondition)cond; StatusMask mask = sCond.EnabledStatuses; if ((mask & StatusKind.DataAvailableStatus) != 0) { DataAvailable(dataReader); } } } }).Start(); } TestStruct test = new TestStruct { RawData = "Hello, I love you, won't you tell me your name?" }; test.LongSequence.Add(20); test.LongSequence.Add(10); test.LongSequence.Add(0); test.StringSequence.Add("Hello,"); test.StringSequence.Add("I love you"); test.StringSequence.Add("won't you tell me your name?"); test.LongDoubleType = 1.1; test.LongDoubleSequence.Add(1.1); test.LongDoubleSequence.Add(2.2); test.LongDoubleSequence.Add(3.3); test.LongArray[0, 0] = 1; test.LongArray[0, 1] = 2; test.LongArray[0, 2] = 3; test.LongArray[0, 3] = 4; test.LongArray[1, 0] = 1; test.LongArray[1, 1] = 2; test.LongArray[1, 2] = 3; test.LongArray[1, 3] = 4; test.LongArray[2, 0] = 1; test.LongArray[2, 1] = 2; test.LongArray[2, 2] = 3; test.LongArray[2, 3] = 4; test.StringArray[0, 0] = "Hello,"; test.StringArray[0, 1] = "I love you,"; test.StringArray[1, 0] = "won't you tell me"; test.StringArray[1, 1] = "your name?"; test.StructArray[0, 0] = new BasicTestStruct() { Id = 0 }; test.StructArray[0, 1] = new BasicTestStruct() { Id = 1 }; test.StructArray[1, 0] = new BasicTestStruct() { Id = 2 }; test.StructArray[1, 1] = new BasicTestStruct() { Id = 3 }; test.LongDoubleArray[0, 0] = 1.1; test.LongDoubleArray[0, 1] = 2.2; test.LongDoubleArray[1, 0] = 3.3; test.LongDoubleArray[1, 1] = 4.4; test.StructSequence.Add(new BasicTestStruct() { Id = 1 }); test.StructSequence.Add(new BasicTestStruct() { Id = 2 }); test.StructSequence.Add(new BasicTestStruct() { Id = 3 }); result = dataWriter.Write(test); System.Threading.Thread.Sleep(1000); if (!useListener) { waitSet.DetachCondition(statusCondition); } participant.DeleteContainedEntities(); domainFactory.DeleteParticipant(participant); } participantService.Shutdown(); OpenDDSharp.Ace.Fini(); Console.WriteLine("Press ENTER to finish the test."); Console.ReadLine(); }