Differences

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

--- eeros_architecture:sequencer:subsequence [2015/10/29 21:47] – [Nonblocking Call of a Subsequence] graf
+++ eeros_architecture:sequencer:subsequence [2015/10/31 09:05] (current) – external edit 127.0.0.1
@@ Line 7: / Line 7: @@
 ===== Simple Example =====
-We first define a class for the sub- or secondary sequence 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 SequenceB : public Sequence<void,double> {
 public:
-  SequenceA(std::string name, Sequencer* seq, Robot& r) : Sequence<void,double>(name, seq), robot(r){ }
+  SequenceB(std::string name, Sequencer* seq, Robot& r) : Sequence<void,double>(name, seq), robot(r){ }
   void run(double z) {
-    robot.moveXY(z);
+    robot.moveZ(z);
     yield();
-    robot.moveXY(0);
+    robot.moveZ(0);
   }
@@ Line 35: / Line 35: @@
   void run() {
     robot.moveXY(10, -20);
-    seqB(5);
+    sequenceB(5);
-    robot.moveXY(-10, -30);
+    robot.moveXY(-10, 30);
-    seqB(5);
+    sequenceB(5);
     robot.moveXY(0, 0);
   }
@@ Line 43: / Line 43: @@
 private:
   Robot& robot;
-  SequenceB seqB;
+  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. The following figure shows the flow of action.
+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 =====
 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.
-===== Headline =====
+==== Simple Example ====
- you have to make
-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 |}}