Initial release.

AIDASystem-AltaRicaDataFlow.alt

+/* Date : 8 oct. 2018 */
+/* DataFlow format */
+
+domain Functions_BasicFunctions_BasicFunctionStatus = {ERRONEOUS, LOST, OK};
+
+domain Functions_BasicFunctions_ModeSelection = {AUTO, MANUAL};
+
+domain Functions_BasicFunctions_Presence = {ABSENT, PRESENT};
+
+domain Functions_BasicFunctions_ModeSelection_ErroneousLost = {AUTO, ERRONEOUS, LOST, MANUAL};
+
+node Functions_BasicFunctions_InOutFunction
+  flow 
+    icone:[1,3]:private;
+    input:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+  state 
+    status:Functions_BasicFunctions_BasicFunctionStatus;
+  event 
+    fail_loss,
+    fail_error;
+  trans 
+    (status = OK) |- fail_loss -> status := LOST;
+    (status = OK) |- fail_error -> status := ERRONEOUS;
+  assert 
+    icone = case { 
+      (status = OK) : 1,
+      (status = LOST) : 2,
+      else 3
+    },
+    output = case { 
+      (status = OK) : input,
+      else status
+    };
+  init 
+    status := OK;
+  extern 
+    law <event fail_loss> = constant(1.0E-4);
+    law <event fail_error> = constant(1.0E-5);
+edon
+
+node Functions_BasicFunctions_InOutModeFunction
+  flow 
+    icone:[1,2]:private;
+    outputMode:Functions_BasicFunctions_ModeSelection:out;
+    inputMode:Functions_BasicFunctions_ModeSelection:in;
+  state 
+    status:{OK, STUCK_AUTO, STUCK_MAN};
+  event 
+    stuck_auto,
+    stuck_man;
+  trans 
+    (status = OK) |- stuck_man -> status := STUCK_MAN;
+    (status = OK) |- stuck_auto -> status := STUCK_AUTO;
+  assert 
+    outputMode = case { 
+      (status = STUCK_AUTO) : AUTO,
+      (status = STUCK_MAN) : MANUAL,
+      else inputMode
+    },
+    icone = (if (outputMode = AUTO) then 1 else 2);
+  init 
+    status := OK;
+  extern 
+    law <event stuck_auto> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event stuck_auto>) = 9.877E8;
+    law <event stuck_man> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event stuck_man>) = 9.877E8;
+edon
+
+node Functions_BasicFunctions_SourceFunction
+  flow 
+    icone:[1,3]:private;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+  state 
+    status:Functions_BasicFunctions_BasicFunctionStatus;
+  event 
+    fail_loss,
+    fail_error;
+  trans 
+    (status = OK) |- fail_loss -> status := LOST;
+    (status = OK) |- fail_error -> status := ERRONEOUS;
+  assert 
+    icone = case { 
+      (status = OK) : 1,
+      (status = LOST) : 2,
+      else 3
+    },
+    output = status;
+  init 
+    status := OK;
+  extern 
+    law <event fail_loss> = constant(1.0E-4);
+    law <event fail_error> = constant(1.0E-5);
+edon
+
+node AIDASystem_Functions_Detection_v44
+  flow 
+    inputFlightPlan:Functions_BasicFunctions_BasicFunctionStatus:in;
+    inputPosition:Functions_BasicFunctions_BasicFunctionStatus:in;
+    inputSpeed:Functions_BasicFunctions_BasicFunctionStatus:in;
+    inputControlPosition:Functions_BasicFunctions_BasicFunctionStatus:in;
+    inputLostHelixesControl:bool:in;
+    inputIndicatedMode:Functions_BasicFunctions_ModeSelection:in;
+    PilotSelectedMode:Functions_BasicFunctions_ModeSelection:out;
+    ManualPayloadControl:Functions_BasicFunctions_Presence:out;
+    PilotInconsistentControl:bool:out;
+    PilotOrders:Functions_BasicFunctions_Presence:out;
+  state 
+    mode:Functions_BasicFunctions_ModeSelection;
+  event 
+    GoToManualMode;
+  trans 
+    (mode = AUTO) |- GoToManualMode -> mode := MANUAL;
+  assert 
+    PilotSelectedMode = (if (mode = AUTO) then AUTO else MANUAL),
+    ManualPayloadControl = (if (mode = AUTO) then ABSENT else PRESENT),
+    PilotInconsistentControl = ((mode = AUTO) and ((((((inputFlightPlan = ERRONEOUS) or (inputPosition # OK)) or (inputSpeed # OK)) or (inputControlPosition # OK)) or inputLostHelixesControl) or (inputIndicatedMode = MANUAL))),
+    PilotOrders = (if (mode = AUTO) then ABSENT else PRESENT);
+  init 
+    mode := AUTO;
+  extern 
+    law <event GoToManualMode> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event GoToManualMode>) = 9.877E8;
+edon
+
+node Functions_BasicOperators_AND
+  flow 
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+    input_1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    input_2:Functions_BasicFunctions_BasicFunctionStatus:in;
+  assert 
+    output = (if ((input_1 = OK) and (input_2 = OK)) then OK else (if ((input_1 = LOST) or (input_2 = LOST)) then LOST else ERRONEOUS));
+edon
+
+node Functions_BasicOperators_ErrConditionalSelector_2
+  flow 
+    icone:[1,2]:private;
+    inputAUTO:Functions_BasicFunctions_BasicFunctionStatus:in;
+    inputMANUAL:Functions_BasicFunctions_BasicFunctionStatus:in;
+    condition:Functions_BasicFunctions_ModeSelection:in;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+  assert 
+    icone = (if (condition = AUTO) then 1 else 2),
+    output = (if (condition = AUTO) then inputAUTO else inputMANUAL);
+edon
+
+node Functions_BasicOperators_ANDBoolErrLost
+  flow 
+    icone:[1,2]:private;
+    input:bool:in;
+    output:bool:out;
+    failurePropagation:Functions_BasicFunctions_BasicFunctionStatus:in;
+  assert 
+    icone = (if (failurePropagation = OK) then 1 else 2),
+    output = case { 
+      (failurePropagation = LOST) : false,
+      (failurePropagation = ERRONEOUS) : true,
+      else input
+    };
+edon
+
+node Boolean_Boolean_or4
+  flow 
+    icone:[1,2]:private;
+    O:bool:out;
+    I1:bool:in;
+    I2:bool:in;
+    I3:bool:in;
+    I4:bool:in;
+  assert 
+    icone = case { 
+      (((I1 or I2) or I3) or I4) : 1,
+      else 2
+    },
+    O = (((I1 or I2) or I3) or I4);
+edon
+
+node Functions_BasicOperators_Comparator
+  flow 
+    input1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    input2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:bool:out;
+  assert 
+    output = case { 
+      (input1 = LOST) : true,
+      (input2 = LOST) : true,
+      (input1 = input2) : false,
+      else true
+    };
+edon
+
+node Quadcopter_Observers_PilotRequiresManualMode
+  flow 
+    icone:[1,2]:private;
+    output:bool:out;
+    input:Functions_BasicFunctions_ModeSelection:in;
+  assert 
+    output = (input = MANUAL),
+    icone = (if output then 2 else 1);
+edon
+
+node Boolean_Boolean_filter
+  flow 
+    filterCriterion:bool:in;
+    input:bool:in;
+    output:bool:out;
+  assert 
+    output = (if filterCriterion then false else input);
+edon
+
+node Quadcopter_Observers_StuckModeMAN_v03
+  flow 
+    icone:[1,2]:private;
+    output:bool:out;
+    PilotAPEngagementOrder:Functions_BasicFunctions_ModeSelection:in;
+    AppliedAPEngagement:Functions_BasicFunctions_ModeSelection:in;
+  assert 
+    output = ((AppliedAPEngagement = MANUAL) and (PilotAPEngagementOrder = AUTO)),
+    icone = (if output then 2 else 1);
+edon
+
+node Boolean_Boolean_or2
+  flow 
+    icone:[1,2]:private;
+    O:bool:out;
+    I1:bool:in;
+    I2:bool:in;
+  assert 
+    icone = case { 
+      (I1 or I2) : 1,
+      else 2
+    },
+    O = (I1 or I2);
+edon
+
+node Quadcopter_Observers_StuckMode_v03
+  flow 
+    icone:[1,2]:private;
+    output:bool:out;
+    input:Functions_BasicFunctions_ModeSelection:in;
+  assert 
+    output = (input = AUTO),
+    icone = (if output then 2 else 1);
+edon
+
+node Boolean_Boolean_intermediate
+  flow 
+    icone:[1,2]:private;
+    O:bool:out;
+    I:bool:in;
+  assert 
+    icone = case { 
+      I : 1,
+      else 2
+    },
+    O = I;
+edon
+
+node Boolean_Boolean_and2
+  flow 
+    O:bool:out;
+    I1:bool:in;
+    I2:bool:in;
+  assert 
+    O = (I1 and I2);
+edon
+
+node Quadcopter_Observers_ErroneousControlOfOneHelix
+  flow 
+    icone:[1,2]:private;
+    in1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:bool:out;
+  assert 
+    output = ((((in1 = ERRONEOUS) or (in2 = ERRONEOUS)) or (in3 = ERRONEOUS)) or (in4 = ERRONEOUS)),
+    icone = (if output then 2 else 1);
+edon
+
+node Quadcopter_Observers_TotalLossOfHelixesControl
+  flow 
+    icone:[1,2]:private;
+    in1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:bool:out;
+  assert 
+    output = ((((in1 = LOST) and (in2 = LOST)) and (in3 = LOST)) and (in4 = LOST)),
+    icone = (if output then 2 else 1);
+edon
+
+node Quadcopter_Observers_LossOfAtMost3HelixesControl
+  flow 
+    icone:[1,2]:private;
+    in1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    in4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:bool:out;
+  assert 
+    output = ((((((((in1 = LOST) and (in2 # ERRONEOUS)) and (in3 # ERRONEOUS)) and (in4 # ERRONEOUS)) or ((((in2 = LOST) and (in1 # ERRONEOUS)) and (in3 # ERRONEOUS)) and (in4 # ERRONEOUS))) or ((((in3 = LOST) and (in2 # ERRONEOUS)) and (in1 # ERRONEOUS)) and (in4 # ERRONEOUS))) or ((((in4 = LOST) and (in2 # ERRONEOUS)) and (in3 # ERRONEOUS)) and (in1 # ERRONEOUS))) and (not ((((in1 = LOST) and (in2 = LOST)) and (in3 = LOST)) and (in4 = LOST)))),
+    icone = (if output then 2 else 1);
+edon
+
+node Functions_BasicOperators_PerfectPresenceSelectorOK
+  flow 
+    icone:[1,2]:private;
+    input:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+    condition:Functions_BasicFunctions_Presence:in;
+  assert 
+    icone = (if (condition = PRESENT) then 2 else 1),
+    output = (if (condition = PRESENT) then OK else input);
+edon
+
+node Functions_BasicFunctions_AbsentPresentFunction
+  flow 
+    icone:[1,2]:private;
+    input:Functions_BasicFunctions_Presence:in;
+    output:Functions_BasicFunctions_Presence:out;
+  state 
+    status:{LOST, OK};
+  event 
+    fail_loss;
+  trans 
+    (status = OK) |- fail_loss -> status := LOST;
+  assert 
+    icone = case { 
+      (status = OK) : 1,
+      else 2
+    },
+    output = case { 
+      (status = OK) : input,
+      else ABSENT
+    };
+  init 
+    status := OK;
+  extern 
+    law <event fail_loss> = exponential(1.0E-6);
+edon
+
+node Functions_BasicOperators_PerfectPresenceSelectorLOSS
+  flow 
+    icone:[1,2]:private;
+    input:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+    condition:Functions_BasicFunctions_Presence:in;
+  assert 
+    icone = (if (condition = ABSENT) then 1 else 2),
+    output = (if (condition = PRESENT) then LOST else input);
+edon
+
+node Functions_BasicFunctions_SourcePresenceFunction
+  flow 
+    icone:[1,2]:private;
+    output:Functions_BasicFunctions_Presence:out;
+  state 
+    status:Functions_BasicFunctions_Presence;
+  event 
+    fail_inadv;
+  trans 
+    (status = ABSENT) |- fail_inadv -> status := PRESENT;
+  assert 
+    icone = case { 
+      (status = ABSENT) : 1,
+      else 2
+    },
+    output = status;
+  init 
+    status := ABSENT;
+  extern 
+    law <event fail_inadv> = constant(1.0E-5);
+edon
+
+node Functions_BasicOperators_Choice
+  flow 
+    icone:[1,2]:private;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+    input_1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    input_2:Functions_BasicFunctions_BasicFunctionStatus:in;
+  assert 
+    icone = (if (input_2 = ERRONEOUS) then 2 else 1),
+    output = (if (input_2 = ERRONEOUS) then ERRONEOUS else input_1);
+edon
+
+node Functions_BasicOperators_transtypageMode
+  flow 
+    icone:[1,2]:private;
+    O:Functions_BasicFunctions_ModeSelection_ErroneousLost:out;
+    I:Functions_BasicFunctions_ModeSelection:in;
+  assert 
+    icone = case { 
+      (I = AUTO) : 1,
+      else 2
+    },
+    O = (if (I = AUTO) then AUTO else MANUAL);
+edon
+
+node Functions_BasicFunctions_ErroneousLostModeSelector
+  flow 
+    icone:[1,2]:private;
+    outputMode:Functions_BasicFunctions_ModeSelection_ErroneousLost:out;
+    inputMode:Functions_BasicFunctions_ModeSelection_ErroneousLost:in;
+  state 
+    status:{LOSS, OK, STUCK_AUTO, STUCK_MAN, UNDEF};
+  event 
+    stuck_auto,
+    stuck_manual,
+    OscillatoryModeSelection,
+    fail_loss;
+  trans 
+    (status = OK) |- stuck_auto -> status := STUCK_AUTO;
+    (status = OK) |- stuck_manual -> status := STUCK_MAN;
+    (status = OK) |- OscillatoryModeSelection -> status := UNDEF;
+    (status = OK) |- fail_loss -> status := LOSS;
+  assert 
+    outputMode = case { 
+      ((status = OK) and (inputMode = AUTO)) : AUTO,
+      ((status = OK) and (inputMode = MANUAL)) : MANUAL,
+      ((status = OK) and (inputMode = ERRONEOUS)) : ERRONEOUS,
+      (status = LOSS) : LOST,
+      (status = STUCK_AUTO) : AUTO,
+      (status = UNDEF) : ERRONEOUS,
+      else MANUAL
+    },
+    icone = case { 
+      (outputMode = AUTO) : 1,
+      else 2
+    };
+  init 
+    status := OK;
+  extern 
+    law <event stuck_auto> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event stuck_auto>) = 9.877E8;
+    law <event stuck_manual> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event stuck_manual>) = 9.877E8;
+    law <event OscillatoryModeSelection> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event OscillatoryModeSelection>) = 9.877E8;
+    attribute DassaultSpecialCtrlPeriod(<event fail_loss>) = 9.877E8;
+edon
+
+node Functions_BasicFunctions_ErroneousLostPresentModeSelector
+  flow 
+    icone:[1,2]:private;
+    outputMode:Functions_BasicFunctions_ModeSelection_ErroneousLost:out;
+    inputMode:Functions_BasicFunctions_ModeSelection_ErroneousLost:in;
+    ManualConsigns:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MissionCompleted:Functions_BasicFunctions_Presence:in;
+  state 
+    status:{LOSS, OK, STUCK_AUTO, STUCK_MAN, UNDEF};
+  event 
+    stuck_auto,
+    stuck_manual,
+    OscillatoryModeSelection,
+    fail_loss;
+  trans 
+    (status = OK) |- stuck_auto -> status := STUCK_AUTO;
+    (status = OK) |- stuck_manual -> status := STUCK_MAN;
+    (status = OK) |- OscillatoryModeSelection -> status := UNDEF;
+    (status = OK) |- fail_loss -> status := LOSS;
+  assert 
+    outputMode = case { 
+      ((status = OK) and ((ManualConsigns # LOST) or (MissionCompleted = PRESENT))) : MANUAL,
+      ((status = OK) and (inputMode = AUTO)) : AUTO,
+      ((status = OK) and (inputMode = MANUAL)) : MANUAL,
+      ((status = OK) and (inputMode = ERRONEOUS)) : ERRONEOUS,
+      ((status = OK) and (inputMode = LOST)) : MANUAL,
+      (status = STUCK_AUTO) : AUTO,
+      (status = STUCK_MAN) : MANUAL,
+      (status = UNDEF) : ERRONEOUS,
+      else LOST
+    },
+    icone = case { 
+      (outputMode = AUTO) : 1,
+      else 2
+    };
+  init 
+    status := OK;
+  extern 
+    law <event stuck_auto> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event stuck_auto>) = 9.877E8;
+    law <event stuck_manual> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event stuck_manual>) = 9.877E8;
+    law <event OscillatoryModeSelection> = exponential(0.001);
+    attribute DassaultSpecialCtrlPeriod(<event OscillatoryModeSelection>) = 9.877E8;
+    attribute DassaultSpecialCtrlPeriod(<event fail_loss>) = 9.877E8;
+edon
+
+node Functions_BasicFunctions_FaultyManualModeSelector_LossType
+  flow 
+    icone:[1,2]:private;
+    outputMode:Functions_BasicFunctions_ModeSelection:out;
+    inputMode:Functions_BasicFunctions_ModeSelection_ErroneousLost:in;
+    FlightPlanInterruption:Functions_BasicFunctions_Presence:out;
+  state 
+    status:{OK, STUCK_AUTO, STUCK_MANUAL};
+  event 
+    stuck_auto,
+    stuck_manual;
+  trans 
+    (status = OK) |- stuck_auto -> status := STUCK_AUTO;
+    (status = OK) |- stuck_manual -> status := STUCK_MANUAL;
+  assert 
+    outputMode = case { 
+      ((status = OK) and ((inputMode = ERRONEOUS) or (inputMode = LOST))) : MANUAL,
+      ((status = OK) and (inputMode = AUTO)) : AUTO,
+      ((status = OK) and (inputMode = MANUAL)) : MANUAL,
+      (status = STUCK_AUTO) : AUTO,
+      else MANUAL
+    },
+    icone = case { 
+      (outputMode = AUTO) : 1,
+      else 2
+    },
+    FlightPlanInterruption = case { 
+      ((status = OK) and ((inputMode = ERRONEOUS) or (inputMode = LOST))) : PRESENT,
+      ((status = OK) and (inputMode = AUTO)) : ABSENT,
+      ((status = OK) and (inputMode = MANUAL)) : PRESENT,
+      (status = STUCK_AUTO) : ABSENT,
+      else PRESENT
+    };
+  init 
+    status := OK;
+  extern 
+    attribute DassaultSpecialCtrlPeriod(<event stuck_auto>) = 9.877E8;
+    attribute DassaultSpecialCtrlPeriod(<event stuck_manual>) = 9.877E8;
+edon
+
+node Functions_BasicOperators_PerfectConditionalSelectorLOST
+  flow 
+    icone:[1,2]:private;
+    input:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+    condition:bool:in;
+  assert 
+    icone = (if condition then 2 else 1),
+    output = (if condition then LOST else input);
+edon
+
+node Boolean_Boolean_BooleanInOutFunction
+  flow 
+    icone:[1,3]:private;
+    input:bool:in;
+    output:bool:out;
+  state 
+    status:{OK, STUCK_FALSE, STUCK_TRUE};
+  event 
+    stuck_true,
+    stuck_false;
+  trans 
+    (status = OK) |- stuck_true -> status := STUCK_TRUE;
+    (status = OK) |- stuck_false -> status := STUCK_FALSE;
+  assert 
+    icone = case { 
+      (status = OK) : 1,
+      (status = STUCK_FALSE) : 3,
+      else 2
+    },
+    output = case { 
+      (status = OK) : input,
+      (status = STUCK_FALSE) : false,
+      else true
+    };
+  init 
+    status := OK;
+  extern 
+    attribute DassaultSpecialCtrlPeriod(<event stuck_true>) = 9.877E8;
+    attribute DassaultSpecialCtrlPeriod(<event stuck_false>) = 9.877E8;
+edon
+
+node Functions_BasicFunctions_InOutPresentFunction
+  flow 
+    icone:[1,3]:private;
+    input:Functions_BasicFunctions_Presence:in;
+    output:Functions_BasicFunctions_BasicFunctionStatus:out;
+  state 
+    status:Functions_BasicFunctions_BasicFunctionStatus;
+  event 
+    fail_loss,
+    fail_error;
+  trans 
+    (status = OK) |- fail_loss -> status := LOST;
+    (status = OK) |- fail_error -> status := ERRONEOUS;
+  assert 
+    icone = case { 
+      (status = OK) : 1,
+      (status = LOST) : 2,
+      else 3
+    },
+    output = case { 
+      (status = OK) : (if (input = PRESENT) then OK else LOST),
+      else status
+    };
+  init 
+    status := OK;
+  extern 
+    law <event fail_loss> = constant(1.0E-4);
+    law <event fail_error> = constant(1.0E-5);
+edon
+
+node eq_AIDASystem_Functions_SF232_5_ControlAttitude
+  flow 
+    icone:[1,3]:private;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AttitudeAPConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    PitchRollConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    YawConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    APEngagement:Functions_BasicFunctions_ModeSelection:in;
+    P:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    AND3:Functions_BasicOperators_AND;
+    ControlAttitudeState:Functions_BasicFunctions_InOutFunction;
+    SF232_SelectAttitudeConsign:Functions_BasicOperators_ErrConditionalSelector_2;
+    AND2:Functions_BasicOperators_AND;
+    AND1:Functions_BasicOperators_AND;
+  assert 
+    icone = (if (ControlAttitudeState.status = OK) then 1 else (if (ControlAttitudeState.status = LOST) then 3 else 2)),
+    P = ControlAttitudeState.output,
+    AND3.input_1 = PitchRollConsign,
+    AND3.input_2 = YawConsign,
+    ControlAttitudeState.input = SF232_SelectAttitudeConsign.output,
+    SF232_SelectAttitudeConsign.inputAUTO = AND2.output,
+    SF232_SelectAttitudeConsign.inputMANUAL = AND1.output,
+    SF232_SelectAttitudeConsign.condition = APEngagement,
+    AND2.input_1 = AttitudeAPConsign,
+    AND2.input_2 = Attitude,
+    AND1.input_1 = AND3.output,
+    AND1.input_2 = Attitude;
+edon
+
+node eq_AIDASystem_Functions_SF242_3_ControlAltitude
+  flow 
+    icone:[1,3]:private;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AltitudeConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    T_AP:Functions_BasicFunctions_BasicFunctionStatus:in;
+    APEngagement:Functions_BasicFunctions_ModeSelection:in;
+    T:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    ControlAltitudeState:Functions_BasicFunctions_InOutFunction;
+    SF243_SelectTotalThrustConsign:Functions_BasicOperators_ErrConditionalSelector_2;
+    AND2:Functions_BasicOperators_AND;
+    AND1:Functions_BasicOperators_AND;
+  assert 
+    icone = (if (ControlAltitudeState.status = OK) then 1 else (if (ControlAltitudeState.status = LOST) then 3 else 2)),
+    T = ControlAltitudeState.output,
+    ControlAltitudeState.input = SF243_SelectTotalThrustConsign.output,
+    SF243_SelectTotalThrustConsign.inputAUTO = T_AP,
+    SF243_SelectTotalThrustConsign.inputMANUAL = AND2.output,
+    SF243_SelectTotalThrustConsign.condition = APEngagement,
+    AND2.input_1 = AltitudeConsign,
+    AND2.input_2 = AND1.output,
+    AND1.input_1 = Altitude,
+    AND1.input_2 = Attitude;
+edon
+
+node eq_AIDASystem_Functions_SF75_DisableDroneMotor
+  flow 
+    icone:[1,2]:private;
+    Motor1Runaway:bool:in;
+    Motor2Runaway:bool:in;
+    Motor3Runaway:bool:in;
+    Motor4Runaway:bool:in;
+    AttitudeFailureDetected:bool:in;
+    AltitudeFailureDetected:bool:in;
+    MotorConsignFailureDetected:bool:in;
+    MotorDisabled^Motor1:bool:out;
+    MotorDisabled^Motor2:bool:out;
+    MotorDisabled^Motor3:bool:out;
+    MotorDisabled^Motor4:bool:out;
+  sub 
+    FMPropagation4:Functions_BasicOperators_ANDBoolErrLost;
+    OR4:Boolean_Boolean_or4;
+    OR3:Boolean_Boolean_or4;
+    FMPropagation3:Functions_BasicOperators_ANDBoolErrLost;
+    FMPropagation2:Functions_BasicOperators_ANDBoolErrLost;
+    OR2:Boolean_Boolean_or4;
+    OR1:Boolean_Boolean_or4;
+    FailureModesOfSF74:Functions_BasicFunctions_SourceFunction;
+    FMPropagation1:Functions_BasicOperators_ANDBoolErrLost;
+  assert 
+    icone = case { 
+      (FailureModesOfSF74.status = OK) : 1,
+      else 2
+    },
+    MotorDisabled^Motor1 = FMPropagation1.output,
+    MotorDisabled^Motor2 = FMPropagation2.output,
+    MotorDisabled^Motor3 = FMPropagation3.output,
+    MotorDisabled^Motor4 = FMPropagation4.output,
+    FMPropagation4.input = OR4.O,
+    FMPropagation4.failurePropagation = FailureModesOfSF74.output,
+    OR4.I1 = Motor4Runaway,
+    OR4.I2 = AltitudeFailureDetected,
+    OR4.I3 = AttitudeFailureDetected,
+    OR4.I4 = MotorConsignFailureDetected,
+    OR3.I1 = MotorConsignFailureDetected,
+    OR3.I2 = AttitudeFailureDetected,
+    OR3.I3 = AltitudeFailureDetected,
+    OR3.I4 = Motor3Runaway,
+    FMPropagation3.input = OR3.O,
+    FMPropagation3.failurePropagation = FailureModesOfSF74.output,
+    FMPropagation2.input = OR2.O,
+    FMPropagation2.failurePropagation = FailureModesOfSF74.output,
+    OR2.I1 = MotorConsignFailureDetected,
+    OR2.I2 = AttitudeFailureDetected,
+    OR2.I3 = AltitudeFailureDetected,
+    OR2.I4 = Motor2Runaway,
+    OR1.I1 = MotorConsignFailureDetected,
+    OR1.I2 = AttitudeFailureDetected,
+    OR1.I3 = AltitudeFailureDetected,
+    OR1.I4 = Motor1Runaway,
+    FMPropagation1.input = OR1.O,
+    FMPropagation1.failurePropagation = FailureModesOfSF74.output;
+edon
+
+node eq_AIDASystem_Functions_SF7_MonitorDroneControl
+  flow 
+    MotorRatesMeasured^MotorRate1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Motor1Runaway:bool:out;
+    Motor2Runaway:bool:out;
+    Motor3Runaway:bool:out;
+    Motor4Runaway:bool:out;
+  sub 
+    MonitorMotorRate4:Functions_BasicOperators_Comparator;
+    MonitorMotorRate3:Functions_BasicOperators_Comparator;
+    MonitorMotorRate2:Functions_BasicOperators_Comparator;
+    MonitorMotorRate1:Functions_BasicOperators_Comparator;
+  assert 
+    Motor1Runaway = MonitorMotorRate1.output,
+    Motor2Runaway = MonitorMotorRate2.output,
+    Motor3Runaway = MonitorMotorRate3.output,
+    Motor4Runaway = MonitorMotorRate4.output,
+    MonitorMotorRate4.input1 = MotorRatesMeasured^MotorRate4,
+    MonitorMotorRate4.input2 = MotorRate,
+    MonitorMotorRate3.input1 = MotorRatesMeasured^MotorRate3,
+    MonitorMotorRate3.input2 = MotorRate,
+    MonitorMotorRate2.input1 = MotorRatesMeasured^MotorRate2,
+    MonitorMotorRate2.input2 = MotorRate,
+    MonitorMotorRate1.input1 = MotorRatesMeasured^MotorRate1,
+    MonitorMotorRate1.input2 = MotorRate;
+edon
+
+node eq_AIDASystem_Functions_SF421_RunFlightPlan
+  flow 
+    Time:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Position:Functions_BasicFunctions_BasicFunctionStatus:in;
+    FlightPlan:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Progress:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MissionCompleted:Functions_BasicFunctions_Presence:out;
+    FlightPlanInterruption:Functions_BasicFunctions_Presence:in;
+  sub 
+    SF421_FlightPlanInterruption:Functions_BasicOperators_PerfectPresenceSelectorLOSS;
+    SF421_MissionCompleted:Functions_BasicFunctions_SourcePresenceFunction;
+    SF421_Compute:Functions_BasicFunctions_InOutFunction;
+    SF421_Choice:Functions_BasicOperators_Choice;
+    SF421_AND1:Functions_BasicOperators_AND;
+  assert 
+    Progress = SF421_FlightPlanInterruption.output,
+    MissionCompleted = SF421_MissionCompleted.output,
+    SF421_FlightPlanInterruption.input = SF421_Compute.output,
+    SF421_FlightPlanInterruption.condition = FlightPlanInterruption,
+    SF421_Compute.input = SF421_Choice.output,
+    SF421_Choice.input_1 = SF421_AND1.output,
+    SF421_Choice.input_2 = FlightPlan,
+    SF421_AND1.input_1 = Time,
+    SF421_AND1.input_2 = Position;
+edon
+
+node eq_AIDASystem_Functions_SF64_DisplayDroneFollowUpData
+  flow 
+    input_ControlMode:Functions_BasicFunctions_ModeSelection:in;
+    input_FlightPlanProgress:Functions_BasicFunctions_BasicFunctionStatus:in;
+    output_ControlMode:Functions_BasicFunctions_ModeSelection:out;
+    output_FlightPlanProgress:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF64_FlightPlanProgress:Functions_BasicFunctions_InOutFunction;
+    SF64_ControlMode:Functions_BasicFunctions_InOutModeFunction;
+  assert 
+    output_ControlMode = SF64_ControlMode.outputMode,
+    output_FlightPlanProgress = SF64_FlightPlanProgress.output,
+    SF64_FlightPlanProgress.input = input_FlightPlanProgress,
+    SF64_ControlMode.inputMode = input_ControlMode;
+edon
+
+node eq_AIDASystem_Functions_SF73_ControlAttitudeAndAltitudeMON
+  flow 
+    icone:[1,2]:private;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    YawConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    PitchRollConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AltitudeConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AttitudeAPConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AltitudeAPConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    APEngagement:Functions_BasicFunctions_ModeSelection:in;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF733_6_ControlAttitudeMON:eq_AIDASystem_Functions_SF232_5_ControlAttitude;
+    SF731_2_ControlAltitudeMON:eq_AIDASystem_Functions_SF242_3_ControlAltitude;
+    SF737_AllNeeded:Functions_BasicOperators_AND;
+    SF737_8_ControlThrust:Functions_BasicFunctions_InOutFunction;
+  assert 
+    icone = case { 
+      (((SF737_8_ControlThrust.status = OK) and (SF731_2_ControlAltitudeMON.ControlAltitudeState.status = OK)) and (SF733_6_ControlAttitudeMON.ControlAttitudeState.status = OK)) : 1,
+      else 2
+    },
+    MotorRate = SF737_8_ControlThrust.output,
+    SF733_6_ControlAttitudeMON.Attitude = Attitude,
+    SF733_6_ControlAttitudeMON.AttitudeAPConsign = AttitudeAPConsign,
+    SF733_6_ControlAttitudeMON.PitchRollConsign = PitchRollConsign,
+    SF733_6_ControlAttitudeMON.YawConsign = YawConsign,
+    SF733_6_ControlAttitudeMON.APEngagement = APEngagement,
+    SF731_2_ControlAltitudeMON.Altitude = Altitude,
+    SF731_2_ControlAltitudeMON.Attitude = Attitude,
+    SF731_2_ControlAltitudeMON.AltitudeConsign = AltitudeConsign,
+    SF731_2_ControlAltitudeMON.T_AP = AltitudeAPConsign,
+    SF731_2_ControlAltitudeMON.APEngagement = APEngagement,
+    SF737_AllNeeded.input_1 = SF731_2_ControlAltitudeMON.T,
+    SF737_AllNeeded.input_2 = SF733_6_ControlAttitudeMON.P,
+    SF737_8_ControlThrust.input = SF737_AllNeeded.output;
+edon
+
+node eq_AIDASystem_Functions_SF74_MonitorParameters
+  flow 
+    icone:[1,2]:private;
+    MotorRateMON:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AltitudeMON:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AttitudeMON:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRateMeasured^MotorRate1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRateMeasured^MotorRate2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRateMeasured^MotorRate3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRateMeasured^MotorRate4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorsDisabled^Motor1:bool:out;
+    MotorsDisabled^Motor2:bool:out;
+    MotorsDisabled^Motor3:bool:out;
+    MotorsDisabled^Motor4:bool:out;
+  sub 
+    SF745_DisableDroneMotor:eq_AIDASystem_Functions_SF75_DisableDroneMotor;
+    SF744_MonitorMotorRate:eq_AIDASystem_Functions_SF7_MonitorDroneControl;
+    SF743_MonitorMotorConsign:Functions_BasicOperators_Comparator;
+    SF742_MonitorAltitude:Functions_BasicOperators_Comparator;
+    SF741_MonitorAttitude:Functions_BasicOperators_Comparator;
+  assert 
+    icone = case { 
+      (SF745_DisableDroneMotor.FailureModesOfSF74.status = OK) : 1,
+      else 2
+    },
+    MotorsDisabled^Motor1 = SF745_DisableDroneMotor.MotorDisabled^Motor1,
+    MotorsDisabled^Motor2 = SF745_DisableDroneMotor.MotorDisabled^Motor2,
+    MotorsDisabled^Motor3 = SF745_DisableDroneMotor.MotorDisabled^Motor3,
+    MotorsDisabled^Motor4 = SF745_DisableDroneMotor.MotorDisabled^Motor4,
+    SF745_DisableDroneMotor.Motor1Runaway = SF744_MonitorMotorRate.Motor1Runaway,
+    SF745_DisableDroneMotor.Motor2Runaway = SF744_MonitorMotorRate.Motor2Runaway,
+    SF745_DisableDroneMotor.Motor3Runaway = SF744_MonitorMotorRate.Motor3Runaway,
+    SF745_DisableDroneMotor.Motor4Runaway = SF744_MonitorMotorRate.Motor4Runaway,
+    SF745_DisableDroneMotor.AttitudeFailureDetected = SF741_MonitorAttitude.output,
+    SF745_DisableDroneMotor.AltitudeFailureDetected = SF742_MonitorAltitude.output,
+    SF745_DisableDroneMotor.MotorConsignFailureDetected = SF743_MonitorMotorConsign.output,
+    SF744_MonitorMotorRate.MotorRatesMeasured^MotorRate1 = MotorRateMeasured^MotorRate1,
+    SF744_MonitorMotorRate.MotorRatesMeasured^MotorRate2 = MotorRateMeasured^MotorRate2,
+    SF744_MonitorMotorRate.MotorRatesMeasured^MotorRate3 = MotorRateMeasured^MotorRate3,
+    SF744_MonitorMotorRate.MotorRatesMeasured^MotorRate4 = MotorRateMeasured^MotorRate4,
+    SF744_MonitorMotorRate.MotorRate = MotorRate,
+    SF743_MonitorMotorConsign.input1 = MotorRate,
+    SF743_MonitorMotorConsign.input2 = MotorRateMON,
+    SF742_MonitorAltitude.input1 = Altitude,
+    SF742_MonitorAltitude.input2 = AltitudeMON,
+    SF741_MonitorAttitude.input1 = Attitude,
+    SF741_MonitorAttitude.input2 = AttitudeMON;
+edon
+
+node eq_AIDASystem_Functions_SF42_RunAutomaticControl
+  flow 
+    FlightPlan:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Position:Functions_BasicFunctions_BasicFunctionStatus:in;
+    FlightPlanProgress:Functions_BasicFunctions_BasicFunctionStatus:out;
+    AutomaticPayloadControl:Functions_BasicFunctions_BasicFunctionStatus:out;
+    SpeedConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    PositionConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    PilotControlConsigns:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Time:Functions_BasicFunctions_BasicFunctionStatus:in;
+    FlightPlanInterruption:Functions_BasicFunctions_Presence:in;
+    MissionCompleted:Functions_BasicFunctions_Presence:out;
+  sub 
+    SF423_SelectAutomaticPayloadControl:Functions_BasicOperators_AND;
+    SF422_RunSpeedControl:Functions_BasicFunctions_InOutFunction;
+    SF421_RunFlightPlan:eq_AIDASystem_Functions_SF421_RunFlightPlan;
+  assert 
+    FlightPlanProgress = SF421_RunFlightPlan.Progress,
+    AutomaticPayloadControl = SF423_SelectAutomaticPayloadControl.output,
+    SpeedConsign = SF422_RunSpeedControl.output,
+    PositionConsign = SF421_RunFlightPlan.Progress,
+    MissionCompleted = SF421_RunFlightPlan.MissionCompleted,
+    SF423_SelectAutomaticPayloadControl.input_1 = SF421_RunFlightPlan.Progress,
+    SF423_SelectAutomaticPayloadControl.input_2 = SF422_RunSpeedControl.output,
+    SF422_RunSpeedControl.input = PilotControlConsigns,
+    SF421_RunFlightPlan.Time = Time,
+    SF421_RunFlightPlan.Position = Position,
+    SF421_RunFlightPlan.FlightPlan = FlightPlan,
+    SF421_RunFlightPlan.FlightPlanInterruption = FlightPlanInterruption;
+edon
+
+node eq_AIDASystem_Functions_SF44_AcquirePilotControlConsignAndMode
+  flow 
+    AcquiredPilotControlConsigns:Functions_BasicFunctions_BasicFunctionStatus:out;
+    AcquiredPilotControlMode:Functions_BasicFunctions_ModeSelection_ErroneousLost:out;
+    PilotControlMode:Functions_BasicFunctions_ModeSelection:in;
+  sub 
+    AcquireControlConsigns:Functions_BasicFunctions_SourceFunction;
+    transtypage:Functions_BasicOperators_transtypageMode;
+    AcquireControlMode:Functions_BasicFunctions_ErroneousLostModeSelector;
+  assert 
+    AcquiredPilotControlConsigns = AcquireControlConsigns.output,
+    AcquiredPilotControlMode = AcquireControlMode.outputMode,
+    transtypage.I = PilotControlMode,
+    AcquireControlMode.inputMode = transtypage.O;
+edon
+
+node eq_AIDASystem_Functions_SF43_SelectControlMode
+  flow 
+    icone:[1,2]:private;
+    PilotManualControl:Functions_BasicFunctions_ModeSelection_ErroneousLost:in;
+    IndicatedMode:Functions_BasicFunctions_ModeSelection:out;
+    APEngagement:Functions_BasicFunctions_ModeSelection:out;
+    ManualConsigns:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MissionCompleted:Functions_BasicFunctions_Presence:in;
+    FlightPlanInterruption:Functions_BasicFunctions_Presence:out;
+  sub 
+    SF431_SelectControlMode:Functions_BasicFunctions_ErroneousLostPresentModeSelector;
+    SF433_IndicateControlMode:Functions_BasicFunctions_InOutModeFunction;
+    SF432_PassivateEngagementOscillation:Functions_BasicFunctions_FaultyManualModeSelector_LossType;
+  assert 
+    APEngagement = SF432_PassivateEngagementOscillation.outputMode,
+    icone = case { 
+      (APEngagement = AUTO) : 1,
+      else 2
+    },
+    IndicatedMode = SF433_IndicateControlMode.outputMode,
+    FlightPlanInterruption = SF432_PassivateEngagementOscillation.FlightPlanInterruption,
+    SF431_SelectControlMode.inputMode = PilotManualControl,
+    SF431_SelectControlMode.ManualConsigns = ManualConsigns,
+    SF431_SelectControlMode.MissionCompleted = MissionCompleted,
+    SF433_IndicateControlMode.inputMode = SF432_PassivateEngagementOscillation.outputMode,
+    SF432_PassivateEngagementOscillation.inputMode = SF431_SelectControlMode.outputMode;
+edon
+
+node eq_AIDASystem_Functions_SF1i_ControlHelix_2
+  flow 
+    MotorDisabled:bool:in;
+    MotorRateMeasured:Functions_BasicFunctions_BasicFunctionStatus:out;
+    ThrustAndTorque:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:in;
+  sub 
+    SF1i1_5_PerfectSelectorLOST:Functions_BasicOperators_PerfectConditionalSelectorLOST;
+    SF1i1_5_CreateMotionAndMeasure:Functions_BasicFunctions_InOutFunction;
+    SF1i6_DepowerMotor:Boolean_Boolean_BooleanInOutFunction;
+    SF1i3_CreateThrustAndTorque:Functions_BasicFunctions_InOutFunction;
+  assert 
+    MotorRateMeasured = SF1i1_5_CreateMotionAndMeasure.output,
+    ThrustAndTorque = SF1i3_CreateThrustAndTorque.output,
+    SF1i1_5_PerfectSelectorLOST.input = SF1i1_5_CreateMotionAndMeasure.output,
+    SF1i1_5_PerfectSelectorLOST.condition = SF1i6_DepowerMotor.output,
+    SF1i1_5_CreateMotionAndMeasure.input = MotorRate,
+    SF1i6_DepowerMotor.input = MotorDisabled,
+    SF1i3_CreateThrustAndTorque.input = SF1i1_5_PerfectSelectorLOST.output;
+edon
+
+node eq_AIDASystem_Functions_SF21_ControlPosition
+  flow 
+    icone:[1,3]:private;
+    Position:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Speed:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    PositionConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    SpeedConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    AttitudeThrustAPConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF212_SelectSpeedConsign:Functions_BasicOperators_AND;
+    ControlPositionState:Functions_BasicFunctions_InOutFunction;
+    AND2:Functions_BasicOperators_AND;
+    AND1:Functions_BasicOperators_AND;
+    AND3:Functions_BasicOperators_AND;
+    AND4:Functions_BasicOperators_AND;
+  assert 
+    icone = (if (ControlPositionState.status = OK) then 1 else (if (ControlPositionState.status = LOST) then 3 else 2)),
+    AttitudeThrustAPConsign = ControlPositionState.output,
+    SF212_SelectSpeedConsign.input_1 = AND4.output,
+    SF212_SelectSpeedConsign.input_2 = AND3.output,
+    ControlPositionState.input = SF212_SelectSpeedConsign.output,
+    AND2.input_1 = Position,
+    AND2.input_2 = AND1.output,
+    AND1.input_1 = Speed,
+    AND1.input_2 = Attitude,
+    AND3.input_1 = PositionConsign,
+    AND3.input_2 = AND2.output,
+    AND4.input_1 = SpeedConsign,
+    AND4.input_2 = AND1.output;
+edon
+
+node eq_AIDASystem_Functions_SF33_ComputeDroneSpeed
+  flow 
+    icone:[1,2]:private;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Speed:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF331_FilmGround:Functions_BasicFunctions_SourceFunction;
+    SF332_AllNeeded:Functions_BasicOperators_AND;
+    SF332_ComputeSpeed:Functions_BasicFunctions_InOutFunction;
+  assert 
+    icone = case { 
+      ((SF331_FilmGround.status = OK) and (SF332_ComputeSpeed.status = OK)) : 1,
+      else 2
+    },
+    Speed = SF332_ComputeSpeed.output,
+    SF332_AllNeeded.input_1 = SF331_FilmGround.output,
+    SF332_AllNeeded.input_2 = Altitude,
+    SF332_ComputeSpeed.input = SF332_AllNeeded.output;
+edon
+
+node eq_AIDASystem_Functions_SF6_ManageMission
+  flow 
+    icone:[1,2]:private;
+    oFlightPlanProgress:Functions_BasicFunctions_BasicFunctionStatus:out;
+    iFlightPlanProgress:Functions_BasicFunctions_BasicFunctionStatus:in;
+    iFlightPlan:Functions_BasicFunctions_BasicFunctionStatus:in;
+    oFlightPlan:Functions_BasicFunctions_BasicFunctionStatus:out;
+    iDroneControlMode:Functions_BasicFunctions_ModeSelection:in;
+    oDroneControlMode:Functions_BasicFunctions_ModeSelection:out;
+  sub 
+    SF61_ComputeFlightPlanAndZone:Functions_BasicFunctions_InOutFunction;
+    SF64_DisplayDroneFollowUpData:eq_AIDASystem_Functions_SF64_DisplayDroneFollowUpData;
+  assert 
+    icone = case { 
+      (((SF61_ComputeFlightPlanAndZone.status = OK) and (SF64_DisplayDroneFollowUpData.SF64_ControlMode.status = OK)) and (SF64_DisplayDroneFollowUpData.SF64_FlightPlanProgress.status = OK)) : 1,
+      else 2
+    },
+    oFlightPlanProgress = SF64_DisplayDroneFollowUpData.output_FlightPlanProgress,
+    oFlightPlan = SF61_ComputeFlightPlanAndZone.output,
+    oDroneControlMode = SF64_DisplayDroneFollowUpData.output_ControlMode,
+    SF61_ComputeFlightPlanAndZone.input = iFlightPlan,
+    SF64_DisplayDroneFollowUpData.input_ControlMode = iDroneControlMode,
+    SF64_DisplayDroneFollowUpData.input_FlightPlanProgress = iFlightPlanProgress;
+edon
+
+node eq_AIDASystem_Functions_SF7_MonitorDroneControl_v042
+  flow 
+    icone:[1,2]:private;
+    APEngagement:Functions_BasicFunctions_ModeSelection:in;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorRatesMeasured^MotorRate4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    MotorDisabled^Motor1:bool:out;
+    MotorDisabled^Motor2:bool:out;
+    MotorDisabled^Motor3:bool:out;
+    MotorDisabled^Motor4:bool:out;
+    Consigns^AltitudeManualConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Consigns^YawManualConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Consigns^PitchRollManualConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Consigns^AltitudeAndAttitudeAPConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+  sub 
+    SF73_ControlAttitudeAndAltitudeMON:eq_AIDASystem_Functions_SF73_ControlAttitudeAndAltitudeMON;
+    SF71_ComputeAttitudeMON:Functions_BasicFunctions_SourceFunction;
+    SF72_ComputeAltitudeMON:Functions_BasicFunctions_InOutFunction;
+    SF74_MonitorParameters:eq_AIDASystem_Functions_SF74_MonitorParameters;
+  assert 
+    icone = case { 
+      ((((((SF74_MonitorParameters.SF745_DisableDroneMotor.FailureModesOfSF74.status = OK) and (SF71_ComputeAttitudeMON.status = OK)) and (SF72_ComputeAltitudeMON.status = OK)) and (SF73_ControlAttitudeAndAltitudeMON.SF737_8_ControlThrust.status = OK)) and (SF73_ControlAttitudeAndAltitudeMON.SF731_2_ControlAltitudeMON.ControlAltitudeState.status = OK)) and (SF73_ControlAttitudeAndAltitudeMON.SF733_6_ControlAttitudeMON.ControlAttitudeState.status = OK)) : 1,
+      else 2
+    },
+    MotorDisabled^Motor1 = SF74_MonitorParameters.MotorsDisabled^Motor1,
+    MotorDisabled^Motor2 = SF74_MonitorParameters.MotorsDisabled^Motor2,
+    MotorDisabled^Motor3 = SF74_MonitorParameters.MotorsDisabled^Motor3,
+    MotorDisabled^Motor4 = SF74_MonitorParameters.MotorsDisabled^Motor4,
+    SF73_ControlAttitudeAndAltitudeMON.Altitude = Altitude,
+    SF73_ControlAttitudeAndAltitudeMON.Attitude = Attitude,
+    SF73_ControlAttitudeAndAltitudeMON.YawConsign = Consigns^YawManualConsign,
+    SF73_ControlAttitudeAndAltitudeMON.PitchRollConsign = Consigns^PitchRollManualConsign,
+    SF73_ControlAttitudeAndAltitudeMON.AltitudeConsign = Consigns^AltitudeManualConsign,
+    SF73_ControlAttitudeAndAltitudeMON.AttitudeAPConsign = Consigns^AltitudeAndAttitudeAPConsign,
+    SF73_ControlAttitudeAndAltitudeMON.AltitudeAPConsign = Consigns^AltitudeAndAttitudeAPConsign,
+    SF73_ControlAttitudeAndAltitudeMON.APEngagement = APEngagement,
+    SF72_ComputeAltitudeMON.input = SF71_ComputeAttitudeMON.output,
+    SF74_MonitorParameters.MotorRateMON = SF73_ControlAttitudeAndAltitudeMON.MotorRate,
+    SF74_MonitorParameters.MotorRate = MotorRate,
+    SF74_MonitorParameters.Altitude = Altitude,
+    SF74_MonitorParameters.AltitudeMON = SF72_ComputeAltitudeMON.output,
+    SF74_MonitorParameters.Attitude = Attitude,
+    SF74_MonitorParameters.AttitudeMON = SF71_ComputeAttitudeMON.output,
+    SF74_MonitorParameters.MotorRateMeasured^MotorRate1 = MotorRatesMeasured^MotorRate1,
+    SF74_MonitorParameters.MotorRateMeasured^MotorRate2 = MotorRatesMeasured^MotorRate2,
+    SF74_MonitorParameters.MotorRateMeasured^MotorRate3 = MotorRatesMeasured^MotorRate3,
+    SF74_MonitorParameters.MotorRateMeasured^MotorRate4 = MotorRatesMeasured^MotorRate4;
+edon
+
+node eq_AIDASystem_Observers_Observer_v44
+  flow 
+    Thrust1:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Thrust2:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Thrust3:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Thrust4:Functions_BasicFunctions_BasicFunctionStatus:in;
+    APEngagement:Functions_BasicFunctions_ModeSelection:in;
+    PilotInconsistentControl:bool:in;
+    PilotManualControl:Functions_BasicFunctions_ModeSelection:in;
+    LostHelixesControl:bool:out;
+  sub 
+    PilotRequiresManualMode:Quadcopter_Observers_PilotRequiresManualMode;
+    LossOfSelectedManualModeFiltered:Boolean_Boolean_filter;
+    filter4:Boolean_Boolean_filter;
+    filter3:Boolean_Boolean_filter;
+    filter2:Boolean_Boolean_filter;
+    StuckModeManual:Quadcopter_Observers_StuckModeMAN_v03;
+    ControlledCrash:Boolean_Boolean_or2;
+    StuckModeAutoOrErr:Quadcopter_Observers_StuckMode_v03;
+    FC03_MAJ:Boolean_Boolean_intermediate;
+    TotalLossOfControl:Boolean_Boolean_and2;
+    UncontrolledCrashInAuthorizedArea:Boolean_Boolean_or2;
+    LossOfSelectedManualMode:Boolean_Boolean_and2;
+    UncontrolledCrashInNonAuthorizedArea:Boolean_Boolean_or2;
+    FC02_HAZ:Boolean_Boolean_intermediate;
+    FC01_CAT:Boolean_Boolean_intermediate;
+    ErroneousControlOfOneHelix:Quadcopter_Observers_ErroneousControlOfOneHelix;
+    TotalLossOfHelixesControl:Quadcopter_Observers_TotalLossOfHelixesControl;
+    LossOfAtMost3HelixesControl:Quadcopter_Observers_LossOfAtMost3HelixesControl;
+  assert 
+    LostHelixesControl = LossOfAtMost3HelixesControl.output,
+    PilotRequiresManualMode.input = PilotManualControl,
+    LossOfSelectedManualModeFiltered.filterCriterion = PilotInconsistentControl,
+    LossOfSelectedManualModeFiltered.input = LossOfSelectedManualMode.O,
+    filter4.filterCriterion = PilotInconsistentControl,
+    filter4.input = ControlledCrash.O,
+    filter3.filterCriterion = PilotInconsistentControl,
+    filter3.input = UncontrolledCrashInAuthorizedArea.O,
+    filter2.filterCriterion = PilotInconsistentControl,
+    filter2.input = UncontrolledCrashInNonAuthorizedArea.O,
+    StuckModeManual.PilotAPEngagementOrder = PilotManualControl,
+    StuckModeManual.AppliedAPEngagement = APEngagement,
+    ControlledCrash.I1 = PilotRequiresManualMode.output,
+    ControlledCrash.I2 = StuckModeManual.output,
+    StuckModeAutoOrErr.input = APEngagement,
+    FC03_MAJ.I = filter4.output,
+    TotalLossOfControl.I1 = LossOfAtMost3HelixesControl.output,
+    TotalLossOfControl.I2 = LossOfSelectedManualMode.O,
+    UncontrolledCrashInAuthorizedArea.I1 = TotalLossOfHelixesControl.output,
+    UncontrolledCrashInAuthorizedArea.I2 = LossOfAtMost3HelixesControl.output,
+    LossOfSelectedManualMode.I1 = StuckModeAutoOrErr.output,
+    LossOfSelectedManualMode.I2 = PilotRequiresManualMode.output,
+    UncontrolledCrashInNonAuthorizedArea.I1 = ErroneousControlOfOneHelix.output,
+    UncontrolledCrashInNonAuthorizedArea.I2 = TotalLossOfControl.O,
+    FC02_HAZ.I = filter3.output,
+    FC01_CAT.I = filter2.output,
+    ErroneousControlOfOneHelix.in1 = Thrust1,
+    ErroneousControlOfOneHelix.in2 = Thrust2,
+    ErroneousControlOfOneHelix.in3 = Thrust4,
+    ErroneousControlOfOneHelix.in4 = Thrust3,
+    TotalLossOfHelixesControl.in1 = Thrust1,
+    TotalLossOfHelixesControl.in2 = Thrust2,
+    TotalLossOfHelixesControl.in3 = Thrust4,
+    TotalLossOfHelixesControl.in4 = Thrust3,
+    LossOfAtMost3HelixesControl.in1 = Thrust1,
+    LossOfAtMost3HelixesControl.in2 = Thrust2,
+    LossOfAtMost3HelixesControl.in3 = Thrust4,
+    LossOfAtMost3HelixesControl.in4 = Thrust3;
+edon
+
+node eq_AIDASystem_Functions_SF5_MakeAndRecordVideo
+  flow 
+    icone:[1,2]:private;
+    ManualPayloadControl:Functions_BasicFunctions_Presence:in;
+    AutomaticPayloadControl:Functions_BasicFunctions_BasicFunctionStatus:in;
+    VideoFlux:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF51_SelectCameraControl:Functions_BasicOperators_PerfectPresenceSelectorOK;
+    SF55_AcquireManualPayloadControl:Functions_BasicFunctions_AbsentPresentFunction;
+    SF52_4_MakePhotosAndVideos:Functions_BasicFunctions_InOutFunction;
+  assert 
+    icone = case { 
+      ((SF55_AcquireManualPayloadControl.status = OK) and (SF52_4_MakePhotosAndVideos.status = OK)) : 1,
+      else 2
+    },
+    VideoFlux = SF52_4_MakePhotosAndVideos.output,
+    SF51_SelectCameraControl.input = AutomaticPayloadControl,
+    SF51_SelectCameraControl.condition = SF55_AcquireManualPayloadControl.output,
+    SF55_AcquireManualPayloadControl.input = ManualPayloadControl,
+    SF52_4_MakePhotosAndVideos.input = SF51_SelectCameraControl.output;
+edon
+
+node eq_AIDASystem_Functions_SF4_ControlDroneNavigation
+  flow 
+    Position:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Time:Functions_BasicFunctions_BasicFunctionStatus:in;
+    PositionConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    SpeedConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    FlightPlan:Functions_BasicFunctions_BasicFunctionStatus:in;
+    APEngagement:Functions_BasicFunctions_ModeSelection:out;
+    IndicatedMode:Functions_BasicFunctions_ModeSelection:out;
+    PilotManualControl:Functions_BasicFunctions_ModeSelection:in;
+    FlightPlanProgress:Functions_BasicFunctions_BasicFunctionStatus:out;
+    AutomaticPayloadControl:Functions_BasicFunctions_BasicFunctionStatus:out;
+    ManualConsigns:Functions_BasicFunctions_BasicFunctionStatus:in;
+  sub 
+    SF42_RunAutomaticControl:eq_AIDASystem_Functions_SF42_RunAutomaticControl;
+    SF44_AcquirePilotControlConsignAndMode:eq_AIDASystem_Functions_SF44_AcquirePilotControlConsignAndMode;
+    SF43_SelectControlMode:eq_AIDASystem_Functions_SF43_SelectControlMode;
+    SF41_AcquireAndStoreFlightPlan:Functions_BasicFunctions_InOutFunction;
+  assert 
+    PositionConsign = SF42_RunAutomaticControl.PositionConsign,
+    SpeedConsign = SF42_RunAutomaticControl.SpeedConsign,
+    APEngagement = SF43_SelectControlMode.APEngagement,
+    IndicatedMode = SF43_SelectControlMode.IndicatedMode,
+    FlightPlanProgress = SF42_RunAutomaticControl.FlightPlanProgress,
+    AutomaticPayloadControl = SF42_RunAutomaticControl.AutomaticPayloadControl,
+    SF42_RunAutomaticControl.FlightPlan = SF41_AcquireAndStoreFlightPlan.output,
+    SF42_RunAutomaticControl.Position = Position,
+    SF42_RunAutomaticControl.PilotControlConsigns = SF44_AcquirePilotControlConsignAndMode.AcquiredPilotControlConsigns,
+    SF42_RunAutomaticControl.Time = Time,
+    SF42_RunAutomaticControl.FlightPlanInterruption = SF43_SelectControlMode.FlightPlanInterruption,
+    SF44_AcquirePilotControlConsignAndMode.PilotControlMode = PilotManualControl,
+    SF43_SelectControlMode.PilotManualControl = SF44_AcquirePilotControlConsignAndMode.AcquiredPilotControlMode,
+    SF43_SelectControlMode.ManualConsigns = ManualConsigns,
+    SF43_SelectControlMode.MissionCompleted = SF42_RunAutomaticControl.MissionCompleted,
+    SF41_AcquireAndStoreFlightPlan.input = FlightPlan;
+edon
+
+node eq_AIDASystem_Functions_SF1_ControlDroneHelixes_2
+  flow 
+    MotorRatesMeasured^MotorRate1:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MotorRatesMeasured^MotorRate2:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MotorRatesMeasured^MotorRate3:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MotorRatesMeasured^MotorRate4:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:in;
+    ThrustAndTorque1:Functions_BasicFunctions_BasicFunctionStatus:out;
+    ThrustAndTorque2:Functions_BasicFunctions_BasicFunctionStatus:out;
+    ThrustAndTorque3:Functions_BasicFunctions_BasicFunctionStatus:out;
+    ThrustAndTorque4:Functions_BasicFunctions_BasicFunctionStatus:out;
+    MotorDisabled^Motor1:bool:in;
+    MotorDisabled^Motor2:bool:in;
+    MotorDisabled^Motor3:bool:in;
+    MotorDisabled^Motor4:bool:in;
+  sub 
+    SF14_ControlHelix4:eq_AIDASystem_Functions_SF1i_ControlHelix_2;
+    SF13_ControlHelix3:eq_AIDASystem_Functions_SF1i_ControlHelix_2;
+    SF12_ControlHelix2:eq_AIDASystem_Functions_SF1i_ControlHelix_2;
+    SF11_ControlHelix1:eq_AIDASystem_Functions_SF1i_ControlHelix_2;
+  assert 
+    MotorRatesMeasured^MotorRate1 = SF11_ControlHelix1.MotorRateMeasured,
+    MotorRatesMeasured^MotorRate2 = SF12_ControlHelix2.MotorRateMeasured,
+    MotorRatesMeasured^MotorRate3 = SF13_ControlHelix3.MotorRateMeasured,
+    MotorRatesMeasured^MotorRate4 = SF14_ControlHelix4.MotorRateMeasured,
+    ThrustAndTorque1 = SF11_ControlHelix1.ThrustAndTorque,
+    ThrustAndTorque2 = SF12_ControlHelix2.ThrustAndTorque,
+    ThrustAndTorque3 = SF13_ControlHelix3.ThrustAndTorque,
+    ThrustAndTorque4 = SF14_ControlHelix4.ThrustAndTorque,
+    SF14_ControlHelix4.MotorDisabled = MotorDisabled^Motor4,
+    SF14_ControlHelix4.MotorRate = MotorRate,
+    SF13_ControlHelix3.MotorDisabled = MotorDisabled^Motor3,
+    SF13_ControlHelix3.MotorRate = MotorRate,
+    SF12_ControlHelix2.MotorDisabled = MotorDisabled^Motor2,
+    SF12_ControlHelix2.MotorRate = MotorRate,
+    SF11_ControlHelix1.MotorDisabled = MotorDisabled^Motor1,
+    SF11_ControlHelix1.MotorRate = MotorRate;
+edon
+
+node eq_AIDASystem_Functions_SF2_ControlDroneAttitudeAndPosition
+  flow 
+    icone:[1,3]:private;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Position:Functions_BasicFunctions_BasicFunctionStatus:in;
+    Speed:Functions_BasicFunctions_BasicFunctionStatus:in;
+    PositionConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    SpeedConsign:Functions_BasicFunctions_BasicFunctionStatus:in;
+    APEngagement:Functions_BasicFunctions_ModeSelection:in;
+    MotorRate:Functions_BasicFunctions_BasicFunctionStatus:out;
+    DetectControlDronePosition:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Consigns^AltitudeManualConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Consigns^YawManualConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Consigns^PitchRollManualConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Consigns^AltitudeAndAttitudeAPConsign:Functions_BasicFunctions_BasicFunctionStatus:out;
+    PilotOrders:Functions_BasicFunctions_Presence:in;
+    ManualConsigns:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF22_AcquirePilotOrders:Functions_BasicFunctions_InOutPresentFunction;
+    SF231_ComputeYawConsign:Functions_BasicFunctions_InOutFunction;
+    SF241_ComputeAltitudeConsign:Functions_BasicFunctions_InOutFunction;
+    SF21_ControlPosition:eq_AIDASystem_Functions_SF21_ControlPosition;
+    SF232_5_ControlAttitude:eq_AIDASystem_Functions_SF232_5_ControlAttitude;
+    SF242_3_ControlAltitude:eq_AIDASystem_Functions_SF242_3_ControlAltitude;
+    SF25_AllNeeded:Functions_BasicOperators_AND;
+    SF25_ControlThrust:Functions_BasicFunctions_InOutFunction;
+  assert 
+    MotorRate = SF25_ControlThrust.output,
+    icone = (if (MotorRate = OK) then 1 else (if (MotorRate = LOST) then 3 else 2)),
+    DetectControlDronePosition = SF21_ControlPosition.AttitudeThrustAPConsign,
+    Consigns^AltitudeManualConsign = SF241_ComputeAltitudeConsign.output,
+    Consigns^YawManualConsign = SF231_ComputeYawConsign.output,
+    Consigns^PitchRollManualConsign = SF22_AcquirePilotOrders.output,
+    Consigns^AltitudeAndAttitudeAPConsign = SF21_ControlPosition.AttitudeThrustAPConsign,
+    ManualConsigns = SF22_AcquirePilotOrders.output,
+    SF22_AcquirePilotOrders.input = PilotOrders,
+    SF231_ComputeYawConsign.input = SF22_AcquirePilotOrders.output,
+    SF241_ComputeAltitudeConsign.input = SF22_AcquirePilotOrders.output,
+    SF21_ControlPosition.Position = Position,
+    SF21_ControlPosition.Speed = Speed,
+    SF21_ControlPosition.Attitude = Attitude,
+    SF21_ControlPosition.PositionConsign = PositionConsign,
+    SF21_ControlPosition.SpeedConsign = SpeedConsign,
+    SF232_5_ControlAttitude.Attitude = Attitude,
+    SF232_5_ControlAttitude.AttitudeAPConsign = SF21_ControlPosition.AttitudeThrustAPConsign,
+    SF232_5_ControlAttitude.PitchRollConsign = SF22_AcquirePilotOrders.output,
+    SF232_5_ControlAttitude.YawConsign = SF231_ComputeYawConsign.output,
+    SF232_5_ControlAttitude.APEngagement = APEngagement,
+    SF242_3_ControlAltitude.Altitude = Altitude,
+    SF242_3_ControlAltitude.Attitude = Attitude,
+    SF242_3_ControlAltitude.AltitudeConsign = SF241_ComputeAltitudeConsign.output,
+    SF242_3_ControlAltitude.T_AP = SF21_ControlPosition.AttitudeThrustAPConsign,
+    SF242_3_ControlAltitude.APEngagement = APEngagement,
+    SF25_AllNeeded.input_1 = SF242_3_ControlAltitude.T,
+    SF25_AllNeeded.input_2 = SF232_5_ControlAttitude.P,
+    SF25_ControlThrust.input = SF25_AllNeeded.output;
+edon
+
+node eq_AIDASystem_Functions_SF3_ComputeDronePositionAndSpeed
+  flow 
+    icone:[1,2]:private;
+    Altitude:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Attitude:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Position:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Speed:Functions_BasicFunctions_BasicFunctionStatus:out;
+    Time:Functions_BasicFunctions_BasicFunctionStatus:out;
+  sub 
+    SF34_ComputePositionAndTime:Functions_BasicFunctions_SourceFunction;
+    SF31_ComputeAttitude:Functions_BasicFunctions_SourceFunction;
+    SF33_ComputeDroneSpeed:eq_AIDASystem_Functions_SF33_ComputeDroneSpeed;
+    SF32_ComputeAltitude:Functions_BasicFunctions_InOutFunction;
+  assert 
+    icone = case { 
+      (((((SF31_ComputeAttitude.status = OK) and (SF32_ComputeAltitude.status = OK)) and (SF34_ComputePositionAndTime.status = OK)) and (SF33_ComputeDroneSpeed.SF331_FilmGround.status = OK)) and (SF33_ComputeDroneSpeed.SF332_ComputeSpeed.status = OK)) : 1,
+      else 2
+    },
+    Altitude = SF32_ComputeAltitude.output,
+    Attitude = SF31_ComputeAttitude.output,
+    Position = SF34_ComputePositionAndTime.output,
+    Speed = SF33_ComputeDroneSpeed.Speed,
+    Time = SF34_ComputePositionAndTime.output,
+    SF33_ComputeDroneSpeed.Altitude = SF32_ComputeAltitude.output,
+    SF32_ComputeAltitude.input = SF31_ComputeAttitude.output;
+edon
+
+node main
+  sub 
+    SF6:eq_AIDASystem_Functions_SF6_ManageMission;
+    EXT_Database_UploadPredefinedFlightZoneBoarders:Functions_BasicFunctions_SourceFunction;
+    EXT_PilotDetection:AIDASystem_Functions_Detection_v44;
+    SF7:eq_AIDASystem_Functions_SF7_MonitorDroneControl_v042;
+    FailureConditions:eq_AIDASystem_Observers_Observer_v44;
+    SF5:eq_AIDASystem_Functions_SF5_MakeAndRecordVideo;
+    SF4:eq_AIDASystem_Functions_SF4_ControlDroneNavigation;
+    SF1:eq_AIDASystem_Functions_SF1_ControlDroneHelixes_2;
+    SF2:eq_AIDASystem_Functions_SF2_ControlDroneAttitudeAndPosition;
+    SF3:eq_AIDASystem_Functions_SF3_ComputeDronePositionAndSpeed;
+  assert 
+    SF6.iFlightPlanProgress = SF4.FlightPlanProgress,
+    SF6.iFlightPlan = EXT_Database_UploadPredefinedFlightZoneBoarders.output,
+    SF6.iDroneControlMode = SF4.IndicatedMode,
+    EXT_PilotDetection.inputFlightPlan = SF6.oFlightPlanProgress,
+    EXT_PilotDetection.inputPosition = SF3.Position,
+    EXT_PilotDetection.inputSpeed = SF3.Speed,
+    EXT_PilotDetection.inputControlPosition = SF2.DetectControlDronePosition,
+    EXT_PilotDetection.inputLostHelixesControl = FailureConditions.LostHelixesControl,
+    EXT_PilotDetection.inputIndicatedMode = SF6.oDroneControlMode,
+    SF7.APEngagement = SF4.APEngagement,
+    SF7.Attitude = SF3.Attitude,
+    SF7.Altitude = SF3.Altitude,
+    SF7.MotorRate = SF2.MotorRate,
+    SF7.MotorRatesMeasured^MotorRate1 = SF1.MotorRatesMeasured^MotorRate1,
+    SF7.MotorRatesMeasured^MotorRate2 = SF1.MotorRatesMeasured^MotorRate2,
+    SF7.MotorRatesMeasured^MotorRate3 = SF1.MotorRatesMeasured^MotorRate3,
+    SF7.MotorRatesMeasured^MotorRate4 = SF1.MotorRatesMeasured^MotorRate4,
+    SF7.Consigns^AltitudeManualConsign = SF2.Consigns^AltitudeManualConsign,
+    SF7.Consigns^YawManualConsign = SF2.Consigns^YawManualConsign,
+    SF7.Consigns^PitchRollManualConsign = SF2.Consigns^PitchRollManualConsign,
+    SF7.Consigns^AltitudeAndAttitudeAPConsign = SF2.Consigns^AltitudeAndAttitudeAPConsign,
+    FailureConditions.Thrust1 = SF1.ThrustAndTorque1,
+    FailureConditions.Thrust2 = SF1.ThrustAndTorque2,
+    FailureConditions.Thrust3 = SF1.ThrustAndTorque3,
+    FailureConditions.Thrust4 = SF1.ThrustAndTorque4,
+    FailureConditions.APEngagement = SF4.APEngagement,
+    FailureConditions.PilotInconsistentControl = EXT_PilotDetection.PilotInconsistentControl,
+    FailureConditions.PilotManualControl = EXT_PilotDetection.PilotSelectedMode,
+    SF5.ManualPayloadControl = EXT_PilotDetection.ManualPayloadControl,
+    SF5.AutomaticPayloadControl = SF4.AutomaticPayloadControl,
+    SF4.Position = SF3.Position,
+    SF4.Time = SF3.Time,
+    SF4.FlightPlan = SF6.oFlightPlan,
+    SF4.PilotManualControl = EXT_PilotDetection.PilotSelectedMode,
+    SF4.ManualConsigns = SF2.ManualConsigns,
+    SF1.MotorRate = SF2.MotorRate,
+    SF1.MotorDisabled^Motor1 = SF7.MotorDisabled^Motor1,
+    SF1.MotorDisabled^Motor2 = SF7.MotorDisabled^Motor2,
+    SF1.MotorDisabled^Motor3 = SF7.MotorDisabled^Motor3,
+    SF1.MotorDisabled^Motor4 = SF7.MotorDisabled^Motor4,
+    SF2.Altitude = SF3.Altitude,
+    SF2.Attitude = SF3.Attitude,
+    SF2.Position = SF3.Position,
+    SF2.Speed = SF3.Speed,
+    SF2.PositionConsign = SF4.PositionConsign,
+    SF2.SpeedConsign = SF4.SpeedConsign,
+    SF2.APEngagement = SF4.APEngagement,
+    SF2.PilotOrders = EXT_PilotDetection.PilotOrders;
+  extern 
+    nodeproperty <global projectName> = "AIDASystem/AIDASystem/AIDA0_4_4";
+    nodeproperty <global projectVersion> = "1";
+    nodeproperty <global projectConfig> = "default";
+    nodeproperty <global currentDate> = "2018-10-08 08:54:11";
+edon
+

Copyrights.txt

+
+************************************************************************
+	Copyrights and license
+************************************************************************
+
+The whole model is provided under the following terms
+
+Copyright (c) 2016-2018 IRT AESE (IRT Saint Exupéry).
+
+All rights reserved. This program and the accompanying materials are made available under the terms of the 
+Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) which accompanies this distribution,
+and is available at https://creativecommons.org/licenses/by-sa/4.0/
+
+Third party components:
+
+The nodes Functions/BasicOperators/AND, Functions/BasicOperators/Comparator, Functions/BasicFunctions/InOutFunction and 
+Functions/BasicFunctions/SourceFunction are provided under the following terms:
+
+Copyright (c) 2007-2017 ONERA. 
+
+All rights reserved. This program and the accompanying materials 
+are made available under the terms of the Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
+which accompanies this distribution, and is available at https://creativecommons.org/licenses/by-sa/4.0/

README.txt

+
+ *******************
+ *** README AIDA ***
+ *******************
+
+This repository contains the safety model of the study case AIDA.
+It is provided by IRT Saint Exupéry under a Creative Commons BY-SA licence.
+This repository is managed in versioning throught git, with the following url
+
+https://sahara.pf.irt-saintexupery.com/
+project AIDA
+
+
+1. AIDA description
+
+2. Motivation and intended use
+
+3. List of files and how to use them
+
+
+
+
+
+************************************************************************
+* 1. AIDA description
+************************************************************************
+The AIDA (Aircraft Inspection by Drone Assistant) system, is a Remotely Piloted Aircraft System (RPAS). 
+It is composed of a quadcopter drone, a control computer and a remote control. 
+The mission of this system is to help the pilot to inspect the aircraft before flight. 
+The quadcopter drone can be piloted in automated or manual mode. In manual mode, 
+the pilot guides the inspection of the aircraft by the drone. 
+In automated mode, the drone follows a flight plan and records the video of the inspected zone.
+
+************************************************************************
+* 2. Motivation and intended use
+************************************************************************
+AIDA provides a reference study case representative of the complexity and criticity found in aeronautical
+systems.
+Our intent is to provide a repository to gather all AIDA modellings in order to share different approaches and tools.
+
+If you plan to use AIDA as a study case it would be kind to inform the IRT Saint-Exupery contacts below. We would be pleased to answer your questions.
+patrick.farail@irt-saintexupery.com
+estelle.saez@irt-saintexupery.com
+
+Currently, the following works use this use case :
+Prosvirnova, T., Saez, E., Seguin, C., Virelizier, P.: Handling consistency between safety and system models.
+In: Bozzano, M., Papadopoulos, Y. (eds.) Model-Based Safety and Assessment - 5th International Symposium, IMBSA 2017, Trento, Italy, September 11-13, 2017, Proceedings.
+Lecture Notes in Computer Science, vol. 10437, pp. 19-34. Springer (2017),
+https://doi.org/10.1007/978-3-319-64119-5_2
+
+************************************************************************
+* 3. List of files and how to use them
+************************************************************************
+AIDASystem-AltaRicaDataFlow.alt: safety model of AIDA in AlaRica DataFlow (version Cecilia-OCAS), text format
+
+AIDASystem-OCASModel.exp: safety model of AIDA, Cecilia-OCAS export format (v5)
+
+AIDASystem-OCASModel.docx: generated documentation of the model, MS Word format
+