Differences

This shows you the differences between two versions of the page.

--- eeros_architecture:sequencer:usage [2015/10/30 10:47] – [Sequence] graf
+++ eeros_architecture:sequencer:usage [2015/10/30 10:48] (current) – removed graf
@@ Line 1: / Line 1: @@
-======Sequencer Usage======
-This page describes the usage of the sequencer in the EEROS framework.
-===== Subsequence=====
-A subsequence is a sequence which is called by another sequence. Such a subsequence can be called in a blocking or non-blocking way. Blocking means that the step waits (or blocks) until the subsequence has finished. Non-blocking means that subsequence and main sequence run concurrently.
-====Blocking Call of a Subsequence====
-If you want to save your own data in the sequence, you need to create a new instance of a sequence. This should be done in the desired step (method) of the superior sequence.
-e.g. in the method //MoveBlocking()//
-<code c>
-MyBlockingSubSequence* subSequence = dynamic_cast<MyBlockingSubSequence*>eeros::sequencer::Sequence::getSequence("BlockingSubSequence"));
-if(!subSequence){
-  //callerThread for Blocking Sub Sequence is the same as is in this running Sequence.
-  subSequence = new MyBlockingSubSequence("BlockingSubSequence", callerThread);
-}
-</code>
-**Note:**
-  *In the above lines only one object of //MyBlockingSubSequence// with the name //BlockingSubSequence// is created.
-  *It is not allowed to call the //callerThread.addRunnable(this)// method, because the superior sequence calls the blocking sub-sequence directly by the //run()// method.
-To start the sub-sequence just call //run()//, which calls all methods in the callback list (filled by //fillCallBacks()//). Be sure that the sub-sequence is terminated before you restart it. This could happen, for example, in an exception handling ( [[.:..:sequencer_usage:error_handler | Error Handler]] ).
-<code c>
-//Here we wait for the returning of the subSequence.run() method
-while(subSequence->getState() != eeros::sequencer::kSequenceFinished){
-	subSequence->run();
-}
-</code>
-====Non Blocking Call of a Sub-Sequence====
-Remark: Please use pointer for a non blocking call, because the memory referenced by a pointer to an object exists until you delete it However, an object is removed as soon the scope of the method is no longer being used. In the case where both sequences (sequence and sub-sequence) run contemporaneously, the sub-sequence should not be deleted at the end of the step (method). That's why you should use pointers!
-A non-blocking sub-sequence has to be created as a thread, so you need a sub-sequencer for starting the new thread.
-e.g.:
-<code c>
-MySequencer* subSequencer = new MySequencer("SubSequencer");
-</code>
-Here you can reuse an existing sub-sequence if you want.
-<code c>
-MyNonBlockingSubSequence* subSequence = dynamic_cast<MyNonBlockingSubSequence*>(eeros::sequencer::Sequence::getSequence("NonBlockingSubSequence"));
-if(!subSequence){
-  subSequence = new MyNonBlockingSubSequence("NonBlockingSubSequence",subSequencer);
-}
-</code>
-**Note:**
-  *The constructor of the //MyNonBlockingSequence// class has to call //callerThread.addRunnable(this)// to add itself to the sub-sequencer runnable list, or else the callback methods are not called by the sub-sequencer.
-  *Do not forget to call //callerThread.stop()// in the last step of the sub-sequence.
-As soon as you have created the sub-sequence, you can start the sub-sequencer, which creates the threads to run all steps.
-<code c>
-  subSequencer->start();
-</code>
-In an other step of the superior sequence you can wait until the non-blocking sequence is terminated by using the method: //ExecutorService::waitForSequenceEnd(…);//.
-<code c>
-//Here we wait for the subsequencer Thread
-eeros::sequencer::Sequencer* seq = eeros::sequencer::Sequencer::getMainSequencer()->findSequencer("SubSequencer");
-if(seq && seq->getStatus() != kStopped){
-  ExecutorService::waitForSequenceEnd(seq);
-}
-</code>