Differences

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

--- eeros_architecture:sequencer:subsequence [2015/10/27 17:33] – created graf
+++ eeros_architecture:sequencer:subsequence [2015/10/31 09:05] (current) – external edit 127.0.0.1
@@ Line 3: / Line 3: @@
 =====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.
+If several steps of a sequence have to be repeated more than once, it might be worth to pack them into a separate subsequence. This subsequence offers all the features of any sequence such as init or exit functions as well as checking of pre and post conditions. However, a blocking call to a subsequence allows to use the same sequencer as the calling sequence.
-e.g. in the method //MoveBlocking()//
 ===== Simple Example =====
-We first define a class for the secondarysequence as follows:
+We continue with our hypothetical robot from the example in [[eeros_architecture:sequencer:sequence|]]. We first define a class for the sub- or secondary sequence as follows:
 <code cpp>
-class MySequence : public Sequence<> {
+class SequenceB : public Sequence<void,double> {
 public:
-  MySequence(std::string name, Sequencer* seq, Robot& r) : Sequence<>(name, seq), robot(r){ }
+  SequenceB(std::string name, Sequencer* seq, Robot& r) : Sequence<void,double>(name, seq), robot(r){ }
-  void run() {
+  void run(double z) {
-    robot.moveXY(10, -20);
+    robot.moveZ(z);
     yield();
-    robot.moveXY(-10, -30);
+    robot.moveZ(0);
   }
@@ Line 25: / Line 24: @@
 </code>
-**Note:**
+The //run()// method is called with one parameter of type double. There is no return value. For this reason, our class has to extend the class ''sequence'' with the template parameters ''<void,double>''. To keep the example as simple as possible we omit the implementation of //init()/////exit()// functions and pre and post condition check functions.
-  *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]] ).
+We can now define our first or main sequence with
-<code c>
+<code cpp>
-//Here we wait for the returning of the subSequence.run() method
+class SequenceA : public Sequence<> {
-while(subSequence->getState() != eeros::sequencer::kSequenceFinished){
+public:
-	subSequence->run();
+  SequenceA(std::string name, Sequencer* seq, Robot& r) : Sequence<>(name, seq), robot(r), seqB("Seq B", seq, r) { }
-}
+  void run() {
+    robot.moveXY(10, -20);
+    sequenceB(5);
+    robot.moveXY(-10, 30);
+    sequenceB(5);
+    robot.moveXY(0, 0);
+  }
+private:
+  Robot& robot;
+  SequenceB sequenceB;
+};
+</code>
+In our main program we declare a sequencer for the main sequence. The same sequencer will also handle the subsequence. Sequence A and B do not run concurrently.
+<code cpp>
+int main() {
+  Sequencer sequencer;
+  SequenceA seqA("Seq A", &sequencer, robot);
+  sequencerA.start(&seqA);
+  sequencerA.join();
+};
 </code>
+The following figure shows the flow of action.
+{{ :eeros_architecture:sequencer:subsequenceblocking.png?400 |}}
+===== Nonblocking Call of a Subsequence =====
-====Non Blocking Call of a Sub-Sequence====
+A nonblocking subsequence has to run in its own thread. For this reason you need a separate subsequencer for it. Both sequences can now run concurrently. A certain step in a sequence could depend on a subsequence to have finished. For this purpose the function //join()// will wait for the subsequence to finish.
-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.
+==== Simple Example ====
-e.g.:
-<code c>
-MySequencer* subSequencer = new MySequencer("SubSequencer");
-</code>
-Here you can reuse an existing sub-sequence if you want.
+We first define a class for the sub- or secondary sequence as follows:
-<code c>
+<code cpp>
-MyNonBlockingSubSequence* subSequence = dynamic_cast<MyNonBlockingSubSequence*>(eeros::sequencer::Sequence::getSequence("NonBlockingSubSequence"));
+class SequenceB : public Sequence<> {
-if(!subSequence){
+public:
-  subSequence = new MyNonBlockingSubSequence("NonBlockingSubSequence",subSequencer);
+  SequenceB(std::string name, Sequencer* seq, Robot& r) : Sequence<void,double>(name, seq), robot(r){ }
-}
+  void run() {
+    robot.moveZ(5);
+    sleep(3);
+    yield();
+    robot.moveZ(0);
+  }
+private:
+  Robot& robot;
+};
 </code>
-**Note:**
+The //run()// method simply moves in z direction and, after a pause, returns to the original position.
-  *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.
+We can now define our first or main sequence with
-<code c>
+<code cpp>
-  subSequencer->start();
+class SequenceA : public Sequence<> {
+public:
+  SequenceA(std::string name, Sequencer* seq, Robot& r, Sequencer& seqB) : Sequence<>(name, seq), robot(r), seqB(seqB) { }
+  void run() {
+    robot.moveXY(10, -20);
+    sequencerB.start(0U);
+    robot.moveXY(-10, 30);
+    sequencerB.join();
+    robot.moveXY(0, 0);
+  }
+private:
+  Robot& robot;
+  Sequencer& sequencerB;
+};
 </code>
+In our main program we declare a sequencer for the main sequence. A second sequencer will run the subsequence.
-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 cpp>
-<code c>
+int main() {
-//Here we wait for the subsequencer Thread
+  Sequencer sequencerA, sequencerB;
-eeros::sequencer::Sequencer* seq = eeros::sequencer::Sequencer::getMainSequencer()->findSequencer("SubSequencer");
+  SequenceB seqB("Seq B", &sequencerB, robot);
-if(seq && seq->getStatus() != kStopped){
+  SequenceA seqA("Seq A", &sequencerA, robot, sequencerB);
-  ExecutorService::waitForSequenceEnd(seq);
+  sequencerB.addCmdSequence(&seqB);
-}
+  sequencerA.start(&seqA);
+  sequencerA.join();
+};
 </code>
+In the second step of the sequence A the sequence is started in its own thread. After this both run concurrently. The forth step of sequence A then waits for the sequence B to finish.
+The following figure shows the flow of action.
+{{ :eeros_architecture:sequencer:subsequencenonblocking.png?400 |}}