Differences

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

--- eeros_architecture:sequencer:sequence [2018/08/07 12:49] – [Waiting for Sequences to Finish] graf
+++ eeros_architecture:sequencer:sequence [2024/12/01 11:50] (current) – [Waiting for Sequences to Finish] ursgraf
@@ Line 5: / Line 5: @@
 A main feature of a sequence is whether it blocks the flow of control during running through its steps or whether the steps run in parallel to the main flow of control.
 [{{ :eeros_architecture:sequencer:sequenceblocking.png?500 | //Sequence B is blocking, sequence C is nonblocking// }}]
-Sequence A runs. That is, all its steps run consecutively. After step 1 is done the sequence B is called. As B is blocking its two steps run while A is being blocked. Only after B finishes does the control return back to A where step 2 and step 3 are then executed. After this sequence C is called. As C is nonblocking its two steps run in parallel to the remaining steps of sequence A. A must wait for C to finish by calling //join//. \\
+Sequence A runs. That is, all its steps run consecutively. After step 1 is done the sequence B is called. As B is blocking its two steps run while A is being blocked. Only after B finishes does the control return back to A where step 2 and step 3 are then executed. After this sequence C is called. As C is nonblocking its two steps run in parallel to the remaining steps of sequence A. A must wait for C to finish by calling //wait()//. \\
 A nonblocking sequence will run in its own thread of execution while a blocking sequence always runs in the same thread as the calling sequence.
@@ Line 29: / Line 29: @@
 class Move : public Step {
 public:
-  Move(std::string name, Sequencer& seq, BaseSequence* caller, Robot& r) : Step(name, seq, this) { }
+  Move(std::string name, Sequence* caller, Robot& r) : Step(name, this) { }
   int operator() (double x, double y) {xPos = x; yPos = y; return start();}
   int action() {
     robot.setValue(xPos, yPos);
+    return 0;
   }
   bool checkExitCondition() {
@@ Line 42: / Line 43: @@
 class MoveSequence : public Sequence {
 public:
-  MoveSequence(std::string name, Sequencer& seq) : Sequence(name, seq), moveXY("step", seq, this) { }
+  MoveSequence(std::string name, Sequencer& seq) : Sequence(name, seq), moveXY("step", this) { }
   int action() {
     robot.moveXY(10, 10)
     robot.moveXY(15, 25);
     robot.moveXY(22, 35);
+    return 0;
   }
 private:
@@ Line 56: / Line 58: @@
 ===== Waiting for Sequences to Finish =====
-Usually at some stage in your program you have to wait for a given sequence to finish until the program should continue. There are two methods to accomplish this, ''wait()'' and ''waitAndTerminate()''. \\
+Usually at some stage in your program you have to wait for a given sequence to finish until the program should continue. Let's assume that a main sequence starts another nonblocking sequence and at some stage wants to wait until this second sequence has finished. For this a sequence can be waited for with ''wait()''. \\
-The former waits for a given sequence to finish running. It returns as soon as all the steps defined in the sequence have completed to run. However, it does not terminate the associated thread. This allows to restart the same sequence with ''start()'' later on in the program. \\
+This method returns as soon as all the steps defined in the sequence have completed running. In order to get the return value of the sequence you can use ''getResult()''.
-On the other hand, ''waitAndTerminate()'' does also wait for all the steps defined in the sequence to have completed. Further, it will terminate the associated thread and return only after successful elimination of the thread object. After this, the sequence cannot be restarted. \\ \\
-IMPORTANT