Differences

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

--- getting_started:tutorials:mockrobot [2019/03/28 12:10] – [Sequencer] graf
+++ getting_started:tutorials:mockrobot [2026/01/13 08:33] (current) – [Control System] ursgraf
@@ Line 1: / Line 1: @@
 ====== Mock Robot Example ======
-This tutorial demonstrates an EEROS application complete with a control system, a safety system, and a sequencer. You can find the code in the directory with examples. Navigate to examples/mockRobotExample.
+This tutorial demonstrates an EEROS application complete with a control system, a safety system, and a sequencer. You can find the code under [[https://github.com/eeros-project/eeros-framework/blob/master/examples/system/MockRobotExample.cpp|MockRobotExample.cpp]].
+Start the program with
+<code cpp>
+$ sudo ./examples/system/mockRobotExample
+</code>
 ===== The Full Picture =====
-This example does not need any hardware. The moving of a robot is pretended by using integrators summing up. This represents the position on an axis. Before a robot can be moved it has usually to be homed.
+This example does not need any hardware. Before a robot can be moved it has usually to be homed. After homing the moving of a robot is pretended by using integrators summing up. This represents the position on an axis.
-The main application defines a control system and a safety system. The safety system is assigned as main task and passed to the executor. Further, a main sequence is defined and added to the sequencer ans started. After this the executor starts running.
+The main application defines a control system and a safety system. The safety system is assigned as main task and passed to the executor. Further, a main sequence is defined and added to the sequencer and started. After this the executor starts running.
 <code cpp>
@@ Line 21: / Line 26: @@
   MainSequence mainSeq("Main Sequence", sequencer, cs, ss, sp);
   sequencer.addSequence(mainSeq);
-  mainSeq.start();
+  mainSeq();
   ...
@@ Line 38: / Line 43: @@
 The main program must wait for the sequencer to stop until it can finish, in order to terminate gracefully without any running thread.
 ===== Control System =====
-The control system is very simple. Each of the two axis x and y, it has a constant block acting as a set point and an integrator block pretending the position to move. \\
+The control system is very simple. A constant block with a Vector2 acts as set point for the two axis x and y. An integrator block pretends how the position moves during homing. When the robot runs a path planner with constant acceleration, see [[eeros_architecture:control_system:available_blocks:pathplannerconstacc|]], moves its position back and forth.
+[{{ :getting_started:tutorials:mockrobotcontrolsystem.png?400 |//Control system//}}]
 In the constructor of the control system the blocks are created, connected, and the integrator are enabled. All of the blocks are added to a time domain which itself is passed to the executor. This time domain runs in parallel to the safety system task.
 ===== Safety System =====
 The safety system has four levels and a couple of safety events to switch between these levels.
-[{{ :getting_started:tutorials:mockrobotsafetysystem.png?400 |//Safety system with levels and events.//}}]
+[{{ :getting_started:tutorials:mockrobotss.jpg?220 |//Safety system with levels and events.//}}]
 The event ''abort'' can be triggered in all levels except ''slOff''. The safety system starts in the level ''slHoming''. As soon as the homing is complete the safety level switches to ''slReady''. The sequencer can then cause the safety system to change to level ''slMoving''.
 ===== Sequencer =====
-The main sequence comprises of two subsequences and a step. The first of the two sequences is responsible for homing while the latter moves the robot up and down. It is defined as blocking, which causes it run in parallel to the main program and notably to the safety system which calls the start method of this sequence.
+The main sequence comprises of two subsequences and a step. The first of the two sequences is responsible for homing while the latter moves the robot up and down. The main sequence does the following action:
 <code cpp>
   int action() {
@@ Line 53: / Line 61: @@
       if (ss.getCurrentLevel() == sp.slHoming) {
         homing();
+      } else if(ss.getCurrentLevel() == sp.slReady) {
         wait(2);
-      } else if(ss.getCurrentLevel() == sp.slReady) {
+        cs.sw.switchToInput(1);
         ss.triggerEvent(sp.startMoving);
       } else if(ss.getCurrentLevel() == sp.slMoving) {
         upDown();
       }
+      wait(0.1);
     }
+    return 0;
   }
 </code>
+Depending on the safety level the homing or the upDown sequence is started. In ''slReady'' the robot pauses for 2 seconds. The action is stopped as soon as the sequencer stops running. The wait(0.1) is necessary to wait for the safety system to actually switch levels. Without waiting the situation could arise that a safety event is triggered which takes effect in the next cycles when the executor runs the safety system.
 <code cpp>
 class HomingSequence : public Sequence {
 public:
-  HomingSequence(std::string name, Sequencer& seq, MockRobotControlSystem& cs) : Sequence(name, seq), cs(cs) {  }
+  HomingSequence(std::string name, Sequence* caller, MockRobotControlSystem& cs, SafetySystem& ss, MockRobotSafetyProperties& sp) :
+    Sequence(name, caller, true),
+    cs(cs), ss(ss), sp(sp) { }
   int action() {
-    cs.setpointX.setValue(0.1);
+    cs.setpoint.setValue({0.1, 0.1});
-    cs.setpointY.setValue(0.1);
+  }
+  bool checkExitCondition() {
+    Matrix<2,1,double> val = cs.i.getOut().getSignal().getValue();
+    bool done = val[0] >= 1.0 && val[1] >= 1.0;
+    if (val[0] >= 1.0) cs.setpoint.setValue({0, cs.setpoint.getValue()[1]});
+    if (val[1] >= 1.0) cs.setpoint.setValue({cs.setpoint.getValue()[0], 0});
+    if (done) ss.triggerEvent(sp.homingDone);
+    return done;
   }
-  bool checkExitCondition() {return cs.iX.getOut().getSignal().getValue() >= 1.0 && cs.iY.getOut().getSignal().getValue() >= 1.0;}
-private:
   MockRobotControlSystem& cs;
+  SafetySystem& ss;
+  MockRobotSafetyProperties& sp;
 };
 </code>
-What does the sequence do? It's action method simply adjusts the set points of the two axis to a small positive value. That causes the position of the robot (represented by the two integrators) to slowly move upwards. The sequence, which in this case is a simple step, terminates as soon as its exit condition is met. That is when both axis reach the position of 1.0.
+What does the sequence do? It's action method simply adjusts the set points of the two axis to a small positive value. That causes the position of the robot (represented by the two integrators) to slowly move upwards. The sequence, which in this case is a simple step, terminates as soon as its exit condition is met. That is when both axis reach the position of 1.0. As soon as one of the axis reaches the position of 1.0 its setpoint is zeroed in order to stop it moving further. On termination a safety event is triggered.
 The second sequence "UpAndDown Sequence" is as follows:
@@ Line 85: / Line 105: @@
 class MoveUp : public Step {
 public:
-  MoveUp(std::string name, Sequencer& sequencer, BaseSequence* caller, MockRobotControlSystem& cs) : Step(name, sequencer, caller), cs(cs) { }
+  MoveUp(std::string name, Sequence* caller, MockRobotControlSystem& cs) : Step(name, caller), cs(cs) { }
   int action() {
-    cs.setpointX.setValue(0.7);
+    Matrix<2,1,double> dest{8.2, 27.0};
-    cs.setpointY.setValue(0.3);
+    cs.pp.move(dest);
+    return 0;
   }
-  bool checkExitCondition() {return cs.iX.getOut().getSignal().getValue() >= 5.0;}
+  bool checkExitCondition() {return cs.pp.endReached();}
-private:
   MockRobotControlSystem& cs;
 };
@@ Line 97: / Line 117: @@
 class MoveDown : public Step {
 public:
-  MoveDown(std::string name, Sequencer& sequencer, BaseSequence* caller, MockRobotControlSystem& cs) : Step(name, sequencer, caller), cs(cs) { }
+  MoveDown(std::string name, Sequence* caller, MockRobotControlSystem& cs) : Step(name, caller), cs(cs) { }
   int action() {
-    cs.setpointX.setValue(-0.6);
+    Matrix<2,1,double> dest{-5, 3};
-    cs.setpointY.setValue(-0.3);
+    cs.pp.move(dest);
+    return 0;
   }
-  bool checkExitCondition() {return cs.iX.getOut().getSignal().getValue() <= -5.0;}
+  bool checkExitCondition() {return cs.pp.endReached();}
-private:
   MockRobotControlSystem& cs;
 };
@@ Line 109: / Line 129: @@
 class UpAndDownSequence : public Sequence {
 public:
-  UpAndDownSequence(std::string name, Sequencer& seq, MockRobotControlSystem& cs) : Sequence(name, seq), cs(cs), moveUp("move up", seq, this, cs), moveDown("move down", seq, this, cs) { }
+  UpAndDownSequence(std::string name, Sequence* caller, MockRobotControlSystem& cs) :
+    Sequence(name, caller, true),
+    moveUp("move up", this, cs),
+    moveDown("move down", this, cs) { }
-  int action() {
+    int action() {
-    while (Sequencer::running) {
+      while (Sequencer::running) {
-      moveUp();
+        moveUp();
-      moveDown();
+        moveDown();
+      }
+      return 0;
     }
-  }
-private:
-  MockRobotControlSystem& cs;
   MoveUp moveUp;
   MoveDown moveDown;