Added support for Modal Models

example/C/src/Patterns/lib/SendersAndReceivers.lf

@@ -20,16 +20,16 @@ reactor SendOnce {
  * 
  * @param offset The starting time.
  * @param period The period.
- * @param initial The first output.
+ * @param start The first output.
  * @param increment The increment between outputs
  */
 reactor SendCount(
     offset:time(0), 
     period:time(1 sec),
-    initial:int(0),
+    start:int(0),
     increment:int(1)
 ) {
-    state count:int(initial);
+    state count:int(start);
     output out:int;
     timer t(offset, period);
     reaction(t) -> out {=
@@ -80,7 +80,7 @@ reactor SendOnceAndReceive {
  * 
  * @param offset The time of the first output.
  * @param period The period of the outputs.
- * @param initial The initial output value.
+ * @param start The initial output value.
  * @param increment The increment between outputs.
  * 
  * @input in The input to report.
@@ -98,7 +98,7 @@ reactor SendPeriodicallyAndReceive extends SendCount, Receive {
  * 
  * @param offset The time of the first output.
  * @param period The period of the outputs.
- * @param initial The initial output value.
+ * @param start The initial output value.
  * @param increment The increment between outputs.
  * 
  * @input in The input to report.
@@ -118,7 +118,7 @@ reactor ReceiveAndSendPeriodically extends Receive, SendCount {
 reactor SendPeriodicallyAndReceiveMultiport (
     offset:time(0),
     period:time(1 sec),
-    initial:int(0),
+    start:int(0),
     increment:int(1),
     width:int(4)
 ) {
@@ -127,7 +127,7 @@ reactor SendPeriodicallyAndReceiveMultiport (
 
     timer t(offset, period);
 
-    state count:int(initial);
+    state count:int(start);
 
     reaction(t) -> out {=
         SET(out, self->count);

experimental/C/src/ModalModels/BehaviorTrees/robohub_example_advanced.lf

@@ -0,0 +1,141 @@
+/*
+ * Implements a modal LF version of the hierarchical statemachine 
+ * for the behavior tree in presented in this article:
+ * https://robohub.org/introduction-to-behavior-trees/
+ * 
+ * Compared to the simple variant this uses modes more extensively, which 
+ * results in the correct behavior.
+ * Moreover, modeling the sequence in Nominal as modal enables the potential 
+ * use of a history transition that could allow modeling the continuation
+ * of the task squecnce at the point where it was left when the battery ran out.
+ */
+target C {
+//    logging: debug
+}
+
+reactor GenericTask(name:string("")) {
+    output success:bool
+    output failure:bool
+
+    initial mode Running {
+        // Just for testing
+        timer work(0, 250msec)
+        timer finish(1sec, 1sec)
+
+        reaction(work) {=
+            printf("%s\n", self->name);
+        =}
+
+        reaction(finish) -> success, Succeeded, failure, Failed {=
+            int r = rand() % 6;
+            if (r == 0) {
+                SET(failure, true);
+                SET_MODE(Failed);
+            } else {
+                SET(success, true);
+                SET_MODE(Succeeded);
+            }
+        =}
+    }
+
+    mode Succeeded {}
+    mode Failed {}
+}
+
+reactor NominalBehavior {
+    input BatteryOK:bool
+
+    output success:bool
+    output failure:bool
+
+    initial mode MoveToObj {
+        MoveToObjTask = new GenericTask(name="MoveToObj")
+
+        MoveToObjTask.failure -> failure
+
+        reaction(MoveToObjTask.success) -> CloseGrip {=
+            SET_MODE(CloseGrip);
+        =}
+    }
+
+    mode CloseGrip {
+        CloseGripTask = new GenericTask(name="CloseGrip")
+
+        CloseGripTask.failure -> failure
+
+        reaction(CloseGripTask.success) -> MoveHome {=
+            SET_MODE(MoveHome);
+        =}
+    }
+
+    mode MoveHome {
+        MoveHomeTask = new GenericTask(name="MoveHome")
+
+        MoveHomeTask.failure -> failure
+
+        reaction(MoveHomeTask.success) -> success {=
+            SET(success, true);
+        =}
+    }
+}
+
+reactor Robot {
+    input BatteryOK:bool
+
+    output success:bool
+    output failure:bool
+
+    initial mode Nominal {
+        NominalBehavior = new NominalBehavior()
+
+        NominalBehavior.success -> success
+        NominalBehavior.failure -> failure
+
+        reaction(BatteryOK) -> Charging {=
+            if (!BatteryOK->value) {
+                SET_MODE(Charging);
+                printf("Battery empty\n");
+            }
+        =}
+    }
+
+    mode Charging {
+        GoCharge = new GenericTask(name="GoCharge")
+
+        GoCharge.failure -> failure
+
+        reaction(BatteryOK, GoCharge.success) -> Nominal {=
+            // Assumes simultaneous presence
+            if (BatteryOK->value && GoCharge.success->value) {
+                SET_MODE(Nominal);
+                printf("Battery charged\n");
+            }
+        =}
+    }
+}
+
+main reactor {
+    timer Battery(1sec, 1sec)
+    state battery_state:int(1)
+
+    robot = new Robot()
+
+    reaction(Battery) -> robot.BatteryOK {=
+        self->battery_state--;
+        SET(robot.BatteryOK, self->battery_state > 0);
+        if (self->battery_state <= 0) {
+            self->battery_state = 5;
+        }
+    =}
+
+    reaction(robot.success) {=
+        printf("Total success\n");
+        request_stop();
+    =}
+
+    reaction(robot.failure) {=
+        printf("Utter failure\n");
+        request_stop();
+    =}
+
+}

experimental/C/src/ModalModels/BehaviorTrees/robohub_example_simple.lf

@@ -0,0 +1,116 @@
+/*
+ * Implements a modal LF version of the hierarchical statemachine 
+ * for the behavior tree in presented in this article:
+ * https://robohub.org/introduction-to-behavior-trees/
+ * 
+ * It implements the core behavior sequence by chaining up reactors.
+ * However, this currently does not work correctly with modes because
+ * there is no support for reacting to entering a mode.
+ * Hence, when switching to Charging the task is not started and if
+ * switching back to Nominal the sequence would not restart.
+ */
+target C;
+
+reactor GenericTask(name:string("")) {
+    input start:bool
+    output success:bool
+    output failure:bool
+
+    logical action continue_task
+
+    reaction(start, continue_task) -> continue_task, success, failure {=
+        printf("%s\n", self->name);
+        int r = rand() % 10;
+        if (r == 0) {
+            SET(failure, true);
+        } else if (r >= 6) {
+            SET(success, true);
+        } else {
+            schedule(continue_task, MSEC(250));
+        }
+    =}
+}
+
+reactor Robot {
+    input start:bool
+    input BatteryOK:bool
+    output success:bool
+    output failure:bool
+
+    initial mode Nominal {
+        MoveToObj = new GenericTask(name="MoveToObj")
+        CloseGrip = new GenericTask(name="CloseGrip")
+        MoveHome = new GenericTask(name="MoveHome")
+
+        start -> MoveToObj.start // No resume after charging
+        MoveToObj.success -> CloseGrip.start
+        CloseGrip.success -> MoveHome.start
+        MoveHome.success -> success
+
+        MoveToObj.failure -> failure
+        CloseGrip.failure -> failure
+        MoveHome.failure -> failure
+
+        // Potential solution for resuming after charging
+//        reaction(entry) -> MoveToObj.start {=
+//            // PROBLEM!!
+//            SET(MoveToObj.start, true);
+//        =}
+
+        reaction(BatteryOK) -> Charging {=
+            if (!BatteryOK->value) {
+                SET_MODE(Charging);
+                printf("Battery empty\n");
+            }
+        =}
+    }
+
+    mode Charging {
+        GoCharge = new GenericTask(name="GoCharge")
+
+        GoCharge.failure -> failure
+
+        // Potential solution for starting task when mode is entered because no start event is provided
+//        reaction(entry) -> GoCharge.start {=
+//            SET(GoCharge.start, true);
+//        =}
+
+        reaction(BatteryOK, GoCharge.success) -> Nominal {=
+            // Assumes simultaneous presence
+            if (BatteryOK->value && GoCharge.success->value) {
+                SET_MODE(Nominal);
+                printf("Battery charged\n");
+            }
+        =}
+    }
+}
+
+main reactor {
+    timer Battery(1sec, 1sec)
+    state battery_state:int(1)
+
+    robot = new Robot()
+
+    reaction(startup) -> robot.start {=
+        SET(robot.start, true);
+    =}
+
+    reaction(Battery) -> robot.BatteryOK {=
+        self->battery_state--;
+        SET(robot.BatteryOK, self->battery_state > 0);
+        if (self->battery_state <= 0) {
+            self->battery_state = 5;
+        }
+    =}
+
+    reaction(robot.success) {=
+        printf("Total success\n");
+        request_stop();
+    =}
+
+    reaction(robot.failure) {=
+        printf("Utter failure\n");
+        request_stop();
+    =}
+
+}

experimental/C/src/modal_models/SineAvgMax/sine_max_avg.lf → experimental/C/src/ModalModels/Motivation/SineAvgMax/sine_max_avg.lf

@@ -36,7 +36,7 @@ reactor ModalModel(sample_size(10)) {
     state sample({=[None] * sample_size=});
     state count(0);
 
-    state mode(0); # Only present w/o mode support
+    state _mode(0); # Only present w/o mode support
 
     // These actions only mimic the Ptolemy structure
     logical action processAVG
@@ -47,7 +47,7 @@ reactor ModalModel(sample_size(10)) {
 
     /** @label Mode AVG: Collect */
     reaction(data) -> processAVG {=
-        if self.mode == 0: # Only present w/o mode support 
+        if self._mode == 0: # Only present w/o mode support 
             self.sample[self.count] = data.value
             self.count += 1
             if self.count == self.sample_size:
@@ -57,19 +57,19 @@ reactor ModalModel(sample_size(10)) {
 
     /** @label Mode AVG: Process and Transition */
     reaction(processAVG) -> out {=
-        if self.mode == 0: # Only present w/o mode support 
+        if self._mode == 0: # Only present w/o mode support 
             #print("Processing: ", self.sample)
             out.set(sum(self.sample) / self.sample_size)
             # Transition to MAX
-            self.mode = 1 # set_mode(MAX)
+            self._mode = 1 # set_mode(MAX)
     =}
 
 //    }
 //    mode MAX {
 
     /** @label Mode MAX: Collect */
     reaction(data) -> processMAX {=
-        if self.mode == 1: # Only present w/o mode support 
+        if self._mode == 1: # Only present w/o mode support 
             self.sample[self.count] = data.value
             self.count += 1
             if self.count == self.sample_size:
@@ -79,11 +79,11 @@ reactor ModalModel(sample_size(10)) {
 
     /** @label Mode MAX: Process and Transition */
     reaction(processMAX) -> out {=
-        if self.mode == 1: # Only present w/o mode support 
+        if self._mode == 1: # Only present w/o mode support 
             #print("Processing: ", self.sample)
             out.set(max(self.sample))
             # Transition to MAX
-            self.mode = 0 # set_mode(AVG)
+            self._mode = 0 # set_mode(AVG)
     =}
 //    }
 }
@@ -121,7 +121,7 @@ reactor Plotter {
     =}
 }
 
-main reactor SineAvgMax {
+main reactor {
     s = new Sinewave(sample_rate = 125 msec, frequency = 0.44)
     m = new ModalModel()
     p = new Plotter()