diff --git a/HVAC_model.c b/HVAC_model.c
index d6b68a9..5a31888 100644
--- a/HVAC_model.c
+++ b/HVAC_model.c
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.866
+ * Model version                  : 1.876
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Tue May  5 14:20:39 2026
+ * C/C++ source code generated on : Wed May  6 14:55:30 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -162,9 +162,9 @@ const ActuatorCmdBus HVAC_model_rtZActuatorCmdBus = {
 ActuatorCmdBusInput Actuator_Ch0_Status_Model;/* '<Root>/Data Store Memory61' */
 ActuatorCmdBusInput Actuator_Ch1_Status_Model;/* '<Root>/Data Store Memory62' */
 ActuatorCmdBusInput Actuator_Ch2_Status_Model;/* '<Root>/Data Store Memory63' */
-ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S483>/Data Store Memory15' */
-ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S484>/Data Store Memory15' */
-ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S485>/Data Store Memory15' */
+ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S501>/Data Store Memory15' */
+ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S502>/Data Store Memory15' */
+ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S503>/Data Store Memory15' */
 CmdBusStatus Status_Sensor_Model;      /* '<S2>/Data Store Memory' */
 CmdBusError CCU_Errors_Model;          /* '<Root>/Data Store Memory3' */
 CmdBusPWMGet PWM_Get;                  /* '<Root>/Data Store Memory128' */
@@ -2503,60 +2503,41 @@ void left(uint8_t rtu_idx, uint16_t rty_vals[9])
 
 /*
  * Output and update for action system:
- *    '<S524>/If Action Subsystem'
- *    '<S591>/If Action Subsystem'
- *    '<S658>/If Action Subsystem'
+ *    '<S542>/If Action Subsystem'
+ *    '<S612>/If Action Subsystem'
+ *    '<S679>/If Action Subsystem'
  */
 void IfActionSubsystem(int8_t *rty_Out1, double *rtd_ErrorHomming_private,
   double *rtd_Start_timer_i, int8_t *rtd_stepSig_private)
 {
-  /* DataStoreWrite: '<S527>/Data Store Write' incorporates:
-   *  Constant: '<S527>/Constant'
+  /* DataStoreWrite: '<S545>/Data Store Write' incorporates:
+   *  Constant: '<S545>/Constant'
    */
   *rtd_stepSig_private = 1;
 
-  /* DataStoreWrite: '<S527>/Data Store Write1' incorporates:
-   *  Constant: '<S527>/Constant2'
-   *  DataStoreRead: '<S527>/Data Store Read1'
-   *  Sum: '<S527>/step inc'
+  /* DataStoreWrite: '<S545>/Data Store Write1' incorporates:
+   *  Constant: '<S545>/Constant2'
+   *  DataStoreRead: '<S545>/Data Store Read1'
+   *  Sum: '<S545>/step inc'
    */
   (*rtd_ErrorHomming_private)++;
 
-  /* DataStoreWrite: '<S527>/Data Store Write2' incorporates:
-   *  Constant: '<S527>/Constant3'
+  /* DataStoreWrite: '<S545>/Data Store Write2' incorporates:
+   *  Constant: '<S545>/Constant3'
    */
   *rtd_Start_timer_i = 0.0;
 
-  /* SignalConversion generated from: '<S527>/Out1' incorporates:
-   *  Constant: '<S527>/Constant1'
+  /* SignalConversion generated from: '<S545>/Out1' incorporates:
+   *  Constant: '<S545>/Constant1'
    */
   *rty_Out1 = 2;
 }
 
-/*
- * Output and update for action system:
- *    '<S524>/If Action Subsystem1'
- *    '<S591>/If Action Subsystem1'
- *    '<S658>/If Action Subsystem1'
- */
-void IfActionSubsystem1(int8_t *rty_Out1, double *rtd_Start_timer_i)
-{
-  /* DataStoreWrite: '<S528>/Data Store Write2' incorporates:
-   *  Constant: '<S528>/Constant3'
-   */
-  *rtd_Start_timer_i = 1.0;
-
-  /* SignalConversion generated from: '<S528>/Out1' incorporates:
-   *  Constant: '<S528>/Constant1'
-   */
-  *rty_Out1 = 3;
-}
-
 /*
  * System initialize for atomic system:
- *    '<S524>/MATLAB Function'
- *    '<S591>/MATLAB Function'
- *    '<S658>/MATLAB Function'
+ *    '<S542>/MATLAB Function'
+ *    '<S612>/MATLAB Function'
+ *    '<S679>/MATLAB Function'
  */
 void MATLABFunction_Init(DW_MATLABFunction *localDW)
 {
@@ -2566,9 +2547,9 @@ void MATLABFunction_Init(DW_MATLABFunction *localDW)
 
 /*
  * Output and update for atomic system:
- *    '<S524>/MATLAB Function'
- *    '<S591>/MATLAB Function'
- *    '<S658>/MATLAB Function'
+ *    '<S542>/MATLAB Function'
+ *    '<S612>/MATLAB Function'
+ *    '<S679>/MATLAB Function'
  */
 void MATLABFunction(double rtu_cond, uint32_t rtu_t_now, uint32_t *rty_dt,
                     DW_MATLABFunction *localDW)
@@ -2615,11 +2596,11 @@ void MATLABFunction(double rtu_cond, uint32_t rtu_t_now, uint32_t *rty_dt,
 
 /*
  * Output and update for action system:
- *    '<S509>/If Action Subsystem1'
- *    '<S576>/If Action Subsystem1'
- *    '<S643>/If Action Subsystem1'
+ *    '<S527>/If Action Subsystem1'
+ *    '<S597>/If Action Subsystem1'
+ *    '<S664>/If Action Subsystem1'
  */
-void IfActionSubsystem1_d(int8_t *rty_Output, uint8_t
+void IfActionSubsystem1(int8_t *rty_Output, uint8_t
   *rtd_CCU_ActuatorErrF_Stat_private, uint8_t rtd_COM_private[9], uint8_t
   rtd_ErrorActuator[9], uint8_t rtd_ErrorCalibration_private[9], const double
   *rtd_LOGGER_LIN, uint8_t rtd_MODE_private[9], uint8_t
@@ -2628,32 +2609,32 @@ void IfActionSubsystem1_d(int8_t *rty_Output, uint8_t
   int32_t i;
   bool tmp;
 
-  /* Logic: '<S531>/Logical Operator' incorporates:
-   *  DataStoreRead: '<S525>/Data Store Read'
+  /* Logic: '<S551>/Logical Operator' incorporates:
+   *  DataStoreRead: '<S543>/Data Store Read'
    */
   tmp = (rtd_ErrorCalibration_private[0] != 0);
   for (i = 0; i < 8; i++) {
     tmp = (tmp || (rtd_ErrorCalibration_private[i + 1] != 0));
   }
 
-  /* DataTypeConversion: '<S531>/Data Type Conversion' incorporates:
-   *  DataStoreWrite: '<S531>/Data Store Write1'
-   *  Logic: '<S531>/Logical Operator'
+  /* DataTypeConversion: '<S551>/Data Type Conversion' incorporates:
+   *  DataStoreWrite: '<S551>/Data Store Write1'
+   *  Logic: '<S551>/Logical Operator'
    */
   *rtd_CCU_ActuatorErrF_Stat_private = tmp;
   for (i = 0; i < 9; i++) {
-    /* DataStoreWrite: '<S531>/Data Store Write2' incorporates:
-     *  DataStoreRead: '<S525>/Data Store Read'
+    /* DataStoreWrite: '<S551>/Data Store Write2' incorporates:
+     *  DataStoreRead: '<S543>/Data Store Read'
      */
     rtd_COM_private[i] = rtd_ErrorCalibration_private[i];
 
-    /* DataStoreWrite: '<S531>/Data Store Write' */
+    /* DataStoreWrite: '<S551>/Data Store Write' */
     rtd_MODE_private[i] = 2U;
   }
 
-  /* MATLAB Function: '<S531>/Write ERROR' incorporates:
-   *  DataStoreRead: '<S525>/Data Store Read'
-   *  DataStoreRead: '<S531>/Data Store Read6'
+  /* MATLAB Function: '<S551>/Write ERROR' incorporates:
+   *  DataStoreRead: '<S543>/Data Store Read'
+   *  DataStoreRead: '<S551>/Data Store Read6'
    */
   /* :  if(LOGGER==1) */
   if (*rtd_LOGGER_LIN == 1.0) {
@@ -2668,40 +2649,58 @@ void IfActionSubsystem1_d(int8_t *rty_Output, uint8_t
     }
   }
 
-  /* End of MATLAB Function: '<S531>/Write ERROR' */
+  /* End of MATLAB Function: '<S551>/Write ERROR' */
   for (i = 0; i < 9; i++) {
     uint8_t rtd_ErrorCalibration_private_0;
 
-    /* Logic: '<S525>/Logical Operator1' incorporates:
-     *  DataStoreRead: '<S525>/Data Store Read'
+    /* Logic: '<S543>/Logical Operator1' incorporates:
+     *  DataStoreRead: '<S543>/Data Store Read'
      */
     rtd_ErrorCalibration_private_0 = rtd_ErrorCalibration_private[i];
 
-    /* DataTypeConversion: '<S525>/Data Type Conversion1' incorporates:
-     *  DataStoreRead: '<S525>/Data Store Read1'
-     *  DataStoreWrite: '<S525>/Data Store Write3'
-     *  Logic: '<S525>/Logical Operator1'
+    /* DataTypeConversion: '<S543>/Data Type Conversion1' incorporates:
+     *  DataStoreRead: '<S543>/Data Store Read1'
+     *  DataStoreWrite: '<S543>/Data Store Write3'
+     *  Logic: '<S543>/Logical Operator1'
      */
     rtd_ErrorActuator[i] = (uint8_t)((rtd_ErrorCalibration_private_0 != 0) ||
       (rtd_ErrorActuator[i] != 0));
 
-    /* DataStoreWrite: '<S532>/Data Store Write' */
+    /* DataStoreWrite: '<S552>/Data Store Write' */
     rtd_dtc_state_error_model[i + 54] = rtd_ErrorCalibration_private_0;
 
-    /* DataStoreWrite: '<S525>/Data Store Write' */
+    /* DataStoreWrite: '<S543>/Data Store Write' */
     rtd_ErrorCalibration_private[i] = 0U;
   }
 
-  /* SignalConversion generated from: '<S525>/Output' incorporates:
-   *  Constant: '<S525>/Constant'
+  /* SignalConversion generated from: '<S543>/Output' incorporates:
+   *  Constant: '<S543>/Constant'
    */
   *rty_Output = 4;
 }
 
+/*
+ * Output and update for action system:
+ *    '<S612>/If Action Subsystem1'
+ *    '<S679>/If Action Subsystem1'
+ */
+void IfActionSubsystem1_l(int8_t *rty_Out1, double *rtd_Start_timer_l)
+{
+  /* DataStoreWrite: '<S616>/Data Store Write2' incorporates:
+   *  Constant: '<S616>/Constant3'
+   */
+  *rtd_Start_timer_l = 1.0;
+
+  /* SignalConversion generated from: '<S616>/Out1' incorporates:
+   *  Constant: '<S616>/Constant1'
+   */
+  *rty_Out1 = 3;
+}
+
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Bi Level'
- *    '<S689>/AF for Bi Level'
+ *    '<S710>/AF for Bi Level'
+ *    '<S711>/AF for Bi Level'
  */
 void AFforBiLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2718,8 +2717,8 @@ void AFforBiLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Def'
- *    '<S689>/AF for Def'
+ *    '<S710>/AF for Def'
+ *    '<S711>/AF for Def'
  */
 void AFforDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2736,8 +2735,8 @@ void AFforDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Foor + Def'
- *    '<S689>/AF for Foor + Def'
+ *    '<S710>/AF for Foor + Def'
+ *    '<S711>/AF for Foor + Def'
  */
 void AFforFoorDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2754,8 +2753,8 @@ void AFforFoorDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Foot'
- *    '<S689>/AF for Foot'
+ *    '<S710>/AF for Foot'
+ *    '<S711>/AF for Foot'
  */
 void AFforFoot(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2772,8 +2771,8 @@ void AFforFoot(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Hi_Level'
- *    '<S689>/AF for Hi_Level'
+ *    '<S710>/AF for Hi_Level'
+ *    '<S711>/AF for Hi_Level'
  */
 void AFforHi_Level(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2790,8 +2789,8 @@ void AFforHi_Level(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Tri-Level'
- *    '<S689>/AF for Tri-Level'
+ *    '<S710>/AF for Tri-Level'
+ *    '<S711>/AF for Tri-Level'
  */
 void AFforTriLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2808,8 +2807,8 @@ void AFforTriLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S688>/AF for Vent mode'
- *    '<S689>/AF for Vent mode'
+ *    '<S710>/AF for Vent mode'
+ *    '<S711>/AF for Vent mode'
  */
 void AFforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2826,8 +2825,8 @@ void AFforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S690>/AF for Bi Level R'
- *    '<S691>/AF for Bi Level R'
+ *    '<S712>/AF for Bi Level R'
+ *    '<S713>/AF for Bi Level R'
  */
 void AFforBiLevelR(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2844,8 +2843,8 @@ void AFforBiLevelR(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S690>/AF for Foot R'
- *    '<S691>/AF for Foot R'
+ *    '<S712>/AF for Foot R'
+ *    '<S713>/AF for Foot R'
  */
 void AFforFootR(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2862,8 +2861,8 @@ void AFforFootR(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S690>/AF for Vent mode R'
- *    '<S691>/AF for Vent mode R'
+ *    '<S712>/AF for Vent mode R'
+ *    '<S713>/AF for Vent mode R'
  */
 void AFforVentmodeR(uint8_t rtu_blower_speed, uint16_t *rty_out)
 {
@@ -2880,8 +2879,188 @@ void AFforVentmodeR(uint8_t rtu_blower_speed, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S727>/g_assSTART_ENTER_INCAR'
- *    '<S728>/g_assSTART_ENTER_INCAR'
+ *    '<S737>/Valves for Bi Level'
+ *    '<S738>/Valves for Bi Level'
+ */
+void ValvesforBiLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_BIVALVE_MANUAL(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_BIVALVE_MANUAL[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S737>/Valves for Def'
+ *    '<S738>/Valves for Def'
+ */
+void ValvesforDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_DE2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_DE2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S737>/Valves for Foot'
+ *    '<S738>/Valves for Foot'
+ */
+void ValvesforFoot(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_FO2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_FO2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S737>/Valves for Foot + Def'
+ *    '<S738>/Valves for Foot + Def'
+ */
+void ValvesforFootDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_FD2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_FD2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S737>/Valves for Hi_Level'
+ *    '<S738>/Valves for Hi_Level'
+ */
+void ValvesforHi_Level(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_HI2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_HI2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S737>/Valves for Tri-Level'
+ *    '<S738>/Valves for Tri-Level'
+ */
+void ValvesforTriLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_TR2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_TR2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S737>/Valves for Vent mode'
+ *    '<S738>/Valves for Vent mode'
+ */
+void ValvesforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_FR_VE2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_FR_VE2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S739>/AF for Bi Level'
+ *    '<S740>/AF for Bi Level'
+ */
+void AFforBiLevel_m(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_RE_BI2VALVE_MANUAL(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_RE_BI2VALVE_MANUAL[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S739>/AF for Foot'
+ *    '<S740>/AF for Foot'
+ */
+void AFforFoot_p(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_RE_FO2VALVE(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_RE_FO2VALVE[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S739>/valves for Vent mode'
+ *    '<S740>/valves for Vent mode'
+ */
+void valvesforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out)
+{
+  int32_t tmp;
+
+  /* :  out = uint16(g_ausFLOW_RE_VENT_MANUAL(blower_speed + 1)); */
+  tmp = (int32_t)(rtu_blower_speed + 1U);
+  if (rtu_blower_speed + 1U > 255U) {
+    tmp = 255;
+  }
+
+  *rty_out = g_ausFLOW_RE_VENT_MANUAL[tmp - 1];
+}
+
+/*
+ * Output and update for atomic system:
+ *    '<S773>/g_assSTART_ENTER_INCAR'
+ *    '<S774>/g_assSTART_ENTER_INCAR'
  */
 void g_assSTART_ENTER_INCAR_j(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -2898,9 +3077,9 @@ void g_assSTART_ENTER_INCAR_j(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S730>/g_assSTART_ENTER_COOLANT '
- *    '<S731>/g_assSTART_ENTER_COOLANT '
- *    '<S732>/g_assSTART_ENTER_COOLANT '
+ *    '<S776>/g_assSTART_ENTER_COOLANT '
+ *    '<S777>/g_assSTART_ENTER_COOLANT '
+ *    '<S778>/g_assSTART_ENTER_COOLANT '
  */
 void g_assSTART_ENTER_COOLANT_p(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -2926,28 +3105,28 @@ void g_assSTART_ENTER_COOLANT_p(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for action system:
- *    '<S722>/Level 4'
- *    '<S722>/Level 5'
+ *    '<S768>/Level 4'
+ *    '<S768>/Level 5'
  */
 void Level4(int8_t *rty_step1, const uint16_t *rtd_ECT, const uint8_t *rtd_LEVEL,
             const double *rtd_MODE_DRIVER)
 {
   int16_t rtb_out_p2;
 
-  /* MATLAB Function: '<S731>/g_assSTART_ENTER_COOLANT ' incorporates:
-   *  DataStoreRead: '<S731>/Data Store Read3'
+  /* MATLAB Function: '<S777>/g_assSTART_ENTER_COOLANT ' incorporates:
+   *  DataStoreRead: '<S777>/Data Store Read3'
    */
   g_assSTART_ENTER_COOLANT_p(*rtd_LEVEL, &rtb_out_p2);
 
-  /* Switch: '<S731>/Switch' incorporates:
-   *  Constant: '<S731>/AUTO'
-   *  Constant: '<S731>/Constant'
-   *  Constant: '<S731>/Constant1'
-   *  DataStoreRead: '<S731>/Data Store Read'
-   *  DataStoreRead: '<S731>/Data Store Read1'
-   *  Logic: '<S731>/AND'
-   *  RelationalOperator: '<S731>/Relational Operator'
-   *  RelationalOperator: '<S731>/Relational Operator2'
+  /* Switch: '<S777>/Switch' incorporates:
+   *  Constant: '<S777>/AUTO'
+   *  Constant: '<S777>/Constant'
+   *  Constant: '<S777>/Constant1'
+   *  DataStoreRead: '<S777>/Data Store Read'
+   *  DataStoreRead: '<S777>/Data Store Read1'
+   *  Logic: '<S777>/AND'
+   *  RelationalOperator: '<S777>/Relational Operator'
+   *  RelationalOperator: '<S777>/Relational Operator2'
    */
   if ((*rtd_ECT < rtb_out_p2) && (*rtd_MODE_DRIVER == 1.0)) {
     *rty_step1 = 0;
@@ -2955,37 +3134,37 @@ void Level4(int8_t *rty_step1, const uint16_t *rtd_ECT, const uint8_t *rtd_LEVEL
     *rty_step1 = -1;
   }
 
-  /* End of Switch: '<S731>/Switch' */
+  /* End of Switch: '<S777>/Switch' */
 }
 
 /*
  * Output and update for action system:
- *    '<S723>/Level 0'
- *    '<S723>/Level 1'
- *    '<S723>/Level 2'
- *    '<S983>/Level 0'
- *    '<S983>/Level 1'
+ *    '<S769>/Level 0'
+ *    '<S769>/Level 1'
+ *    '<S769>/Level 2'
+ *    '<S1029>/Level 0'
+ *    '<S1029>/Level 1'
  */
 void Level0(int8_t *rty_step)
 {
-  /* SignalConversion generated from: '<S740>/step' incorporates:
-   *  Constant: '<S740>/Constant'
+  /* SignalConversion generated from: '<S786>/step' incorporates:
+   *  Constant: '<S786>/Constant'
    */
   *rty_step = 1;
 }
 
 /*
  * Output and update for atomic system:
- *    '<S743>/incar filter down'
- *    '<S744>/incar filter down'
- *    '<S745>/incar filter down'
- *    '<S755>/incar filter down'
- *    '<S756>/incar filter down'
- *    '<S758>/incar filter down'
- *    '<S759>/incar filter down'
- *    '<S760>/incar filter down'
- *    '<S823>/incar filter down'
- *    '<S824>/incar filter down'
+ *    '<S789>/incar filter down'
+ *    '<S790>/incar filter down'
+ *    '<S791>/incar filter down'
+ *    '<S801>/incar filter down'
+ *    '<S802>/incar filter down'
+ *    '<S804>/incar filter down'
+ *    '<S805>/incar filter down'
+ *    '<S806>/incar filter down'
+ *    '<S869>/incar filter down'
+ *    '<S870>/incar filter down'
  *    ...
  */
 void incarfilterdown(uint8_t rtu_LVL, uint8_t *rty_out)
@@ -3003,16 +3182,16 @@ void incarfilterdown(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S743>/incar filter up'
- *    '<S744>/incar filter up'
- *    '<S745>/incar filter up'
- *    '<S755>/incar filter up'
- *    '<S756>/incar filter up'
- *    '<S758>/incar filter up'
- *    '<S759>/incar filter up'
- *    '<S760>/incar filter up'
- *    '<S823>/incar filter up'
- *    '<S824>/incar filter up'
+ *    '<S789>/incar filter up'
+ *    '<S790>/incar filter up'
+ *    '<S791>/incar filter up'
+ *    '<S801>/incar filter up'
+ *    '<S802>/incar filter up'
+ *    '<S804>/incar filter up'
+ *    '<S805>/incar filter up'
+ *    '<S806>/incar filter up'
+ *    '<S869>/incar filter up'
+ *    '<S870>/incar filter up'
  *    ...
  */
 void incarfilterup(uint8_t rtu_LVL, uint8_t *rty_out)
@@ -3030,8 +3209,8 @@ void incarfilterup(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S744>/g_assSTART_COOLANT_STEP0_TO_1 '
- *    '<S745>/g_assSTART_COOLANT_STEP0_TO_1 '
+ *    '<S790>/g_assSTART_COOLANT_STEP0_TO_1 '
+ *    '<S791>/g_assSTART_COOLANT_STEP0_TO_1 '
  */
 void g_assSTART_COOLANT_STEP0_TO_1_h(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -3057,11 +3236,11 @@ void g_assSTART_COOLANT_STEP0_TO_1_h(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/3 way valve status'
- *    '<S756>/3 way valve status'
- *    '<S758>/3 way valve status'
- *    '<S759>/3 way valve status'
- *    '<S760>/3 way valve status'
+ *    '<S801>/3 way valve status'
+ *    '<S802>/3 way valve status'
+ *    '<S804>/3 way valve status'
+ *    '<S805>/3 way valve status'
+ *    '<S806>/3 way valve status'
  */
 void uwayvalvestatus(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3078,9 +3257,9 @@ void uwayvalvestatus(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/Dtg_FrontLower_X'
- *    '<S756>/Dtg_FrontLower_X'
- *    '<S758>/Dtg_FrontLower_X'
+ *    '<S801>/Dtg_FrontLower_X'
+ *    '<S802>/Dtg_FrontLower_X'
+ *    '<S804>/Dtg_FrontLower_X'
  */
 void Dtg_FrontLower_X(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3097,9 +3276,9 @@ void Dtg_FrontLower_X(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/Dtg_FrontUpper_X'
- *    '<S756>/Dtg_FrontUpper_X'
- *    '<S758>/Dtg_FrontUpper_X'
+ *    '<S801>/Dtg_FrontUpper_X'
+ *    '<S802>/Dtg_FrontUpper_X'
+ *    '<S804>/Dtg_FrontUpper_X'
  */
 void Dtg_FrontUpper_X(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3116,11 +3295,11 @@ void Dtg_FrontUpper_X(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/Incar temp goto from step 1 to step 2 '
- *    '<S756>/Incar temp goto from step 1 to step 2 '
- *    '<S758>/Incar temp goto from step 1 to step 2 '
- *    '<S759>/Incar temp goto from step 1 to step 2 '
- *    '<S760>/Incar temp goto from step 1 to step 2 '
+ *    '<S801>/Incar temp goto from step 1 to step 2 '
+ *    '<S802>/Incar temp goto from step 1 to step 2 '
+ *    '<S804>/Incar temp goto from step 1 to step 2 '
+ *    '<S805>/Incar temp goto from step 1 to step 2 '
+ *    '<S806>/Incar temp goto from step 1 to step 2 '
  */
 void Incartempgotofromstep1tostep2(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -3137,8 +3316,8 @@ void Incartempgotofromstep1tostep2(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/blower FR'
- *    '<S756>/blower FR'
+ *    '<S801>/blower FR'
+ *    '<S802>/blower FR'
  */
 void blowerFR(uint8_t rtu_LVL, uint16_t *rty_out)
 {
@@ -3155,11 +3334,11 @@ void blowerFR(uint8_t rtu_LVL, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/mode FR step 1'
- *    '<S756>/mode FR step 1'
- *    '<S758>/mode FR step 1'
- *    '<S759>/mode FR step 1'
- *    '<S760>/mode FR step 1'
+ *    '<S801>/mode FR step 1'
+ *    '<S802>/mode FR step 1'
+ *    '<S804>/mode FR step 1'
+ *    '<S805>/mode FR step 1'
+ *    '<S806>/mode FR step 1'
  */
 void modeFRstep1(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3176,11 +3355,11 @@ void modeFRstep1(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S755>/window heating'
- *    '<S756>/window heating'
- *    '<S758>/window heating'
- *    '<S759>/window heating'
- *    '<S760>/window heating'
+ *    '<S801>/window heating'
+ *    '<S802>/window heating'
+ *    '<S804>/window heating'
+ *    '<S805>/window heating'
+ *    '<S806>/window heating'
  */
 void windowheating(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3197,10 +3376,10 @@ void windowheating(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S756>/Time goto from step 1 to step 2 '
- *    '<S758>/Time goto from step 1 to step 2 '
- *    '<S759>/Time goto from step 1 to step 2 '
- *    '<S760>/Time goto from step 1 to step 2 '
+ *    '<S802>/Time goto from step 1 to step 2 '
+ *    '<S804>/Time goto from step 1 to step 2 '
+ *    '<S805>/Time goto from step 1 to step 2 '
+ *    '<S806>/Time goto from step 1 to step 2 '
  */
 void Timegotofromstep1tostep2(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -3223,9 +3402,9 @@ void Timegotofromstep1tostep2(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S789>/ECT min max'
- *    '<S803>/ECT min max'
- *    '<S816>/ECT min max'
+ *    '<S835>/ECT min max'
+ *    '<S849>/ECT min max'
+ *    '<S862>/ECT min max'
  */
 void ECTminmax(uint8_t rtu_LVL, int16_t rty_out[2])
 {
@@ -3254,9 +3433,9 @@ void ECTminmax(uint8_t rtu_LVL, int16_t rty_out[2])
 
 /*
  * Output and update for atomic system:
- *    '<S789>/blower min max'
- *    '<S803>/blower min max'
- *    '<S816>/blower min max'
+ *    '<S835>/blower min max'
+ *    '<S849>/blower min max'
+ *    '<S862>/blower min max'
  */
 void blowerminmax(uint8_t rtu_LVL, uint16_t rty_out[2])
 {
@@ -3276,8 +3455,8 @@ void blowerminmax(uint8_t rtu_LVL, uint16_t rty_out[2])
 
 /*
  * Output and update for action system:
- *    '<S724>/Level 4'
- *    '<S724>/Level 5'
+ *    '<S770>/Level 4'
+ *    '<S770>/Level 5'
  */
 void Level4_c(int8_t *rty_step, uint16_t *rtd_Blower_FL, uint16_t *rtd_Blower_FR,
               uint8_t *rtd_Dtg_FLL, uint8_t *rtd_Dtg_FLR, uint8_t *rtd_Dtg_FUL,
@@ -3291,74 +3470,74 @@ void Level4_c(int8_t *rty_step, uint16_t *rtd_Blower_FL, uint16_t *rtd_Blower_FR
 {
   int32_t tmp;
   int16_t rtb_out_jl[2];
-  int16_t rtb_out_ff3;
-  int16_t rtb_out_mh;
+  int16_t rtb_out_nl;
+  int16_t rtb_out_pe;
   uint16_t rtb_out_nm[2];
   uint8_t rtb_out_fa;
   bool rtb_Equal_b;
   bool rtb_RelationalOperator1_mub;
 
-  /* DataStoreWrite: '<S759>/Data Store Write8' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read10'
-   *  MATLAB Function: '<S759>/3 way valve status'
+  /* DataStoreWrite: '<S805>/Data Store Write8' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read10'
+   *  MATLAB Function: '<S805>/3 way valve status'
    */
   uwayvalvestatus(*rtd_LEVEL, rtd_Valve_3_way);
 
-  /* DataStoreWrite: '<S759>/Data Store Write' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read1'
-   *  MATLAB Function: '<S759>/incar filter up'
+  /* DataStoreWrite: '<S805>/Data Store Write' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read1'
+   *  MATLAB Function: '<S805>/incar filter up'
    */
   incarfilterup(*rtd_LEVEL, rtd_Incar_filter_up_value);
 
-  /* DataStoreWrite: '<S759>/Data Store Write1' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read2'
-   *  MATLAB Function: '<S759>/incar filter down'
+  /* DataStoreWrite: '<S805>/Data Store Write1' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read2'
+   *  MATLAB Function: '<S805>/incar filter down'
    */
   incarfilterdown(*rtd_LEVEL, rtd_Incar_filter_down_value);
 
-  /* MATLAB Function: '<S759>/mode FR step 1' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read5'
+  /* MATLAB Function: '<S805>/mode FR step 1' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read5'
    */
   modeFRstep1(*rtd_LEVEL, &rtb_out_fa);
 
-  /* DataStoreWrite: '<S759>/Data Store Write2' */
+  /* DataStoreWrite: '<S805>/Data Store Write2' */
   *rtd_Mode_FR = rtb_out_fa;
 
-  /* DataStoreWrite: '<S759>/Data Store Write3' */
+  /* DataStoreWrite: '<S805>/Data Store Write3' */
   *rtd_Mode_FL = rtb_out_fa;
 
-  /* MATLAB Function: '<S759>/window heating' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read6'
+  /* MATLAB Function: '<S805>/window heating' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read6'
    */
   windowheating(*rtd_LEVEL, &rtb_out_fa);
 
-  /* DataStoreWrite: '<S759>/Data Store Write4' */
+  /* DataStoreWrite: '<S805>/Data Store Write4' */
   *rtd_El_window_heating = rtb_out_fa;
 
-  /* MATLAB Function: '<S803>/blower min max' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read7'
+  /* MATLAB Function: '<S849>/blower min max' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read7'
    */
   blowerminmax(*rtd_LEVEL, rtb_out_nm);
 
-  /* MATLAB Function: '<S803>/ECT min max' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read7'
+  /* MATLAB Function: '<S849>/ECT min max' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read7'
    */
   ECTminmax(*rtd_LEVEL, rtb_out_jl);
 
-  /* Lookup_n-D: '<S803>/blower для текущего ECT' incorporates:
-   *  DataStoreRead: '<S803>/engine coolant temp'
-   *  DataStoreWrite: '<S759>/Data Store Write5'
+  /* Lookup_n-D: '<S849>/blower для текущего ECT' incorporates:
+   *  DataStoreRead: '<S849>/engine coolant temp'
+   *  DataStoreWrite: '<S805>/Data Store Write5'
    */
   *rtd_Blower_FR = look1_iu16bs16lu64n32_binlcse(*rtd_ECT, rtb_out_jl,
     rtb_out_nm, 1U);
 
-  /* DataStoreWrite: '<S759>/Data Store Write6' incorporates:
-   *  DataStoreWrite: '<S759>/Data Store Write5'
+  /* DataStoreWrite: '<S805>/Data Store Write6' incorporates:
+   *  DataStoreWrite: '<S805>/Data Store Write5'
    */
   *rtd_Blower_FL = *rtd_Blower_FR;
 
-  /* MATLAB Function: '<S759>/Dtg_FrontUpper_X' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read8'
+  /* MATLAB Function: '<S805>/Dtg_FrontUpper_X' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read8'
    */
   /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_U(LVL + 1); */
   tmp = (int32_t)(*rtd_LEVEL + 1U);
@@ -3368,16 +3547,16 @@ void Level4_c(int8_t *rty_step, uint16_t *rtd_Blower_FL, uint16_t *rtd_Blower_FR
 
   rtb_out_fa = g_aucSTART_DUCT_TGT_STEP2_FX_U[tmp - 1];
 
-  /* DataStoreWrite: '<S759>/Data Store Write10' */
+  /* DataStoreWrite: '<S805>/Data Store Write10' */
   *rtd_Dtg_FUR = rtb_out_fa;
 
-  /* DataStoreWrite: '<S759>/Data Store Write11' */
+  /* DataStoreWrite: '<S805>/Data Store Write11' */
   *rtd_Dtg_FUL = rtb_out_fa;
 
-  /* MATLAB Function: '<S759>/Dtg_FrontLower_X' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read8'
-   *  DataStoreRead: '<S759>/Data Store Read9'
-   *  MATLAB Function: '<S759>/Dtg_FrontUpper_X'
+  /* MATLAB Function: '<S805>/Dtg_FrontLower_X' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read8'
+   *  DataStoreRead: '<S805>/Data Store Read9'
+   *  MATLAB Function: '<S805>/Dtg_FrontUpper_X'
    */
   /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_L(LVL + 1); */
   tmp = (int32_t)(*rtd_LEVEL + 1U);
@@ -3387,82 +3566,82 @@ void Level4_c(int8_t *rty_step, uint16_t *rtd_Blower_FL, uint16_t *rtd_Blower_FR
 
   rtb_out_fa = g_aucSTART_DUCT_TGT_STEP2_FX_L[tmp - 1];
 
-  /* End of MATLAB Function: '<S759>/Dtg_FrontLower_X' */
+  /* End of MATLAB Function: '<S805>/Dtg_FrontLower_X' */
 
-  /* DataStoreWrite: '<S759>/Data Store Write12' */
+  /* DataStoreWrite: '<S805>/Data Store Write12' */
   *rtd_Dtg_FLR = rtb_out_fa;
 
-  /* DataStoreWrite: '<S759>/Data Store Write13' */
+  /* DataStoreWrite: '<S805>/Data Store Write13' */
   *rtd_Dtg_FLL = rtb_out_fa;
 
-  /* DataStoreWrite: '<S759>/Data Store Write7' incorporates:
-   *  Constant: '<S759>/Recirc logic Partial REC'
+  /* DataStoreWrite: '<S805>/Data Store Write7' incorporates:
+   *  Constant: '<S805>/Recirc logic Partial REC'
    */
   *rtd_Recirculation = 1.0;
 
-  /* RelationalOperator: '<S759>/Equal' incorporates:
-   *  DataStoreRead: '<S759>/current step'
+  /* RelationalOperator: '<S805>/Equal' incorporates:
+   *  DataStoreRead: '<S805>/current step'
    */
   rtb_Equal_b = (*rtd_step_start_controle_front == 1);
 
-  /* MATLAB Function: '<S759>/Incar temp goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read3'
+  /* MATLAB Function: '<S805>/Incar temp goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read3'
    */
-  Incartempgotofromstep1tostep2(*rtd_LEVEL, &rtb_out_ff3);
+  Incartempgotofromstep1tostep2(*rtd_LEVEL, &rtb_out_nl);
 
-  /* MATLAB Function: '<S759>/Time goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S759>/Data Store Read4'
+  /* MATLAB Function: '<S805>/Time goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S805>/Data Store Read4'
    */
-  Timegotofromstep1tostep2(*rtd_LEVEL, &rtb_out_mh);
+  Timegotofromstep1tostep2(*rtd_LEVEL, &rtb_out_pe);
 
-  /* RelationalOperator: '<S759>/Relational Operator1' incorporates:
-   *  DataStoreRead: '<S801>/Data Store Read4'
-   *  Gain: '<S759>/из сек в мс'
-   *  Sum: '<S801>/Subtract'
-   *  UnitDelay: '<S801>/t_start_delay_private '
+  /* RelationalOperator: '<S805>/Relational Operator1' incorporates:
+   *  DataStoreRead: '<S847>/Data Store Read4'
+   *  Gain: '<S805>/из сек в мс'
+   *  Sum: '<S847>/Subtract'
+   *  UnitDelay: '<S847>/t_start_delay_private '
    */
   rtb_RelationalOperator1_mub = (*rtd_t_now -
-    localDW->t_start_delay_private_DSTATE > (uint32_t)(1000 * rtb_out_mh));
+    localDW->t_start_delay_private_DSTATE > (uint32_t)(1000 * rtb_out_pe));
 
-  /* Switch: '<S801>/Switch' incorporates:
-   *  DataStoreRead: '<S801>/Data Store Read4'
-   *  Logic: '<S801>/Logical Operator3'
-   *  Logic: '<S801>/Logical Operator4'
-   *  UnitDelay: '<S801>/Cond_prev_private '
-   *  UnitDelay: '<S801>/t_start_delay_private '
+  /* Switch: '<S847>/Switch' incorporates:
+   *  DataStoreRead: '<S847>/Data Store Read4'
+   *  Logic: '<S847>/Logical Operator3'
+   *  Logic: '<S847>/Logical Operator4'
+   *  UnitDelay: '<S847>/Cond_prev_private '
+   *  UnitDelay: '<S847>/t_start_delay_private '
    */
   if (rtb_Equal_b && (!localDW->Cond_prev_private_DSTATE)) {
     localDW->t_start_delay_private_DSTATE = *rtd_t_now;
   }
 
-  /* End of Switch: '<S801>/Switch' */
+  /* End of Switch: '<S847>/Switch' */
 
-  /* Switch: '<S759>/Switch' incorporates:
-   *  Constant: '<S759>/go to next step'
-   *  Constant: '<S759>/stay at step 1'
-   *  DataStoreRead: '<S759>/incar temp'
-   *  Logic: '<S759>/Logical Operator'
-   *  RelationalOperator: '<S759>/Relational Operator'
+  /* Switch: '<S805>/Switch' incorporates:
+   *  Constant: '<S805>/go to next step'
+   *  Constant: '<S805>/stay at step 1'
+   *  DataStoreRead: '<S805>/incar temp'
+   *  Logic: '<S805>/Logical Operator'
+   *  RelationalOperator: '<S805>/Relational Operator'
    */
-  if ((*rtd_Incar_FL > rtb_out_ff3) || rtb_RelationalOperator1_mub) {
+  if ((*rtd_Incar_FL > rtb_out_nl) || rtb_RelationalOperator1_mub) {
     *rty_step = 2;
   } else {
     *rty_step = 1;
   }
 
-  /* End of Switch: '<S759>/Switch' */
+  /* End of Switch: '<S805>/Switch' */
 
-  /* Update for UnitDelay: '<S801>/Cond_prev_private ' */
+  /* Update for UnitDelay: '<S847>/Cond_prev_private ' */
   localDW->Cond_prev_private_DSTATE = rtb_Equal_b;
 }
 
 /*
  * Output and update for atomic system:
- *    '<S823>/3 way valve status'
- *    '<S824>/3 way valve status'
- *    '<S826>/3 way valve status'
- *    '<S827>/3 way valve status'
- *    '<S828>/3 way valve status'
+ *    '<S869>/3 way valve status'
+ *    '<S870>/3 way valve status'
+ *    '<S872>/3 way valve status'
+ *    '<S873>/3 way valve status'
+ *    '<S874>/3 way valve status'
  */
 void uwayvalvestatus_a(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3485,11 +3664,11 @@ void uwayvalvestatus_a(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S830>/time for step'
- *    '<S860>/time for step'
- *    '<S890>/time for step'
- *    '<S921>/time for step'
- *    '<S952>/time for step'
+ *    '<S876>/time for step'
+ *    '<S906>/time for step'
+ *    '<S936>/time for step'
+ *    '<S967>/time for step'
+ *    '<S998>/time for step'
  */
 void timeforstep(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3512,11 +3691,11 @@ void timeforstep(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S831>/time for step'
- *    '<S861>/time for step'
- *    '<S891>/time for step'
- *    '<S922>/time for step'
- *    '<S953>/time for step'
+ *    '<S877>/time for step'
+ *    '<S907>/time for step'
+ *    '<S937>/time for step'
+ *    '<S968>/time for step'
+ *    '<S999>/time for step'
  */
 void timeforstep_j(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3539,11 +3718,11 @@ void timeforstep_j(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S823>/Time goto from step 2 to step 3 '
- *    '<S824>/Time goto from step 2 to step 3 '
- *    '<S826>/Time goto from step 2 to step 3 '
- *    '<S827>/Time goto from step 2 to step 3 '
- *    '<S828>/Time goto from step 2 to step 3 '
+ *    '<S869>/Time goto from step 2 to step 3 '
+ *    '<S870>/Time goto from step 2 to step 3 '
+ *    '<S872>/Time goto from step 2 to step 3 '
+ *    '<S873>/Time goto from step 2 to step 3 '
+ *    '<S874>/Time goto from step 2 to step 3 '
  */
 void Timegotofromstep2tostep3(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -3566,11 +3745,11 @@ void Timegotofromstep2tostep3(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S834>/blower step'
- *    '<S864>/blower step'
- *    '<S895>/blower step'
- *    '<S926>/blower step'
- *    '<S957>/blower step'
+ *    '<S880>/blower step'
+ *    '<S910>/blower step'
+ *    '<S941>/blower step'
+ *    '<S972>/blower step'
+ *    '<S1003>/blower step'
  */
 void blowerstep(uint8_t rtu_LVL, uint16_t *rty_out)
 {
@@ -3587,11 +3766,11 @@ void blowerstep(uint8_t rtu_LVL, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S834>/blower time for step'
- *    '<S864>/blower time for step'
- *    '<S895>/blower time for step'
- *    '<S926>/blower time for step'
- *    '<S957>/blower time for step'
+ *    '<S880>/blower time for step'
+ *    '<S910>/blower time for step'
+ *    '<S941>/blower time for step'
+ *    '<S972>/blower time for step'
+ *    '<S1003>/blower time for step'
  */
 void blowertimeforstep(uint8_t rtu_LVL, uint16_t *rty_out)
 {
@@ -3614,11 +3793,11 @@ void blowertimeforstep(uint8_t rtu_LVL, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S837>/step'
- *    '<S867>/step'
- *    '<S898>/step'
- *    '<S929>/step'
- *    '<S960>/step'
+ *    '<S883>/step'
+ *    '<S913>/step'
+ *    '<S944>/step'
+ *    '<S975>/step'
+ *    '<S1006>/step'
  */
 void step_j(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3635,11 +3814,11 @@ void step_j(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S837>/time for step'
- *    '<S867>/time for step'
- *    '<S898>/time for step'
- *    '<S929>/time for step'
- *    '<S960>/time for step'
+ *    '<S883>/time for step'
+ *    '<S913>/time for step'
+ *    '<S944>/time for step'
+ *    '<S975>/time for step'
+ *    '<S1006>/time for step'
  */
 void timeforstep_g(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3662,10 +3841,10 @@ void timeforstep_g(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S824>/window heating'
- *    '<S826>/window heating'
- *    '<S827>/window heating'
- *    '<S828>/window heating'
+ *    '<S870>/window heating'
+ *    '<S872>/window heating'
+ *    '<S873>/window heating'
+ *    '<S874>/window heating'
  */
 void windowheating_k(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3688,9 +3867,9 @@ void windowheating_k(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S826>/autodemist (autodefog)'
- *    '<S827>/autodemist (autodefog)'
- *    '<S828>/autodemist (autodefog)'
+ *    '<S872>/autodemist (autodefog)'
+ *    '<S873>/autodemist (autodefog)'
+ *    '<S874>/autodemist (autodefog)'
  */
 void autodemistautodefog(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -3707,8 +3886,8 @@ void autodemistautodefog(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for action system:
- *    '<S725>/Level 3'
- *    '<S725>/Level 4'
+ *    '<S771>/Level 3'
+ *    '<S771>/Level 4'
  */
 void Level3(int8_t *rty_step, uint8_t *rtd_Autodefog, uint16_t *rtd_Blower_FL,
             uint16_t *rtd_Blower_FR, const uint16_t *rtd_Blower_logic_FL,
@@ -3724,325 +3903,325 @@ void Level3(int8_t *rty_step, uint8_t *rtd_Autodefog, uint16_t *rtd_Blower_FL,
 {
   int32_t tmp;
   int16_t rtb_out_cw;
-  uint16_t rtb_out_as;
   uint16_t rtb_out_gqg;
-  uint8_t rtb_out_ir5;
-  uint8_t rtb_out_jj;
-  uint8_t rtb_out_pr;
+  uint16_t rtb_out_ov4;
+  uint8_t rtb_out_ac;
+  uint8_t rtb_out_ln5;
+  uint8_t rtb_out_oq;
   bool rtb_Cond_prev_private_gh;
   bool rtb_RelationalOperator1_df;
 
-  /* DataStoreWrite: '<S826>/Data Store Write8' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read10'
-   *  MATLAB Function: '<S826>/3 way valve status'
+  /* DataStoreWrite: '<S872>/Data Store Write8' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read10'
+   *  MATLAB Function: '<S872>/3 way valve status'
    */
   uwayvalvestatus_a(*rtd_LEVEL, rtd_Valve_3_way);
 
-  /* MATLAB Function: '<S890>/step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read9'
+  /* MATLAB Function: '<S936>/step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read9'
    */
-  Dtg_FrontLower_X(*rtd_LEVEL, &rtb_out_jj);
+  Dtg_FrontLower_X(*rtd_LEVEL, &rtb_out_oq);
 
-  /* MATLAB Function: '<S890>/time for step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read9'
+  /* MATLAB Function: '<S936>/time for step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read9'
    */
-  timeforstep(*rtd_LEVEL, &rtb_out_ir5);
+  timeforstep(*rtd_LEVEL, &rtb_out_ac);
 
-  /* Switch: '<S890>/Switch' incorporates:
-   *  Constant: '<S890>/Constant'
-   *  Constant: '<S900>/epsilon'
-   *  DataStoreRead: '<S890>/Текущее значение blower '
-   *  DataStoreRead: '<S890>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S890>/текущее время в мс'
-   *  DataStoreWrite: '<S826>/Data Store Write12'
-   *  Product: '<S890>/Product1'
-   *  Product: '<S890>/change rate (dtg//sec)'
-   *  Product: '<S890>/скорость в мс'
-   *  Product: '<S890>/шаг изменения'
-   *  RelationalOperator: '<S900>/Relational Operator'
-   *  RelationalOperator: '<S904>/Relational Operator'
-   *  Sum: '<S890>/Add'
-   *  Sum: '<S900>/Add'
-   *  Sum: '<S901>/Subtract'
-   *  Switch: '<S904>/Switch'
-   *  UnitDelay: '<S901>/Unit Delay'
+  /* Switch: '<S936>/Switch' incorporates:
+   *  Constant: '<S936>/Constant'
+   *  Constant: '<S946>/epsilon'
+   *  DataStoreRead: '<S936>/Текущее значение blower '
+   *  DataStoreRead: '<S936>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S936>/текущее время в мс'
+   *  DataStoreWrite: '<S872>/Data Store Write12'
+   *  Product: '<S936>/Product1'
+   *  Product: '<S936>/change rate (dtg//sec)'
+   *  Product: '<S936>/скорость в мс'
+   *  Product: '<S936>/шаг изменения'
+   *  RelationalOperator: '<S946>/Relational Operator'
+   *  RelationalOperator: '<S950>/Relational Operator'
+   *  Sum: '<S936>/Add'
+   *  Sum: '<S946>/Add'
+   *  Sum: '<S947>/Subtract'
+   *  Switch: '<S950>/Switch'
+   *  UnitDelay: '<S947>/Unit Delay'
    */
   if ((uint8_t)(*rtd_Dtg_FLL - *rtd_Dtg_logic_FLL) <= 0.01) {
     *rtd_Dtg_FLR = *rtd_Dtg_logic_FLL;
   } else {
     if (*rtd_Dtg_FLL <= *rtd_Dtg_logic_FLL) {
-      /* Switch: '<S904>/Switch' incorporates:
-       *  Constant: '<S904>/Constant'
+      /* Switch: '<S950>/Switch' incorporates:
+       *  Constant: '<S950>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S904>/Switch' incorporates:
-       *  Constant: '<S904>/Constant1'
+      /* Switch: '<S950>/Switch' incorporates:
+       *  Constant: '<S950>/Constant1'
        */
       tmp = -1;
     }
 
-    *rtd_Dtg_FLR = (uint8_t)((double)rtb_out_jj / (double)rtb_out_ir5 / 1000.0 *
+    *rtd_Dtg_FLR = (uint8_t)((double)rtb_out_oq / (double)rtb_out_ac / 1000.0 *
       (double)(*rtd_t_now - localDW->UnitDelay_DSTATE) * (double)tmp + (double)*
       rtd_Dtg_FLL);
   }
 
-  /* End of Switch: '<S890>/Switch' */
+  /* End of Switch: '<S936>/Switch' */
 
-  /* DataStoreWrite: '<S826>/Data Store Write13' incorporates:
-   *  DataStoreWrite: '<S826>/Data Store Write12'
+  /* DataStoreWrite: '<S872>/Data Store Write13' incorporates:
+   *  DataStoreWrite: '<S872>/Data Store Write12'
    */
   *rtd_Dtg_FLL = *rtd_Dtg_FLR;
 
-  /* MATLAB Function: '<S891>/step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read8'
+  /* MATLAB Function: '<S937>/step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read8'
    */
-  Dtg_FrontUpper_X(*rtd_LEVEL, &rtb_out_jj);
+  Dtg_FrontUpper_X(*rtd_LEVEL, &rtb_out_oq);
 
-  /* MATLAB Function: '<S891>/time for step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read8'
+  /* MATLAB Function: '<S937>/time for step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read8'
    */
-  timeforstep_j(*rtd_LEVEL, &rtb_out_ir5);
+  timeforstep_j(*rtd_LEVEL, &rtb_out_ac);
 
-  /* Switch: '<S891>/Switch' incorporates:
-   *  Constant: '<S891>/Constant'
-   *  Constant: '<S905>/epsilon'
-   *  DataStoreRead: '<S891>/Текущее значение blower '
-   *  DataStoreRead: '<S891>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S891>/текущее время в мс'
-   *  DataStoreWrite: '<S826>/Data Store Write10'
-   *  Product: '<S891>/Product1'
-   *  Product: '<S891>/change rate (dtg//sec)'
-   *  Product: '<S891>/скорость в мс'
-   *  Product: '<S891>/шаг изменения'
-   *  RelationalOperator: '<S905>/Relational Operator'
-   *  RelationalOperator: '<S909>/Relational Operator'
-   *  Sum: '<S891>/Add'
-   *  Sum: '<S905>/Add'
-   *  Sum: '<S906>/Subtract'
-   *  Switch: '<S909>/Switch'
-   *  UnitDelay: '<S906>/Unit Delay'
+  /* Switch: '<S937>/Switch' incorporates:
+   *  Constant: '<S937>/Constant'
+   *  Constant: '<S951>/epsilon'
+   *  DataStoreRead: '<S937>/Текущее значение blower '
+   *  DataStoreRead: '<S937>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S937>/текущее время в мс'
+   *  DataStoreWrite: '<S872>/Data Store Write10'
+   *  Product: '<S937>/Product1'
+   *  Product: '<S937>/change rate (dtg//sec)'
+   *  Product: '<S937>/скорость в мс'
+   *  Product: '<S937>/шаг изменения'
+   *  RelationalOperator: '<S951>/Relational Operator'
+   *  RelationalOperator: '<S955>/Relational Operator'
+   *  Sum: '<S937>/Add'
+   *  Sum: '<S951>/Add'
+   *  Sum: '<S952>/Subtract'
+   *  Switch: '<S955>/Switch'
+   *  UnitDelay: '<S952>/Unit Delay'
    */
   if ((uint8_t)(*rtd_Dtg_FUL - *rtd_Dtg_logic_FUL) <= 0.01) {
     *rtd_Dtg_FUR = *rtd_Dtg_logic_FUL;
   } else {
     if (*rtd_Dtg_FUL <= *rtd_Dtg_logic_FUL) {
-      /* Switch: '<S909>/Switch' incorporates:
-       *  Constant: '<S909>/Constant'
+      /* Switch: '<S955>/Switch' incorporates:
+       *  Constant: '<S955>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S909>/Switch' incorporates:
-       *  Constant: '<S909>/Constant1'
+      /* Switch: '<S955>/Switch' incorporates:
+       *  Constant: '<S955>/Constant1'
        */
       tmp = -1;
     }
 
-    *rtd_Dtg_FUR = (uint8_t)((double)rtb_out_jj / (double)rtb_out_ir5 / 1000.0 *
+    *rtd_Dtg_FUR = (uint8_t)((double)rtb_out_oq / (double)rtb_out_ac / 1000.0 *
       (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_i) * (double)tmp + (double)*
       rtd_Dtg_FUL);
   }
 
-  /* End of Switch: '<S891>/Switch' */
+  /* End of Switch: '<S937>/Switch' */
 
-  /* DataStoreWrite: '<S826>/Data Store Write11' incorporates:
-   *  DataStoreWrite: '<S826>/Data Store Write10'
+  /* DataStoreWrite: '<S872>/Data Store Write11' incorporates:
+   *  DataStoreWrite: '<S872>/Data Store Write10'
    */
   *rtd_Dtg_FUL = *rtd_Dtg_FUR;
 
-  /* DataStoreWrite: '<S826>/Data Store Write' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read1'
-   *  MATLAB Function: '<S826>/incar filter up'
+  /* DataStoreWrite: '<S872>/Data Store Write' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read1'
+   *  MATLAB Function: '<S872>/incar filter up'
    */
   incarfilterup(*rtd_LEVEL, rtd_Incar_filter_up_value);
 
-  /* DataStoreWrite: '<S826>/Data Store Write1' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read2'
-   *  MATLAB Function: '<S826>/incar filter down'
+  /* DataStoreWrite: '<S872>/Data Store Write1' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read2'
+   *  MATLAB Function: '<S872>/incar filter down'
    */
   incarfilterdown(*rtd_LEVEL, rtd_Incar_filter_down_value);
 
-  /* DataStoreWrite: '<S826>/Data Store Write14' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read3'
-   *  MATLAB Function: '<S826>/autodemist (autodefog)'
+  /* DataStoreWrite: '<S872>/Data Store Write14' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read3'
+   *  MATLAB Function: '<S872>/autodemist (autodefog)'
    */
   autodemistautodefog(*rtd_LEVEL, rtd_Autodefog);
 
-  /* Sum: '<S915>/Add' incorporates:
-   *  DataStoreRead: '<S898>/Текущее значение blower '
-   *  DataStoreRead: '<S898>/значение auto (в соответствии с логикой)'
+  /* Sum: '<S961>/Add' incorporates:
+   *  DataStoreRead: '<S944>/Текущее значение blower '
+   *  DataStoreRead: '<S944>/значение auto (в соответствии с логикой)'
    */
-  rtb_out_jj = (uint8_t)(*rtd_Mode_FL - *rtd_Mode_logic_FL);
+  rtb_out_oq = (uint8_t)(*rtd_Mode_FL - *rtd_Mode_logic_FL);
 
-  /* MATLAB Function: '<S898>/step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read5'
+  /* MATLAB Function: '<S944>/step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read5'
    */
-  step_j(*rtd_LEVEL, &rtb_out_ir5);
+  step_j(*rtd_LEVEL, &rtb_out_ac);
 
-  /* MATLAB Function: '<S898>/time for step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read5'
+  /* MATLAB Function: '<S944>/time for step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read5'
    */
-  timeforstep_g(*rtd_LEVEL, &rtb_out_pr);
+  timeforstep_g(*rtd_LEVEL, &rtb_out_ln5);
 
-  /* Switch: '<S898>/Switch' incorporates:
-   *  Constant: '<S898>/Constant'
-   *  Constant: '<S915>/epsilon'
-   *  DataStoreRead: '<S898>/Текущее значение blower '
-   *  DataStoreRead: '<S898>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S898>/текущее время в мс'
-   *  DataStoreWrite: '<S826>/Data Store Write2'
-   *  Product: '<S898>/Product1'
-   *  Product: '<S898>/change rate (step//sec)'
-   *  Product: '<S898>/скорость в мс'
-   *  Product: '<S898>/шаг изменения'
-   *  RelationalOperator: '<S915>/Relational Operator'
-   *  RelationalOperator: '<S919>/Relational Operator'
-   *  Sum: '<S898>/Add'
-   *  Sum: '<S916>/Subtract'
-   *  Switch: '<S919>/Switch'
-   *  UnitDelay: '<S916>/Unit Delay'
+  /* Switch: '<S944>/Switch' incorporates:
+   *  Constant: '<S944>/Constant'
+   *  Constant: '<S961>/epsilon'
+   *  DataStoreRead: '<S944>/Текущее значение blower '
+   *  DataStoreRead: '<S944>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S944>/текущее время в мс'
+   *  DataStoreWrite: '<S872>/Data Store Write2'
+   *  Product: '<S944>/Product1'
+   *  Product: '<S944>/change rate (step//sec)'
+   *  Product: '<S944>/скорость в мс'
+   *  Product: '<S944>/шаг изменения'
+   *  RelationalOperator: '<S961>/Relational Operator'
+   *  RelationalOperator: '<S965>/Relational Operator'
+   *  Sum: '<S944>/Add'
+   *  Sum: '<S962>/Subtract'
+   *  Switch: '<S965>/Switch'
+   *  UnitDelay: '<S962>/Unit Delay'
    */
-  if (rtb_out_jj <= 0.01) {
+  if (rtb_out_oq <= 0.01) {
     *rtd_Mode_FR = *rtd_Mode_logic_FL;
   } else {
     if (*rtd_Mode_FL <= *rtd_Mode_logic_FL) {
-      /* Switch: '<S919>/Switch' incorporates:
-       *  Constant: '<S919>/Constant'
+      /* Switch: '<S965>/Switch' incorporates:
+       *  Constant: '<S965>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S919>/Switch' incorporates:
-       *  Constant: '<S919>/Constant1'
+      /* Switch: '<S965>/Switch' incorporates:
+       *  Constant: '<S965>/Constant1'
        */
       tmp = -1;
     }
 
-    *rtd_Mode_FR = (uint8_t)((double)rtb_out_ir5 / (double)rtb_out_pr / 1000.0 *
+    *rtd_Mode_FR = (uint8_t)((double)rtb_out_ac / (double)rtb_out_ln5 / 1000.0 *
       (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_j) * (double)tmp + (double)*
       rtd_Mode_FL);
   }
 
-  /* End of Switch: '<S898>/Switch' */
+  /* End of Switch: '<S944>/Switch' */
 
-  /* DataStoreWrite: '<S826>/Data Store Write3' incorporates:
-   *  DataStoreWrite: '<S826>/Data Store Write2'
+  /* DataStoreWrite: '<S872>/Data Store Write3' incorporates:
+   *  DataStoreWrite: '<S872>/Data Store Write2'
    */
   *rtd_Mode_FL = *rtd_Mode_FR;
 
-  /* MATLAB Function: '<S826>/window heating' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read6'
+  /* MATLAB Function: '<S872>/window heating' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read6'
    */
-  windowheating_k(*rtd_LEVEL, &rtb_out_jj);
+  windowheating_k(*rtd_LEVEL, &rtb_out_oq);
 
-  /* DataStoreWrite: '<S826>/Data Store Write4' */
-  *rtd_El_window_heating = rtb_out_jj;
+  /* DataStoreWrite: '<S872>/Data Store Write4' */
+  *rtd_El_window_heating = rtb_out_oq;
 
-  /* Sum: '<S910>/Add' incorporates:
-   *  DataStoreRead: '<S895>/Текущее значение blower '
-   *  DataStoreRead: '<S895>/значение auto (в соответствии с логикой)'
+  /* Sum: '<S956>/Add' incorporates:
+   *  DataStoreRead: '<S941>/Текущее значение blower '
+   *  DataStoreRead: '<S941>/значение auto (в соответствии с логикой)'
    */
-  rtb_out_as = (uint16_t)(*rtd_Blower_FL - *rtd_Blower_logic_FL);
+  rtb_out_ov4 = (uint16_t)(*rtd_Blower_FL - *rtd_Blower_logic_FL);
 
-  /* RelationalOperator: '<S910>/Relational Operator' incorporates:
-   *  Constant: '<S910>/epsilon'
+  /* RelationalOperator: '<S956>/Relational Operator' incorporates:
+   *  Constant: '<S956>/epsilon'
    */
-  rtb_Cond_prev_private_gh = (rtb_out_as <= 0.01);
+  rtb_Cond_prev_private_gh = (rtb_out_ov4 <= 0.01);
 
-  /* MATLAB Function: '<S895>/blower step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read7'
+  /* MATLAB Function: '<S941>/blower step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read7'
    */
   blowerstep(*rtd_LEVEL, &rtb_out_gqg);
 
-  /* MATLAB Function: '<S895>/blower time for step' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read7'
+  /* MATLAB Function: '<S941>/blower time for step' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read7'
    */
-  blowertimeforstep(*rtd_LEVEL, &rtb_out_as);
+  blowertimeforstep(*rtd_LEVEL, &rtb_out_ov4);
 
-  /* Switch: '<S895>/Switch' incorporates:
-   *  Constant: '<S895>/Constant'
-   *  DataStoreRead: '<S895>/Текущее значение blower '
-   *  DataStoreRead: '<S895>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S895>/текущее время в мс'
-   *  DataStoreWrite: '<S826>/Data Store Write5'
-   *  Product: '<S895>/Product1'
-   *  Product: '<S895>/change rate (step//sec)'
-   *  Product: '<S895>/скорость в мс'
-   *  Product: '<S895>/шаг изменения'
-   *  RelationalOperator: '<S914>/Relational Operator'
-   *  Sum: '<S895>/Add'
-   *  Sum: '<S911>/Subtract'
-   *  Switch: '<S914>/Switch'
-   *  UnitDelay: '<S911>/Unit Delay'
+  /* Switch: '<S941>/Switch' incorporates:
+   *  Constant: '<S941>/Constant'
+   *  DataStoreRead: '<S941>/Текущее значение blower '
+   *  DataStoreRead: '<S941>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S941>/текущее время в мс'
+   *  DataStoreWrite: '<S872>/Data Store Write5'
+   *  Product: '<S941>/Product1'
+   *  Product: '<S941>/change rate (step//sec)'
+   *  Product: '<S941>/скорость в мс'
+   *  Product: '<S941>/шаг изменения'
+   *  RelationalOperator: '<S960>/Relational Operator'
+   *  Sum: '<S941>/Add'
+   *  Sum: '<S957>/Subtract'
+   *  Switch: '<S960>/Switch'
+   *  UnitDelay: '<S957>/Unit Delay'
    */
   if (rtb_Cond_prev_private_gh) {
     *rtd_Blower_FR = *rtd_Blower_logic_FL;
   } else {
     if (*rtd_Blower_FL <= *rtd_Blower_logic_FL) {
-      /* Switch: '<S914>/Switch' incorporates:
-       *  Constant: '<S914>/Constant'
+      /* Switch: '<S960>/Switch' incorporates:
+       *  Constant: '<S960>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S914>/Switch' incorporates:
-       *  Constant: '<S914>/Constant1'
+      /* Switch: '<S960>/Switch' incorporates:
+       *  Constant: '<S960>/Constant1'
        */
       tmp = -1;
     }
 
-    *rtd_Blower_FR = (uint16_t)((double)rtb_out_gqg / (double)rtb_out_as /
+    *rtd_Blower_FR = (uint16_t)((double)rtb_out_gqg / (double)rtb_out_ov4 /
       1000.0 * (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_a) * (double)tmp
       + (double)*rtd_Blower_FL);
   }
 
-  /* End of Switch: '<S895>/Switch' */
+  /* End of Switch: '<S941>/Switch' */
 
-  /* DataStoreWrite: '<S826>/Data Store Write6' incorporates:
-   *  DataStoreWrite: '<S826>/Data Store Write5'
+  /* DataStoreWrite: '<S872>/Data Store Write6' incorporates:
+   *  DataStoreWrite: '<S872>/Data Store Write5'
    */
   *rtd_Blower_FL = *rtd_Blower_FR;
 
-  /* DataStoreWrite: '<S826>/Data Store Write7' incorporates:
-   *  Constant: '<S826>/Recirc logic Partial REC'
+  /* DataStoreWrite: '<S872>/Data Store Write7' incorporates:
+   *  Constant: '<S872>/Recirc logic Partial REC'
    */
   *rtd_Recirculation = 1.0;
 
-  /* RelationalOperator: '<S826>/Equal' incorporates:
-   *  DataStoreRead: '<S826>/current step'
+  /* RelationalOperator: '<S872>/Equal' incorporates:
+   *  DataStoreRead: '<S872>/current step'
    */
   rtb_Cond_prev_private_gh = (*rtd_step_start_controle_front == 2);
 
-  /* MATLAB Function: '<S826>/Time goto from step 2 to step 3 ' incorporates:
-   *  DataStoreRead: '<S826>/Data Store Read4'
+  /* MATLAB Function: '<S872>/Time goto from step 2 to step 3 ' incorporates:
+   *  DataStoreRead: '<S872>/Data Store Read4'
    */
   Timegotofromstep2tostep3(*rtd_LEVEL, &rtb_out_cw);
 
-  /* RelationalOperator: '<S826>/Relational Operator1' incorporates:
-   *  DataStoreRead: '<S892>/Data Store Read4'
-   *  Gain: '<S826>/из сек в мс'
-   *  Sum: '<S892>/Subtract'
-   *  UnitDelay: '<S892>/t_start_delay_private '
+  /* RelationalOperator: '<S872>/Relational Operator1' incorporates:
+   *  DataStoreRead: '<S938>/Data Store Read4'
+   *  Gain: '<S872>/из сек в мс'
+   *  Sum: '<S938>/Subtract'
+   *  UnitDelay: '<S938>/t_start_delay_private '
    */
   rtb_RelationalOperator1_df = (*rtd_t_now -
     localDW->t_start_delay_private_DSTATE > (uint32_t)(1000 * rtb_out_cw));
 
-  /* Switch: '<S892>/Switch' incorporates:
-   *  DataStoreRead: '<S892>/Data Store Read4'
-   *  Logic: '<S892>/Logical Operator3'
-   *  Logic: '<S892>/Logical Operator4'
-   *  UnitDelay: '<S892>/Cond_prev_private '
-   *  UnitDelay: '<S892>/t_start_delay_private '
+  /* Switch: '<S938>/Switch' incorporates:
+   *  DataStoreRead: '<S938>/Data Store Read4'
+   *  Logic: '<S938>/Logical Operator3'
+   *  Logic: '<S938>/Logical Operator4'
+   *  UnitDelay: '<S938>/Cond_prev_private '
+   *  UnitDelay: '<S938>/t_start_delay_private '
    */
   if (rtb_Cond_prev_private_gh && (!localDW->Cond_prev_private_DSTATE)) {
     localDW->t_start_delay_private_DSTATE = *rtd_t_now;
   }
 
-  /* End of Switch: '<S892>/Switch' */
+  /* End of Switch: '<S938>/Switch' */
 
-  /* Switch: '<S826>/Switch' incorporates:
-   *  Constant: '<S826>/go to next step'
-   *  Constant: '<S826>/stay at step'
-   *  DataStoreRead: '<S826>/Data Store Read'
-   *  Logic: '<S826>/Logical Operator'
+  /* Switch: '<S872>/Switch' incorporates:
+   *  Constant: '<S872>/go to next step'
+   *  Constant: '<S872>/stay at step'
+   *  DataStoreRead: '<S872>/Data Store Read'
+   *  Logic: '<S872>/Logical Operator'
    */
   if (rtb_RelationalOperator1_df || (*rtd_HI_logic_on)) {
     *rty_step = 3;
@@ -4050,55 +4229,55 @@ void Level3(int8_t *rty_step, uint8_t *rtd_Autodefog, uint16_t *rtd_Blower_FL,
     *rty_step = 2;
   }
 
-  /* End of Switch: '<S826>/Switch' */
+  /* End of Switch: '<S872>/Switch' */
 
-  /* Update for UnitDelay: '<S901>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S890>/текущее время в мс'
+  /* Update for UnitDelay: '<S947>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S936>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S906>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S891>/текущее время в мс'
+  /* Update for UnitDelay: '<S952>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S937>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE_i = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S916>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S898>/текущее время в мс'
+  /* Update for UnitDelay: '<S962>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S944>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE_j = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S911>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S895>/текущее время в мс'
+  /* Update for UnitDelay: '<S957>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S941>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE_a = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S892>/Cond_prev_private ' */
+  /* Update for UnitDelay: '<S938>/Cond_prev_private ' */
   localDW->Cond_prev_private_DSTATE = rtb_Cond_prev_private_gh;
 }
 
 /*
  * Output and update for action system:
- *    '<S720>/Step 3 F'
- *    '<S721>/Step 3 R'
+ *    '<S766>/Step 3 F'
+ *    '<S767>/Step 3 R'
  */
 void Step3F(int8_t *rty_step, int8_t *rtd_start_control_finished_front)
 {
-  /* DataStoreWrite: '<S726>/Data Store Write10' incorporates:
-   *  Constant: '<S726>/True'
+  /* DataStoreWrite: '<S772>/Data Store Write10' incorporates:
+   *  Constant: '<S772>/True'
    */
   *rtd_start_control_finished_front = 1;
 
-  /* SignalConversion generated from: '<S726>/step' incorporates:
-   *  Constant: '<S726>/Constant1'
+  /* SignalConversion generated from: '<S772>/step' incorporates:
+   *  Constant: '<S772>/Constant1'
    */
   *rty_step = 3;
 }
 
 /*
  * Output and update for atomic system:
- *    '<S987>/g_ausSTART_ENTER_SETTEMP'
- *    '<S988>/g_ausSTART_ENTER_SETTEMP'
- *    '<S989>/g_ausSTART_ENTER_SETTEMP'
+ *    '<S1033>/g_ausSTART_ENTER_SETTEMP'
+ *    '<S1034>/g_ausSTART_ENTER_SETTEMP'
+ *    '<S1035>/g_ausSTART_ENTER_SETTEMP'
  */
 void g_ausSTART_ENTER_SETTEMP_b(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -4127,11 +4306,11 @@ void g_ausSTART_ENTER_SETTEMP_b(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S988>/g_assSTART_ENTER_INCAR'
- *    '<S989>/g_assSTART_ENTER_INCAR'
- *    '<S990>/g_assSTART_ENTER_INCAR'
- *    '<S991>/g_assSTART_ENTER_INCAR'
- *    '<S992>/g_assSTART_ENTER_INCAR'
+ *    '<S1034>/g_assSTART_ENTER_INCAR'
+ *    '<S1035>/g_assSTART_ENTER_INCAR'
+ *    '<S1036>/g_assSTART_ENTER_INCAR'
+ *    '<S1037>/g_assSTART_ENTER_INCAR'
+ *    '<S1038>/g_assSTART_ENTER_INCAR'
  */
 void g_assSTART_ENTER_INCAR_p(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -4154,9 +4333,9 @@ void g_assSTART_ENTER_INCAR_p(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S990>/g_assSTART_ENTER_COOLANT '
- *    '<S991>/g_assSTART_ENTER_COOLANT '
- *    '<S992>/g_assSTART_ENTER_COOLANT '
+ *    '<S1036>/g_assSTART_ENTER_COOLANT '
+ *    '<S1037>/g_assSTART_ENTER_COOLANT '
+ *    '<S1038>/g_assSTART_ENTER_COOLANT '
  */
 void g_assSTART_ENTER_COOLANT_e(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -4173,55 +4352,55 @@ void g_assSTART_ENTER_COOLANT_e(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for action system:
- *    '<S982>/Level 4'
- *    '<S982>/Level 5'
+ *    '<S1028>/Level 4'
+ *    '<S1028>/Level 5'
  */
 void Level4_e(int8_t *rty_step1, const uint16_t *rtd_ECT, const int16_t
               *rtd_Incar_RR, const uint8_t *rtd_LEVEL, const double
               *rtd_MODE_RR_passenger)
 {
-  int16_t rtb_out_cv;
-  int16_t rtb_out_jz;
+  int16_t rtb_out_ef;
+  int16_t rtb_out_ntg;
 
-  /* MATLAB Function: '<S991>/g_assSTART_ENTER_INCAR' incorporates:
-   *  DataStoreRead: '<S991>/Data Store Read4'
+  /* MATLAB Function: '<S1037>/g_assSTART_ENTER_INCAR' incorporates:
+   *  DataStoreRead: '<S1037>/Data Store Read4'
    */
-  g_assSTART_ENTER_INCAR_p(*rtd_LEVEL, &rtb_out_jz);
+  g_assSTART_ENTER_INCAR_p(*rtd_LEVEL, &rtb_out_ntg);
 
-  /* MATLAB Function: '<S991>/g_assSTART_ENTER_COOLANT ' incorporates:
-   *  DataStoreRead: '<S991>/Data Store Read3'
+  /* MATLAB Function: '<S1037>/g_assSTART_ENTER_COOLANT ' incorporates:
+   *  DataStoreRead: '<S1037>/Data Store Read3'
    */
-  g_assSTART_ENTER_COOLANT_e(*rtd_LEVEL, &rtb_out_cv);
+  g_assSTART_ENTER_COOLANT_e(*rtd_LEVEL, &rtb_out_ef);
 
-  /* Switch: '<S991>/Switch' incorporates:
-   *  Constant: '<S991>/AUTO'
-   *  Constant: '<S991>/Constant'
-   *  Constant: '<S991>/Constant1'
-   *  DataStoreRead: '<S991>/Data Store Read'
-   *  DataStoreRead: '<S991>/Data Store Read1'
-   *  DataStoreRead: '<S991>/Data Store Read2'
-   *  Logic: '<S991>/AND'
-   *  Logic: '<S991>/AND1'
-   *  RelationalOperator: '<S991>/Relational Operator'
-   *  RelationalOperator: '<S991>/Relational Operator1'
-   *  RelationalOperator: '<S991>/Relational Operator2'
+  /* Switch: '<S1037>/Switch' incorporates:
+   *  Constant: '<S1037>/AUTO'
+   *  Constant: '<S1037>/Constant'
+   *  Constant: '<S1037>/Constant1'
+   *  DataStoreRead: '<S1037>/Data Store Read'
+   *  DataStoreRead: '<S1037>/Data Store Read1'
+   *  DataStoreRead: '<S1037>/Data Store Read2'
+   *  Logic: '<S1037>/AND'
+   *  Logic: '<S1037>/AND1'
+   *  RelationalOperator: '<S1037>/Relational Operator'
+   *  RelationalOperator: '<S1037>/Relational Operator1'
+   *  RelationalOperator: '<S1037>/Relational Operator2'
    */
-  if (((*rtd_Incar_RR < rtb_out_jz) || (*rtd_ECT < rtb_out_cv)) &&
+  if (((*rtd_Incar_RR < rtb_out_ntg) || (*rtd_ECT < rtb_out_ef)) &&
       (*rtd_MODE_RR_passenger == 1.0)) {
     *rty_step1 = 0;
   } else {
     *rty_step1 = -1;
   }
 
-  /* End of Switch: '<S991>/Switch' */
+  /* End of Switch: '<S1037>/Switch' */
 }
 
 /*
  * Output and update for atomic system:
- *    '<S1008>/incar filter down'
- *    '<S1009>/incar filter down'
- *    '<S1010>/incar filter down'
- *    '<S1011>/incar filter down'
+ *    '<S1054>/incar filter down'
+ *    '<S1055>/incar filter down'
+ *    '<S1056>/incar filter down'
+ *    '<S1057>/incar filter down'
  */
 void incarfilterdown_c(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4244,10 +4423,10 @@ void incarfilterdown_c(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1008>/incar filter up'
- *    '<S1009>/incar filter up'
- *    '<S1010>/incar filter up'
- *    '<S1011>/incar filter up'
+ *    '<S1054>/incar filter up'
+ *    '<S1055>/incar filter up'
+ *    '<S1056>/incar filter up'
+ *    '<S1057>/incar filter up'
  */
 void incarfilterup_i(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4270,9 +4449,9 @@ void incarfilterup_i(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1009>/g_assSTART_COOLANT_STEP0_TO_1 '
- *    '<S1010>/g_assSTART_COOLANT_STEP0_TO_1 '
- *    '<S1011>/g_assSTART_COOLANT_STEP0_TO_1 '
+ *    '<S1055>/g_assSTART_COOLANT_STEP0_TO_1 '
+ *    '<S1056>/g_assSTART_COOLANT_STEP0_TO_1 '
+ *    '<S1057>/g_assSTART_COOLANT_STEP0_TO_1 '
  */
 void g_assSTART_COOLANT_STEP0_TO_1_e(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -4289,8 +4468,8 @@ void g_assSTART_COOLANT_STEP0_TO_1_e(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for action system:
- *    '<S983>/Level 4'
- *    '<S983>/Level 5'
+ *    '<S1029>/Level 4'
+ *    '<S1029>/Level 5'
  */
 void Level4_m(int8_t *rty_step1, uint16_t *rtd_Blower_RL, uint16_t
               *rtd_Blower_RR, uint8_t *rtd_Dtg_RL, uint8_t *rtd_Dtg_RR, const
@@ -4299,84 +4478,84 @@ void Level4_m(int8_t *rty_step1, uint16_t *rtd_Blower_RL, uint16_t
               *rtd_Mode_RL, uint8_t *rtd_Mode_RR, uint8_t *rtd_Valve_2_way,
               uint8_t *rtd_Valve_3_way)
 {
-  int16_t rtb_out_pr;
+  int16_t rtb_out_ls;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write5' incorporates:
-   *  Constant: '<S1010>/Constant2'
+  /* DataStoreWrite: '<S1056>/Data Store Write5' incorporates:
+   *  Constant: '<S1056>/Constant2'
    */
   *rtd_Blower_RR = 10U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write6' incorporates:
-   *  Constant: '<S1010>/Constant3'
+  /* DataStoreWrite: '<S1056>/Data Store Write6' incorporates:
+   *  Constant: '<S1056>/Constant3'
    */
   *rtd_Blower_RL = 10U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write10' incorporates:
-   *  Constant: '<S1010>/Constant4'
+  /* DataStoreWrite: '<S1056>/Data Store Write10' incorporates:
+   *  Constant: '<S1056>/Constant4'
    */
   *rtd_Dtg_RR = 80U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write11' incorporates:
-   *  Constant: '<S1010>/Constant5'
+  /* DataStoreWrite: '<S1056>/Data Store Write11' incorporates:
+   *  Constant: '<S1056>/Constant5'
    */
   *rtd_Dtg_RL = 80U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write' incorporates:
-   *  DataStoreRead: '<S1010>/Data Store Read1'
-   *  MATLAB Function: '<S1010>/incar filter up'
+  /* DataStoreWrite: '<S1056>/Data Store Write' incorporates:
+   *  DataStoreRead: '<S1056>/Data Store Read1'
+   *  MATLAB Function: '<S1056>/incar filter up'
    */
   incarfilterup_i(*rtd_LEVEL, rtd_Incar_filter_up_value);
 
-  /* DataStoreWrite: '<S1010>/Data Store Write1' incorporates:
-   *  DataStoreRead: '<S1010>/Data Store Read2'
-   *  MATLAB Function: '<S1010>/incar filter down'
+  /* DataStoreWrite: '<S1056>/Data Store Write1' incorporates:
+   *  DataStoreRead: '<S1056>/Data Store Read2'
+   *  MATLAB Function: '<S1056>/incar filter down'
    */
   incarfilterdown_c(*rtd_LEVEL, rtd_Incar_filter_down_value);
 
-  /* DataStoreWrite: '<S1010>/Data Store Write2' incorporates:
-   *  Constant: '<S1010>/Mode - foot'
+  /* DataStoreWrite: '<S1056>/Data Store Write2' incorporates:
+   *  Constant: '<S1056>/Mode - foot'
    */
   *rtd_Mode_RR = 60U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write3' incorporates:
-   *  Constant: '<S1010>/Mode - foot'
+  /* DataStoreWrite: '<S1056>/Data Store Write3' incorporates:
+   *  Constant: '<S1056>/Mode - foot'
    */
   *rtd_Mode_RL = 60U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write8' incorporates:
-   *  Constant: '<S1010>/Valve open'
+  /* DataStoreWrite: '<S1056>/Data Store Write8' incorporates:
+   *  Constant: '<S1056>/Valve open'
    */
   *rtd_Valve_3_way = 1U;
 
-  /* DataStoreWrite: '<S1010>/Data Store Write9' incorporates:
-   *  Constant: '<S1010>/Valve open'
+  /* DataStoreWrite: '<S1056>/Data Store Write9' incorporates:
+   *  Constant: '<S1056>/Valve open'
    */
   *rtd_Valve_2_way = 1U;
 
-  /* MATLAB Function: '<S1010>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
-   *  DataStoreRead: '<S1010>/Data Store Read3'
+  /* MATLAB Function: '<S1056>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
+   *  DataStoreRead: '<S1056>/Data Store Read3'
    */
-  g_assSTART_COOLANT_STEP0_TO_1_e(*rtd_LEVEL, &rtb_out_pr);
+  g_assSTART_COOLANT_STEP0_TO_1_e(*rtd_LEVEL, &rtb_out_ls);
 
-  /* Switch: '<S1010>/Switch' incorporates:
-   *  DataStoreRead: '<S1010>/Engine coolant temp'
-   *  RelationalOperator: '<S1010>/Relational Operator'
+  /* Switch: '<S1056>/Switch' incorporates:
+   *  DataStoreRead: '<S1056>/Engine coolant temp'
+   *  RelationalOperator: '<S1056>/Relational Operator'
    */
-  *rty_step1 = (int8_t)(*rtd_ECT > rtb_out_pr);
+  *rty_step1 = (int8_t)(*rtd_ECT > rtb_out_ls);
 }
 
 /*
  * Output and update for atomic system:
- *    '<S1024>/2 way valve'
- *    '<S1025>/2 way valve'
- *    '<S1026>/2 way valve'
- *    '<S1027>/2 way valve'
- *    '<S1028>/2 way valve'
- *    '<S1029>/2 way valve'
- *    '<S1094>/2 way valve'
- *    '<S1095>/2 way valve'
- *    '<S1096>/2 way valve'
- *    '<S1097>/2 way valve'
+ *    '<S1070>/2 way valve'
+ *    '<S1071>/2 way valve'
+ *    '<S1072>/2 way valve'
+ *    '<S1073>/2 way valve'
+ *    '<S1074>/2 way valve'
+ *    '<S1075>/2 way valve'
+ *    '<S1140>/2 way valve'
+ *    '<S1141>/2 way valve'
+ *    '<S1142>/2 way valve'
+ *    '<S1143>/2 way valve'
  *    ...
  */
 void uwayvalve(uint8_t rtu_LVL, uint8_t *rty_out)
@@ -4394,12 +4573,12 @@ void uwayvalve(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1024>/Dtg_rear'
- *    '<S1025>/Dtg_rear'
- *    '<S1026>/Dtg_rear'
- *    '<S1027>/Dtg_rear'
- *    '<S1028>/Dtg_rear'
- *    '<S1029>/Dtg_rear'
+ *    '<S1070>/Dtg_rear'
+ *    '<S1071>/Dtg_rear'
+ *    '<S1072>/Dtg_rear'
+ *    '<S1073>/Dtg_rear'
+ *    '<S1074>/Dtg_rear'
+ *    '<S1075>/Dtg_rear'
  */
 void Dtg_rear(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4416,12 +4595,12 @@ void Dtg_rear(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1024>/Incar temp goto from step 1 to step 2 '
- *    '<S1025>/Incar temp goto from step 1 to step 2 '
- *    '<S1026>/Incar temp goto from step 1 to step 2 '
- *    '<S1027>/Incar temp goto from step 1 to step 2 '
- *    '<S1028>/Incar temp goto from step 1 to step 2 '
- *    '<S1029>/Incar temp goto from step 1 to step 2 '
+ *    '<S1070>/Incar temp goto from step 1 to step 2 '
+ *    '<S1071>/Incar temp goto from step 1 to step 2 '
+ *    '<S1072>/Incar temp goto from step 1 to step 2 '
+ *    '<S1073>/Incar temp goto from step 1 to step 2 '
+ *    '<S1074>/Incar temp goto from step 1 to step 2 '
+ *    '<S1075>/Incar temp goto from step 1 to step 2 '
  */
 void Incartempgotofromstep1tostep2_j(uint8_t rtu_LVL, int16_t *rty_out)
 {
@@ -4444,16 +4623,16 @@ void Incartempgotofromstep1tostep2_j(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1024>/Time goto from step 1 to step 2 '
- *    '<S1025>/Time goto from step 1 to step 2 '
- *    '<S1026>/Time goto from step 1 to step 2 '
- *    '<S1027>/Time goto from step 1 to step 2 '
- *    '<S1028>/Time goto from step 1 to step 2 '
- *    '<S1029>/Time goto from step 1 to step 2 '
- *    '<S1094>/Time goto from step 1 to step 2 '
- *    '<S1095>/Time goto from step 1 to step 2 '
- *    '<S1096>/Time goto from step 1 to step 2 '
- *    '<S1097>/Time goto from step 1 to step 2 '
+ *    '<S1070>/Time goto from step 1 to step 2 '
+ *    '<S1071>/Time goto from step 1 to step 2 '
+ *    '<S1072>/Time goto from step 1 to step 2 '
+ *    '<S1073>/Time goto from step 1 to step 2 '
+ *    '<S1074>/Time goto from step 1 to step 2 '
+ *    '<S1075>/Time goto from step 1 to step 2 '
+ *    '<S1140>/Time goto from step 1 to step 2 '
+ *    '<S1141>/Time goto from step 1 to step 2 '
+ *    '<S1142>/Time goto from step 1 to step 2 '
+ *    '<S1143>/Time goto from step 1 to step 2 '
  *    ...
  */
 void Timegotofromstep1tostep2_l(uint8_t rtu_LVL, int16_t *rty_out)
@@ -4483,12 +4662,12 @@ void Timegotofromstep1tostep2_l(uint8_t rtu_LVL, int16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1024>/mode rear step 1'
- *    '<S1025>/mode rear step 1'
- *    '<S1026>/mode rear step 1'
- *    '<S1027>/mode rear step 1'
- *    '<S1028>/mode rear step 1'
- *    '<S1029>/mode rear step 1'
+ *    '<S1070>/mode rear step 1'
+ *    '<S1071>/mode rear step 1'
+ *    '<S1072>/mode rear step 1'
+ *    '<S1073>/mode rear step 1'
+ *    '<S1074>/mode rear step 1'
+ *    '<S1075>/mode rear step 1'
  */
 void moderearstep1(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4511,8 +4690,8 @@ void moderearstep1(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for action system:
- *    '<S984>/Level 0'
- *    '<S984>/Level 1'
+ *    '<S1030>/Level 0'
+ *    '<S1030>/Level 1'
  */
 void Level0_b(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR,
               uint8_t *rtd_Dtg_RL, uint8_t *rtd_Dtg_RR, const int16_t
@@ -4528,40 +4707,40 @@ void Level0_b(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
   int16_t rtb_out_gb;
   int16_t rtb_out_kdi;
   uint16_t rtb_out_ne;
-  uint8_t rtb_out_jlu;
+  uint8_t rtb_out_hl;
   bool rtb_Equal_eo;
 
-  /* DataStoreWrite: '<S1024>/Data Store Write9' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read6'
-   *  MATLAB Function: '<S1024>/2 way valve'
+  /* DataStoreWrite: '<S1070>/Data Store Write9' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read6'
+   *  MATLAB Function: '<S1070>/2 way valve'
    */
   uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);
 
-  /* DataStoreWrite: '<S1024>/Data Store Write' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read1'
-   *  MATLAB Function: '<S1024>/incar filter up'
+  /* DataStoreWrite: '<S1070>/Data Store Write' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read1'
+   *  MATLAB Function: '<S1070>/incar filter up'
    */
   incarfilterup_i(*rtd_LEVEL, rtd_Incar_filter_up_value);
 
-  /* DataStoreWrite: '<S1024>/Data Store Write1' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read2'
-   *  MATLAB Function: '<S1024>/incar filter down'
+  /* DataStoreWrite: '<S1070>/Data Store Write1' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read2'
+   *  MATLAB Function: '<S1070>/incar filter down'
    */
   incarfilterdown_c(*rtd_LEVEL, rtd_Incar_filter_down_value);
 
-  /* MATLAB Function: '<S1024>/mode rear step 1' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read5'
+  /* MATLAB Function: '<S1070>/mode rear step 1' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read5'
    */
-  moderearstep1(*rtd_LEVEL, &rtb_out_jlu);
+  moderearstep1(*rtd_LEVEL, &rtb_out_hl);
 
-  /* DataStoreWrite: '<S1024>/Data Store Write2' */
-  *rtd_Mode_RR = rtb_out_jlu;
+  /* DataStoreWrite: '<S1070>/Data Store Write2' */
+  *rtd_Mode_RR = rtb_out_hl;
 
-  /* DataStoreWrite: '<S1024>/Data Store Write3' */
-  *rtd_Mode_RL = rtb_out_jlu;
+  /* DataStoreWrite: '<S1070>/Data Store Write3' */
+  *rtd_Mode_RL = rtb_out_hl;
 
-  /* MATLAB Function: '<S1024>/blower rear' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read7'
+  /* MATLAB Function: '<S1070>/blower rear' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read7'
    */
   /* :  out = g_ausSTART_BLR_AF_STEP12_R(LVL + 1); */
   tmp = (int32_t)(*rtd_LEVEL + 1U);
@@ -4571,72 +4750,72 @@ void Level0_b(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
 
   rtb_out_ne = g_ausSTART_BLR_AF_STEP12_R[tmp - 1];
 
-  /* End of MATLAB Function: '<S1024>/blower rear' */
+  /* End of MATLAB Function: '<S1070>/blower rear' */
 
-  /* DataStoreWrite: '<S1024>/Data Store Write5' */
+  /* DataStoreWrite: '<S1070>/Data Store Write5' */
   *rtd_Blower_RR = rtb_out_ne;
 
-  /* DataStoreWrite: '<S1024>/Data Store Write6' */
+  /* DataStoreWrite: '<S1070>/Data Store Write6' */
   *rtd_Blower_RL = rtb_out_ne;
 
-  /* MATLAB Function: '<S1024>/Dtg_rear' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read8'
+  /* MATLAB Function: '<S1070>/Dtg_rear' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read8'
    */
-  Dtg_rear(*rtd_LEVEL, &rtb_out_jlu);
+  Dtg_rear(*rtd_LEVEL, &rtb_out_hl);
 
-  /* DataStoreWrite: '<S1024>/Data Store Write10' */
-  *rtd_Dtg_RR = rtb_out_jlu;
+  /* DataStoreWrite: '<S1070>/Data Store Write10' */
+  *rtd_Dtg_RR = rtb_out_hl;
 
-  /* DataStoreWrite: '<S1024>/Data Store Write11' */
-  *rtd_Dtg_RL = rtb_out_jlu;
+  /* DataStoreWrite: '<S1070>/Data Store Write11' */
+  *rtd_Dtg_RL = rtb_out_hl;
 
-  /* DataStoreWrite: '<S1024>/Data Store Write7' incorporates:
-   *  Constant: '<S1024>/Recirc logic Partial REC'
+  /* DataStoreWrite: '<S1070>/Data Store Write7' incorporates:
+   *  Constant: '<S1070>/Recirc logic Partial REC'
    */
   *rtd_Recirculation = 1.0;
 
-  /* RelationalOperator: '<S1024>/Equal' incorporates:
-   *  DataStoreRead: '<S1024>/current step'
+  /* RelationalOperator: '<S1070>/Equal' incorporates:
+   *  DataStoreRead: '<S1070>/current step'
    */
   rtb_Equal_eo = (*rtd_step_start_controle_rear == 1);
 
-  /* MATLAB Function: '<S1024>/Incar temp goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read3'
+  /* MATLAB Function: '<S1070>/Incar temp goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read3'
    */
   Incartempgotofromstep1tostep2_j(*rtd_LEVEL, &rtb_out_kdi);
 
-  /* Sum: '<S1033>/Subtract' incorporates:
-   *  DataStoreRead: '<S1033>/Data Store Read4'
-   *  UnitDelay: '<S1033>/t_start_delay_private '
+  /* Sum: '<S1079>/Subtract' incorporates:
+   *  DataStoreRead: '<S1079>/Data Store Read4'
+   *  UnitDelay: '<S1079>/t_start_delay_private '
    */
   rtb_dt_b = *rtd_t_now - localDW->t_start_delay_private_DSTATE;
 
-  /* MATLAB Function: '<S1024>/Time goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S1024>/Data Store Read4'
+  /* MATLAB Function: '<S1070>/Time goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S1070>/Data Store Read4'
    */
   Timegotofromstep1tostep2_l(*rtd_LEVEL, &rtb_out_gb);
 
-  /* Switch: '<S1033>/Switch' incorporates:
-   *  DataStoreRead: '<S1033>/Data Store Read4'
-   *  Logic: '<S1033>/Logical Operator3'
-   *  Logic: '<S1033>/Logical Operator4'
-   *  UnitDelay: '<S1033>/Cond_prev_private '
-   *  UnitDelay: '<S1033>/t_start_delay_private '
+  /* Switch: '<S1079>/Switch' incorporates:
+   *  DataStoreRead: '<S1079>/Data Store Read4'
+   *  Logic: '<S1079>/Logical Operator3'
+   *  Logic: '<S1079>/Logical Operator4'
+   *  UnitDelay: '<S1079>/Cond_prev_private '
+   *  UnitDelay: '<S1079>/t_start_delay_private '
    */
   if (rtb_Equal_eo && (!localDW->Cond_prev_private_DSTATE)) {
     localDW->t_start_delay_private_DSTATE = *rtd_t_now;
   }
 
-  /* End of Switch: '<S1033>/Switch' */
+  /* End of Switch: '<S1079>/Switch' */
 
-  /* Switch: '<S1024>/Switch' incorporates:
-   *  Constant: '<S1024>/go to next step'
-   *  Constant: '<S1024>/stay at step 1'
-   *  DataStoreRead: '<S1024>/incar temp'
-   *  Gain: '<S1024>/из сек в мс'
-   *  Logic: '<S1024>/Logical Operator'
-   *  RelationalOperator: '<S1024>/Relational Operator'
-   *  RelationalOperator: '<S1024>/Relational Operator1'
+  /* Switch: '<S1070>/Switch' incorporates:
+   *  Constant: '<S1070>/go to next step'
+   *  Constant: '<S1070>/stay at step 1'
+   *  DataStoreRead: '<S1070>/incar temp'
+   *  Gain: '<S1070>/из сек в мс'
+   *  Logic: '<S1070>/Logical Operator'
+   *  RelationalOperator: '<S1070>/Relational Operator'
+   *  RelationalOperator: '<S1070>/Relational Operator1'
    */
   if ((*rtd_Incar_RR < rtb_out_kdi) || (rtb_dt_b > (uint16_t)(1000 * rtb_out_gb)))
   {
@@ -4645,18 +4824,18 @@ void Level0_b(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
     *rty_step = 1;
   }
 
-  /* End of Switch: '<S1024>/Switch' */
+  /* End of Switch: '<S1070>/Switch' */
 
-  /* Update for UnitDelay: '<S1033>/Cond_prev_private ' */
+  /* Update for UnitDelay: '<S1079>/Cond_prev_private ' */
   localDW->Cond_prev_private_DSTATE = rtb_Equal_eo;
 }
 
 /*
  * Output and update for atomic system:
- *    '<S1053>/blower start finish'
- *    '<S1065>/blower start finish'
- *    '<S1077>/blower start finish'
- *    '<S1088>/blower start finish'
+ *    '<S1099>/blower start finish'
+ *    '<S1111>/blower start finish'
+ *    '<S1123>/blower start finish'
+ *    '<S1134>/blower start finish'
  */
 void blowerstartfinish(uint8_t rtu_LVL, uint16_t rty_out[2])
 {
@@ -4687,9 +4866,9 @@ void blowerstartfinish(uint8_t rtu_LVL, uint16_t rty_out[2])
 
 /*
  * Output and update for atomic system:
- *    '<S1065>/ECT min max'
- *    '<S1077>/ECT min max'
- *    '<S1088>/ECT min max'
+ *    '<S1111>/ECT min max'
+ *    '<S1123>/ECT min max'
+ *    '<S1134>/ECT min max'
  */
 void ECTminmax_l(uint8_t rtu_LVL, int16_t rty_out[2])
 {
@@ -4709,8 +4888,8 @@ void ECTminmax_l(uint8_t rtu_LVL, int16_t rty_out[2])
 
 /*
  * Output and update for action system:
- *    '<S984>/Level 4'
- *    '<S984>/Level 5'
+ *    '<S1030>/Level 4'
+ *    '<S1030>/Level 5'
  */
 void Level4_d(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR,
               uint8_t *rtd_Dtg_RL, uint8_t *rtd_Dtg_RR, const uint16_t *rtd_ECT,
@@ -4729,115 +4908,115 @@ void Level4_d(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
   uint8_t rtb_out_gz;
   bool rtb_Equal_m3;
 
-  /* DataStoreWrite: '<S1028>/Data Store Write9' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read6'
-   *  MATLAB Function: '<S1028>/2 way valve'
+  /* DataStoreWrite: '<S1074>/Data Store Write9' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read6'
+   *  MATLAB Function: '<S1074>/2 way valve'
    */
   uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);
 
-  /* DataStoreWrite: '<S1028>/Data Store Write' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read1'
-   *  MATLAB Function: '<S1028>/incar filter up'
+  /* DataStoreWrite: '<S1074>/Data Store Write' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read1'
+   *  MATLAB Function: '<S1074>/incar filter up'
    */
   incarfilterup_i(*rtd_LEVEL, rtd_Incar_filter_up_value);
 
-  /* DataStoreWrite: '<S1028>/Data Store Write1' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read2'
-   *  MATLAB Function: '<S1028>/incar filter down'
+  /* DataStoreWrite: '<S1074>/Data Store Write1' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read2'
+   *  MATLAB Function: '<S1074>/incar filter down'
    */
   incarfilterdown_c(*rtd_LEVEL, rtd_Incar_filter_down_value);
 
-  /* MATLAB Function: '<S1028>/mode rear step 1' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read5'
+  /* MATLAB Function: '<S1074>/mode rear step 1' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read5'
    */
   moderearstep1(*rtd_LEVEL, &rtb_out_gz);
 
-  /* DataStoreWrite: '<S1028>/Data Store Write2' */
+  /* DataStoreWrite: '<S1074>/Data Store Write2' */
   *rtd_Mode_RR = rtb_out_gz;
 
-  /* DataStoreWrite: '<S1028>/Data Store Write3' */
+  /* DataStoreWrite: '<S1074>/Data Store Write3' */
   *rtd_Mode_RL = rtb_out_gz;
 
-  /* MATLAB Function: '<S1077>/blower start finish' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read7'
+  /* MATLAB Function: '<S1123>/blower start finish' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read7'
    */
   blowerstartfinish(*rtd_LEVEL, rtb_out_dq);
 
-  /* MATLAB Function: '<S1077>/ECT min max' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read7'
+  /* MATLAB Function: '<S1123>/ECT min max' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read7'
    */
   ECTminmax_l(*rtd_LEVEL, rtb_out_ij);
 
-  /* Lookup_n-D: '<S1077>/blower для текущего ECT' incorporates:
-   *  DataStoreRead: '<S1077>/engine coolant temp'
-   *  DataStoreWrite: '<S1028>/Data Store Write5'
+  /* Lookup_n-D: '<S1123>/blower для текущего ECT' incorporates:
+   *  DataStoreRead: '<S1123>/engine coolant temp'
+   *  DataStoreWrite: '<S1074>/Data Store Write5'
    */
   *rtd_Blower_RR = look1_iu16bs16lu64n32_binlcse(*rtd_ECT, rtb_out_ij,
     rtb_out_dq, 1U);
 
-  /* DataStoreWrite: '<S1028>/Data Store Write6' incorporates:
-   *  DataStoreWrite: '<S1028>/Data Store Write5'
+  /* DataStoreWrite: '<S1074>/Data Store Write6' incorporates:
+   *  DataStoreWrite: '<S1074>/Data Store Write5'
    */
   *rtd_Blower_RL = *rtd_Blower_RR;
 
-  /* MATLAB Function: '<S1028>/Dtg_rear' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read8'
+  /* MATLAB Function: '<S1074>/Dtg_rear' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read8'
    */
   Dtg_rear(*rtd_LEVEL, &rtb_out_gz);
 
-  /* DataStoreWrite: '<S1028>/Data Store Write10' */
+  /* DataStoreWrite: '<S1074>/Data Store Write10' */
   *rtd_Dtg_RR = rtb_out_gz;
 
-  /* DataStoreWrite: '<S1028>/Data Store Write11' */
+  /* DataStoreWrite: '<S1074>/Data Store Write11' */
   *rtd_Dtg_RL = rtb_out_gz;
 
-  /* DataStoreWrite: '<S1028>/Data Store Write7' incorporates:
-   *  Constant: '<S1028>/Recirc logic Partial REC'
+  /* DataStoreWrite: '<S1074>/Data Store Write7' incorporates:
+   *  Constant: '<S1074>/Recirc logic Partial REC'
    */
   *rtd_Recirculation = 1.0;
 
-  /* RelationalOperator: '<S1028>/Equal' incorporates:
-   *  DataStoreRead: '<S1028>/current step'
+  /* RelationalOperator: '<S1074>/Equal' incorporates:
+   *  DataStoreRead: '<S1074>/current step'
    */
   rtb_Equal_m3 = (*rtd_step_start_controle_rear == 1);
 
-  /* MATLAB Function: '<S1028>/Incar temp goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read3'
+  /* MATLAB Function: '<S1074>/Incar temp goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read3'
    */
   Incartempgotofromstep1tostep2_j(*rtd_LEVEL, &rtb_out_pf);
 
-  /* Sum: '<S1075>/Subtract' incorporates:
-   *  DataStoreRead: '<S1075>/Data Store Read4'
-   *  UnitDelay: '<S1075>/t_start_delay_private '
+  /* Sum: '<S1121>/Subtract' incorporates:
+   *  DataStoreRead: '<S1121>/Data Store Read4'
+   *  UnitDelay: '<S1121>/t_start_delay_private '
    */
   rtb_dt_ha = *rtd_t_now - localDW->t_start_delay_private_DSTATE;
 
-  /* MATLAB Function: '<S1028>/Time goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S1028>/Data Store Read4'
+  /* MATLAB Function: '<S1074>/Time goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S1074>/Data Store Read4'
    */
   Timegotofromstep1tostep2_l(*rtd_LEVEL, &rtb_out_ck);
 
-  /* Switch: '<S1075>/Switch' incorporates:
-   *  DataStoreRead: '<S1075>/Data Store Read4'
-   *  Logic: '<S1075>/Logical Operator3'
-   *  Logic: '<S1075>/Logical Operator4'
-   *  UnitDelay: '<S1075>/Cond_prev_private '
-   *  UnitDelay: '<S1075>/t_start_delay_private '
+  /* Switch: '<S1121>/Switch' incorporates:
+   *  DataStoreRead: '<S1121>/Data Store Read4'
+   *  Logic: '<S1121>/Logical Operator3'
+   *  Logic: '<S1121>/Logical Operator4'
+   *  UnitDelay: '<S1121>/Cond_prev_private '
+   *  UnitDelay: '<S1121>/t_start_delay_private '
    */
   if (rtb_Equal_m3 && (!localDW->Cond_prev_private_DSTATE)) {
     localDW->t_start_delay_private_DSTATE = *rtd_t_now;
   }
 
-  /* End of Switch: '<S1075>/Switch' */
+  /* End of Switch: '<S1121>/Switch' */
 
-  /* Switch: '<S1028>/Switch' incorporates:
-   *  Constant: '<S1028>/go to next step'
-   *  Constant: '<S1028>/stay at step 1'
-   *  DataStoreRead: '<S1028>/incar temp'
-   *  Gain: '<S1028>/из сек в мс'
-   *  Logic: '<S1028>/Logical Operator'
-   *  RelationalOperator: '<S1028>/Relational Operator'
-   *  RelationalOperator: '<S1028>/Relational Operator1'
+  /* Switch: '<S1074>/Switch' incorporates:
+   *  Constant: '<S1074>/go to next step'
+   *  Constant: '<S1074>/stay at step 1'
+   *  DataStoreRead: '<S1074>/incar temp'
+   *  Gain: '<S1074>/из сек в мс'
+   *  Logic: '<S1074>/Logical Operator'
+   *  RelationalOperator: '<S1074>/Relational Operator'
+   *  RelationalOperator: '<S1074>/Relational Operator1'
    */
   if ((*rtd_Incar_RR > rtb_out_pf) || (rtb_dt_ha > (uint16_t)(1000 * rtb_out_ck)))
   {
@@ -4846,20 +5025,20 @@ void Level4_d(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
     *rty_step = 1;
   }
 
-  /* End of Switch: '<S1028>/Switch' */
+  /* End of Switch: '<S1074>/Switch' */
 
-  /* Update for UnitDelay: '<S1075>/Cond_prev_private ' */
+  /* Update for UnitDelay: '<S1121>/Cond_prev_private ' */
   localDW->Cond_prev_private_DSTATE = rtb_Equal_m3;
 }
 
 /*
  * Output and update for atomic system:
- *    '<S1101>/time for step'
- *    '<S1124>/time for step'
  *    '<S1147>/time for step'
  *    '<S1170>/time for step'
  *    '<S1193>/time for step'
  *    '<S1216>/time for step'
+ *    '<S1239>/time for step'
+ *    '<S1262>/time for step'
  */
 void timeforstep_jn(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4882,12 +5061,12 @@ void timeforstep_jn(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1104>/blower step'
- *    '<S1127>/blower step'
  *    '<S1150>/blower step'
  *    '<S1173>/blower step'
  *    '<S1196>/blower step'
  *    '<S1219>/blower step'
+ *    '<S1242>/blower step'
+ *    '<S1265>/blower step'
  */
 void blowerstep_d(uint8_t rtu_LVL, uint16_t *rty_out)
 {
@@ -4904,12 +5083,12 @@ void blowerstep_d(uint8_t rtu_LVL, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1104>/blower time for step'
- *    '<S1127>/blower time for step'
  *    '<S1150>/blower time for step'
  *    '<S1173>/blower time for step'
  *    '<S1196>/blower time for step'
  *    '<S1219>/blower time for step'
+ *    '<S1242>/blower time for step'
+ *    '<S1265>/blower time for step'
  */
 void blowertimeforstep_l(uint8_t rtu_LVL, uint16_t *rty_out)
 {
@@ -4932,12 +5111,12 @@ void blowertimeforstep_l(uint8_t rtu_LVL, uint16_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1107>/step'
- *    '<S1130>/step'
  *    '<S1153>/step'
  *    '<S1176>/step'
  *    '<S1199>/step'
  *    '<S1222>/step'
+ *    '<S1245>/step'
+ *    '<S1268>/step'
  */
 void step_a(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4954,12 +5133,12 @@ void step_a(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for atomic system:
- *    '<S1107>/time for step'
- *    '<S1130>/time for step'
  *    '<S1153>/time for step'
  *    '<S1176>/time for step'
  *    '<S1199>/time for step'
  *    '<S1222>/time for step'
+ *    '<S1245>/time for step'
+ *    '<S1268>/time for step'
  */
 void timeforstep_h(uint8_t rtu_LVL, uint8_t *rty_out)
 {
@@ -4982,9 +5161,9 @@ void timeforstep_h(uint8_t rtu_LVL, uint8_t *rty_out)
 
 /*
  * Output and update for action system:
- *    '<S985>/Level 3'
- *    '<S985>/Level 4'
- *    '<S985>/Level 5'
+ *    '<S1031>/Level 3'
+ *    '<S1031>/Level 4'
+ *    '<S1031>/Level 5'
  */
 void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR,
               const uint16_t *rtd_Blower_logic_RR, uint8_t *rtd_Dtg_RL, uint8_t *
@@ -5005,52 +5184,52 @@ void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
   uint8_t rtb_out_i4;
   bool rtb_Cond_prev_private_e;
 
-  /* DataStoreWrite: '<S1097>/Data Store Write9' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read6'
-   *  MATLAB Function: '<S1097>/2 way valve'
+  /* DataStoreWrite: '<S1143>/Data Store Write9' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read6'
+   *  MATLAB Function: '<S1143>/2 way valve'
    */
   uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);
 
-  /* MATLAB Function: '<S1170>/step' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read8'
+  /* MATLAB Function: '<S1216>/step' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read8'
    */
   Dtg_rear(*rtd_LEVEL, &rtb_out_i4);
 
-  /* MATLAB Function: '<S1170>/time for step' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read8'
+  /* MATLAB Function: '<S1216>/time for step' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read8'
    */
   timeforstep_jn(*rtd_LEVEL, &rtb_out_cn);
 
-  /* Switch: '<S1170>/Switch' incorporates:
-   *  Constant: '<S1170>/Constant'
-   *  Constant: '<S1177>/epsilon'
-   *  DataStoreRead: '<S1170>/Текущее значение blower '
-   *  DataStoreRead: '<S1170>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S1170>/текущее время в мс'
-   *  DataStoreWrite: '<S1097>/Data Store Write10'
-   *  Product: '<S1170>/Product1'
-   *  Product: '<S1170>/change rate (dtg//sec)'
-   *  Product: '<S1170>/скорость в мс'
-   *  Product: '<S1170>/шаг изменения'
-   *  RelationalOperator: '<S1177>/Relational Operator'
-   *  RelationalOperator: '<S1181>/Relational Operator'
-   *  Sum: '<S1170>/Add'
-   *  Sum: '<S1177>/Add'
-   *  Sum: '<S1178>/Subtract'
-   *  Switch: '<S1181>/Switch'
-   *  UnitDelay: '<S1178>/Unit Delay'
+  /* Switch: '<S1216>/Switch' incorporates:
+   *  Constant: '<S1216>/Constant'
+   *  Constant: '<S1223>/epsilon'
+   *  DataStoreRead: '<S1216>/Текущее значение blower '
+   *  DataStoreRead: '<S1216>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S1216>/текущее время в мс'
+   *  DataStoreWrite: '<S1143>/Data Store Write10'
+   *  Product: '<S1216>/Product1'
+   *  Product: '<S1216>/change rate (dtg//sec)'
+   *  Product: '<S1216>/скорость в мс'
+   *  Product: '<S1216>/шаг изменения'
+   *  RelationalOperator: '<S1223>/Relational Operator'
+   *  RelationalOperator: '<S1227>/Relational Operator'
+   *  Sum: '<S1216>/Add'
+   *  Sum: '<S1223>/Add'
+   *  Sum: '<S1224>/Subtract'
+   *  Switch: '<S1227>/Switch'
+   *  UnitDelay: '<S1224>/Unit Delay'
    */
   if ((uint8_t)(*rtd_Dtg_RR - *rtd_Dtg_logic_RR) <= 0.01) {
     *rtd_Dtg_RR = *rtd_Dtg_logic_RR;
   } else {
     if (*rtd_Dtg_RR <= *rtd_Dtg_logic_RR) {
-      /* Switch: '<S1181>/Switch' incorporates:
-       *  Constant: '<S1181>/Constant'
+      /* Switch: '<S1227>/Switch' incorporates:
+       *  Constant: '<S1227>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S1181>/Switch' incorporates:
-       *  Constant: '<S1181>/Constant1'
+      /* Switch: '<S1227>/Switch' incorporates:
+       *  Constant: '<S1227>/Constant1'
        */
       tmp = -1;
     }
@@ -5060,73 +5239,73 @@ void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
       rtd_Dtg_RR);
   }
 
-  /* End of Switch: '<S1170>/Switch' */
+  /* End of Switch: '<S1216>/Switch' */
 
-  /* DataStoreWrite: '<S1097>/Data Store Write11' incorporates:
-   *  DataStoreWrite: '<S1097>/Data Store Write10'
+  /* DataStoreWrite: '<S1143>/Data Store Write11' incorporates:
+   *  DataStoreWrite: '<S1143>/Data Store Write10'
    */
   *rtd_Dtg_RL = *rtd_Dtg_RR;
 
-  /* DataStoreWrite: '<S1097>/Data Store Write' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read1'
-   *  MATLAB Function: '<S1097>/incar filter up'
+  /* DataStoreWrite: '<S1143>/Data Store Write' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read1'
+   *  MATLAB Function: '<S1143>/incar filter up'
    */
   incarfilterup_i(*rtd_LEVEL, rtd_Incar_filter_up_value);
 
-  /* DataStoreWrite: '<S1097>/Data Store Write1' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read2'
-   *  MATLAB Function: '<S1097>/incar filter down'
+  /* DataStoreWrite: '<S1143>/Data Store Write1' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read2'
+   *  MATLAB Function: '<S1143>/incar filter down'
    */
   incarfilterdown_c(*rtd_LEVEL, rtd_Incar_filter_down_value);
 
-  /* Sum: '<S1187>/Add' incorporates:
-   *  DataStoreRead: '<S1176>/Текущее значение blower '
-   *  DataStoreRead: '<S1176>/значение auto (в соответствии с логикой)'
+  /* Sum: '<S1233>/Add' incorporates:
+   *  DataStoreRead: '<S1222>/Текущее значение blower '
+   *  DataStoreRead: '<S1222>/значение auto (в соответствии с логикой)'
    */
   rtb_out_i4 = (uint8_t)(*rtd_Mode_RR - *rtd_Mode_logic_RR);
 
-  /* RelationalOperator: '<S1187>/Relational Operator' incorporates:
-   *  Constant: '<S1187>/epsilon'
+  /* RelationalOperator: '<S1233>/Relational Operator' incorporates:
+   *  Constant: '<S1233>/epsilon'
    */
   rtb_Cond_prev_private_e = (rtb_out_i4 <= 0.01);
 
-  /* MATLAB Function: '<S1176>/step' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read5'
+  /* MATLAB Function: '<S1222>/step' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read5'
    */
   step_a(*rtd_LEVEL, &rtb_out_cn);
 
-  /* MATLAB Function: '<S1176>/time for step' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read5'
+  /* MATLAB Function: '<S1222>/time for step' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read5'
    */
   timeforstep_h(*rtd_LEVEL, &rtb_out_i4);
 
-  /* Switch: '<S1176>/Switch' incorporates:
-   *  Constant: '<S1176>/Constant'
-   *  DataStoreRead: '<S1176>/Текущее значение blower '
-   *  DataStoreRead: '<S1176>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S1176>/текущее время в мс'
-   *  DataStoreWrite: '<S1097>/Data Store Write2'
-   *  Product: '<S1176>/Product1'
-   *  Product: '<S1176>/change rate (step//sec)'
-   *  Product: '<S1176>/скорость в мс'
-   *  Product: '<S1176>/шаг изменения'
-   *  RelationalOperator: '<S1191>/Relational Operator'
-   *  Sum: '<S1176>/Add'
-   *  Sum: '<S1188>/Subtract'
-   *  Switch: '<S1191>/Switch'
-   *  UnitDelay: '<S1188>/Unit Delay'
+  /* Switch: '<S1222>/Switch' incorporates:
+   *  Constant: '<S1222>/Constant'
+   *  DataStoreRead: '<S1222>/Текущее значение blower '
+   *  DataStoreRead: '<S1222>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S1222>/текущее время в мс'
+   *  DataStoreWrite: '<S1143>/Data Store Write2'
+   *  Product: '<S1222>/Product1'
+   *  Product: '<S1222>/change rate (step//sec)'
+   *  Product: '<S1222>/скорость в мс'
+   *  Product: '<S1222>/шаг изменения'
+   *  RelationalOperator: '<S1237>/Relational Operator'
+   *  Sum: '<S1222>/Add'
+   *  Sum: '<S1234>/Subtract'
+   *  Switch: '<S1237>/Switch'
+   *  UnitDelay: '<S1234>/Unit Delay'
    */
   if (rtb_Cond_prev_private_e) {
     *rtd_Mode_RR = *rtd_Mode_logic_RR;
   } else {
     if (*rtd_Mode_RR <= *rtd_Mode_logic_RR) {
-      /* Switch: '<S1191>/Switch' incorporates:
-       *  Constant: '<S1191>/Constant'
+      /* Switch: '<S1237>/Switch' incorporates:
+       *  Constant: '<S1237>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S1191>/Switch' incorporates:
-       *  Constant: '<S1191>/Constant1'
+      /* Switch: '<S1237>/Switch' incorporates:
+       *  Constant: '<S1237>/Constant1'
        */
       tmp = -1;
     }
@@ -5136,53 +5315,53 @@ void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
       rtd_Mode_RR);
   }
 
-  /* End of Switch: '<S1176>/Switch' */
+  /* End of Switch: '<S1222>/Switch' */
 
-  /* DataStoreWrite: '<S1097>/Data Store Write3' incorporates:
-   *  DataStoreWrite: '<S1097>/Data Store Write2'
+  /* DataStoreWrite: '<S1143>/Data Store Write3' incorporates:
+   *  DataStoreWrite: '<S1143>/Data Store Write2'
    */
   *rtd_Mode_RL = *rtd_Mode_RR;
 
-  /* MATLAB Function: '<S1173>/blower step' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read7'
+  /* MATLAB Function: '<S1219>/blower step' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read7'
    */
   blowerstep_d(*rtd_LEVEL, &rtb_out_gx);
 
-  /* MATLAB Function: '<S1173>/blower time for step' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read7'
+  /* MATLAB Function: '<S1219>/blower time for step' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read7'
    */
   blowertimeforstep_l(*rtd_LEVEL, &rtb_out_bz);
 
-  /* Switch: '<S1173>/Switch' incorporates:
-   *  Constant: '<S1173>/Constant'
-   *  Constant: '<S1182>/epsilon'
-   *  DataStoreRead: '<S1173>/Текущее значение blower '
-   *  DataStoreRead: '<S1173>/значение auto (в соответствии с логикой)'
-   *  DataStoreRead: '<S1173>/текущее время в мс'
-   *  DataStoreWrite: '<S1097>/Data Store Write5'
-   *  Product: '<S1173>/Product1'
-   *  Product: '<S1173>/change rate (step//sec)'
-   *  Product: '<S1173>/скорость в мс'
-   *  Product: '<S1173>/шаг изменения'
-   *  RelationalOperator: '<S1182>/Relational Operator'
-   *  RelationalOperator: '<S1186>/Relational Operator'
-   *  Sum: '<S1173>/Add'
-   *  Sum: '<S1182>/Add'
-   *  Sum: '<S1183>/Subtract'
-   *  Switch: '<S1186>/Switch'
-   *  UnitDelay: '<S1183>/Unit Delay'
+  /* Switch: '<S1219>/Switch' incorporates:
+   *  Constant: '<S1219>/Constant'
+   *  Constant: '<S1228>/epsilon'
+   *  DataStoreRead: '<S1219>/Текущее значение blower '
+   *  DataStoreRead: '<S1219>/значение auto (в соответствии с логикой)'
+   *  DataStoreRead: '<S1219>/текущее время в мс'
+   *  DataStoreWrite: '<S1143>/Data Store Write5'
+   *  Product: '<S1219>/Product1'
+   *  Product: '<S1219>/change rate (step//sec)'
+   *  Product: '<S1219>/скорость в мс'
+   *  Product: '<S1219>/шаг изменения'
+   *  RelationalOperator: '<S1228>/Relational Operator'
+   *  RelationalOperator: '<S1232>/Relational Operator'
+   *  Sum: '<S1219>/Add'
+   *  Sum: '<S1228>/Add'
+   *  Sum: '<S1229>/Subtract'
+   *  Switch: '<S1232>/Switch'
+   *  UnitDelay: '<S1229>/Unit Delay'
    */
   if ((uint16_t)(*rtd_Blower_RR - *rtd_Blower_logic_RR) <= 0.01) {
     *rtd_Blower_RR = *rtd_Blower_logic_RR;
   } else {
     if (*rtd_Blower_RR <= *rtd_Blower_logic_RR) {
-      /* Switch: '<S1186>/Switch' incorporates:
-       *  Constant: '<S1186>/Constant'
+      /* Switch: '<S1232>/Switch' incorporates:
+       *  Constant: '<S1232>/Constant'
        */
       tmp = 1;
     } else {
-      /* Switch: '<S1186>/Switch' incorporates:
-       *  Constant: '<S1186>/Constant1'
+      /* Switch: '<S1232>/Switch' incorporates:
+       *  Constant: '<S1232>/Constant1'
        */
       tmp = -1;
     }
@@ -5192,54 +5371,54 @@ void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
       (double)*rtd_Blower_RR);
   }
 
-  /* End of Switch: '<S1173>/Switch' */
+  /* End of Switch: '<S1219>/Switch' */
 
-  /* DataStoreWrite: '<S1097>/Data Store Write6' incorporates:
-   *  DataStoreWrite: '<S1097>/Data Store Write5'
+  /* DataStoreWrite: '<S1143>/Data Store Write6' incorporates:
+   *  DataStoreWrite: '<S1143>/Data Store Write5'
    */
   *rtd_Blower_RL = *rtd_Blower_RR;
 
-  /* DataStoreWrite: '<S1097>/Data Store Write7' incorporates:
-   *  Constant: '<S1097>/Recirc logic Partial REC'
+  /* DataStoreWrite: '<S1143>/Data Store Write7' incorporates:
+   *  Constant: '<S1143>/Recirc logic Partial REC'
    */
   *rtd_Recirculation = 1.0;
 
-  /* RelationalOperator: '<S1097>/Equal' incorporates:
-   *  DataStoreRead: '<S1097>/current step'
+  /* RelationalOperator: '<S1143>/Equal' incorporates:
+   *  DataStoreRead: '<S1143>/current step'
    */
   rtb_Cond_prev_private_e = (*rtd_step_start_controle_rear == 2);
 
-  /* Sum: '<S1171>/Subtract' incorporates:
-   *  DataStoreRead: '<S1171>/Data Store Read4'
-   *  UnitDelay: '<S1171>/t_start_delay_private '
+  /* Sum: '<S1217>/Subtract' incorporates:
+   *  DataStoreRead: '<S1217>/Data Store Read4'
+   *  UnitDelay: '<S1217>/t_start_delay_private '
    */
   rtb_dt_ho = *rtd_t_now - localDW->t_start_delay_private_DSTATE;
 
-  /* MATLAB Function: '<S1097>/Time goto from step 1 to step 2 ' incorporates:
-   *  DataStoreRead: '<S1097>/Data Store Read4'
+  /* MATLAB Function: '<S1143>/Time goto from step 1 to step 2 ' incorporates:
+   *  DataStoreRead: '<S1143>/Data Store Read4'
    */
   Timegotofromstep1tostep2_l(*rtd_LEVEL, &rtb_out_cw);
 
-  /* Switch: '<S1171>/Switch' incorporates:
-   *  DataStoreRead: '<S1171>/Data Store Read4'
-   *  Logic: '<S1171>/Logical Operator3'
-   *  Logic: '<S1171>/Logical Operator4'
-   *  UnitDelay: '<S1171>/Cond_prev_private '
-   *  UnitDelay: '<S1171>/t_start_delay_private '
+  /* Switch: '<S1217>/Switch' incorporates:
+   *  DataStoreRead: '<S1217>/Data Store Read4'
+   *  Logic: '<S1217>/Logical Operator3'
+   *  Logic: '<S1217>/Logical Operator4'
+   *  UnitDelay: '<S1217>/Cond_prev_private '
+   *  UnitDelay: '<S1217>/t_start_delay_private '
    */
   if (rtb_Cond_prev_private_e && (!localDW->Cond_prev_private_DSTATE)) {
     localDW->t_start_delay_private_DSTATE = *rtd_t_now;
   }
 
-  /* End of Switch: '<S1171>/Switch' */
+  /* End of Switch: '<S1217>/Switch' */
 
-  /* Switch: '<S1097>/Switch' incorporates:
-   *  Constant: '<S1097>/go to next step'
-   *  Constant: '<S1097>/stay at step'
-   *  DataStoreRead: '<S1097>/Data Store Read'
-   *  Gain: '<S1097>/из сек в мс'
-   *  Logic: '<S1097>/Logical Operator'
-   *  RelationalOperator: '<S1097>/Relational Operator1'
+  /* Switch: '<S1143>/Switch' incorporates:
+   *  Constant: '<S1143>/go to next step'
+   *  Constant: '<S1143>/stay at step'
+   *  DataStoreRead: '<S1143>/Data Store Read'
+   *  Gain: '<S1143>/из сек в мс'
+   *  Logic: '<S1143>/Logical Operator'
+   *  RelationalOperator: '<S1143>/Relational Operator1'
    */
   if ((rtb_dt_ho > (uint16_t)(1000 * rtb_out_cw)) || (*rtd_HI_logic_on)) {
     *rty_step = 3;
@@ -5247,24 +5426,24 @@ void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR
     *rty_step = 2;
   }
 
-  /* End of Switch: '<S1097>/Switch' */
+  /* End of Switch: '<S1143>/Switch' */
 
-  /* Update for UnitDelay: '<S1178>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S1170>/текущее время в мс'
+  /* Update for UnitDelay: '<S1224>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S1216>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S1188>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S1176>/текущее время в мс'
+  /* Update for UnitDelay: '<S1234>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S1222>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE_i = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S1183>/Unit Delay' incorporates:
-   *  DataStoreRead: '<S1173>/текущее время в мс'
+  /* Update for UnitDelay: '<S1229>/Unit Delay' incorporates:
+   *  DataStoreRead: '<S1219>/текущее время в мс'
    */
   localDW->UnitDelay_DSTATE_e = *rtd_t_now;
 
-  /* Update for UnitDelay: '<S1171>/Cond_prev_private ' */
+  /* Update for UnitDelay: '<S1217>/Cond_prev_private ' */
   localDW->Cond_prev_private_DSTATE = rtb_Cond_prev_private_e;
 }
 
@@ -5279,11 +5458,11 @@ void HVAC_model_step(void)
   double rtb_Divide6;
   double rtb_Divide8;
   int32_t i;
-  int32_t q0;
+  int32_t y;
   uint32_t rtb_dt_fa;
   uint32_t rtb_dt_ih;
   int16_t tmp[6];
-  int16_t rtb_out_hl[2];
+  int16_t rtb_out_j4[2];
   int16_t AMB;
   int16_t Duct1_F;
   int16_t Duct1_R;
@@ -5304,27 +5483,28 @@ void HVAC_model_step(void)
   int16_t Pressure;
   uint16_t Merge[9];
   uint16_t rtb_vals_m[9];
-  uint16_t rtb_out_he[2];
-  uint16_t rtb_out_bc;
-  uint16_t rtb_out_cb;
-  uint16_t rtb_out_d;
-  uint16_t rtb_out_ee;
-  uint16_t rtb_out_fm;
-  uint16_t rtb_out_hi;
-  uint16_t rtb_out_hz;
-  uint16_t rtb_out_i4;
+  uint16_t rtb_out_jq[2];
+  uint16_t FIU_SET_RR;
+  uint16_t rtb_out_b5;
+  uint16_t rtb_out_bko;
+  uint16_t rtb_out_e0;
+  uint16_t rtb_out_h;
+  uint16_t rtb_out_iir;
+  uint16_t rtb_out_jn;
+  uint16_t rtb_out_oc;
+  uint16_t rtb_out_pd;
   int8_t rtb_Switch_hx;
   uint8_t rtb_get_modes_for_levels[78];
   uint8_t Actuator_pos_percent_Ch0[9];
-  uint8_t rtb_DataTypeConversion_c1[9];
-  uint8_t rtb_DataTypeConversion_np[9];
+  uint8_t rtb_DataTypeConversion_md[9];
   uint8_t rtb_DataTypeConversion_ns[9];
+  uint8_t rtb_VectorConcatenate_c[9];
   uint8_t Autodefog;
   uint8_t Dtg_FUR;
   uint8_t El_window_heating;
   uint8_t Mode_FR;
   uint8_t Valve_2_way;
-  uint8_t rtb_Gain2_c;
+  uint8_t rtb_Gain2_hu;
   uint8_t rtb_Gain_ge;
   uint8_t rtb_u_cuz;
   bool rtb_LogicalOperator3_a0[9];
@@ -5412,7 +5592,7 @@ void HVAC_model_step(void)
     AMB = 100;
   } else {
     AMB = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Ambient_Temp,
-      rtConstP.pooled45, rtConstP.uDLookupTable_tableData, 1023U);
+      rtConstP.pooled47, rtConstP.uDLookupTable_tableData, 1023U);
   }
 
   /* End of Switch: '<S253>/Switch' */
@@ -5526,7 +5706,7 @@ void HVAC_model_step(void)
     Eva_F = -100;
   } else {
     Eva_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Evap_Temp,
-      rtConstP.pooled45, rtConstP.pooled3, 1023U);
+      rtConstP.pooled47, rtConstP.pooled3, 1023U);
   }
 
   /* End of Switch: '<S254>/Switch' */
@@ -5640,7 +5820,7 @@ void HVAC_model_step(void)
     Eva_R = -100;
   } else {
     Eva_R = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Evap_Temp,
-      rtConstP.pooled45, rtConstP.pooled3, 1023U);
+      rtConstP.pooled47, rtConstP.pooled3, 1023U);
   }
 
   /* End of Switch: '<S255>/Switch' */
@@ -5754,7 +5934,7 @@ void HVAC_model_step(void)
     Pressure = 32;
   } else {
     Pressure = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_AC_Pressure,
-      rtConstP.pooled45, rtConstP.uDLookupTable_tableData_a, 1023U);
+      rtConstP.pooled47, rtConstP.uDLookupTable_tableData_a, 1023U);
   }
 
   /* End of Switch: '<S271>/Switch' */
@@ -5868,7 +6048,7 @@ void HVAC_model_step(void)
     Duct2_F = 230;
   } else {
     Duct2_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Front_Duct2,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S272>/Switch2' */
@@ -5914,7 +6094,7 @@ void HVAC_model_step(void)
     Duct1_F = 230;
   } else {
     Duct1_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Front_Duct1,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S272>/Switch1' */
@@ -5960,7 +6140,7 @@ void HVAC_model_step(void)
     Duct3_F = 230;
   } else {
     Duct3_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Front_Duct3,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S272>/Switch3' */
@@ -6006,7 +6186,7 @@ void HVAC_model_step(void)
     Duct4_F = 230;
   } else {
     Duct4_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Front_Duct4,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S272>/Switch4' */
@@ -6052,7 +6232,7 @@ void HVAC_model_step(void)
     Duct5_F = 230;
   } else {
     Duct5_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Duct5,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S272>/Switch5' */
@@ -6098,7 +6278,7 @@ void HVAC_model_step(void)
     Duct6_F = 230;
   } else {
     Duct6_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Duct6,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S272>/Switch6' */
@@ -6552,7 +6732,7 @@ void HVAC_model_step(void)
     Duct1_R = 230;
   } else {
     Duct1_R = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Duct1,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S279>/Switch' */
@@ -6598,7 +6778,7 @@ void HVAC_model_step(void)
     Duct2_R = 230;
   } else {
     Duct2_R = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Duct2,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S279>/Switch1' */
@@ -6644,7 +6824,7 @@ void HVAC_model_step(void)
     Duct3_R = 230;
   } else {
     Duct3_R = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Duct3,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S279>/Switch2' */
@@ -6690,7 +6870,7 @@ void HVAC_model_step(void)
     Duct4_R = 230;
   } else {
     Duct4_R = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Duct4,
-      rtConstP.pooled45, rtConstP.pooled4, 1023U);
+      rtConstP.pooled47, rtConstP.pooled4, 1023U);
   }
 
   /* End of Switch: '<S279>/Switch3' */
@@ -6815,12 +6995,12 @@ void HVAC_model_step(void)
   /* :  if(LOGGER) */
   if (rtDW.LOGGER_ACP != 0.0) {
     /* :  fprintf('Duct1_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
-    rtb_out_ee = rtDW.ADC_Data_Model.Sensor_Rear_Duct1;
+    rtb_out_oc = rtDW.ADC_Data_Model.Sensor_Rear_Duct1;
     if (rtDW.ADC_Data_Model.Sensor_Rear_Duct1 > 32767) {
-      rtb_out_ee = 32767U;
+      rtb_out_oc = 32767U;
     }
 
-    printf("Duct1_R = %d * 0.1 C %d V\n", Duct1_R, (int16_t)rtb_out_ee);
+    printf("Duct1_R = %d * 0.1 C %d V\n", Duct1_R, (int16_t)rtb_out_oc);
     fflush(stdout);
   }
 
@@ -6834,12 +7014,12 @@ void HVAC_model_step(void)
   /* :  if(LOGGER) */
   if (rtDW.LOGGER_ACP != 0.0) {
     /* :  fprintf('Duct2_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
-    rtb_out_ee = rtDW.ADC_Data_Model.Sensor_Rear_Duct2;
+    rtb_out_oc = rtDW.ADC_Data_Model.Sensor_Rear_Duct2;
     if (rtDW.ADC_Data_Model.Sensor_Rear_Duct2 > 32767) {
-      rtb_out_ee = 32767U;
+      rtb_out_oc = 32767U;
     }
 
-    printf("Duct2_R = %d * 0.1 C %d V\n", Duct2_R, (int16_t)rtb_out_ee);
+    printf("Duct2_R = %d * 0.1 C %d V\n", Duct2_R, (int16_t)rtb_out_oc);
     fflush(stdout);
   }
 
@@ -6853,12 +7033,12 @@ void HVAC_model_step(void)
   /* :  if(LOGGER) */
   if (rtDW.LOGGER_ACP != 0.0) {
     /* :  fprintf('Duct3_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
-    rtb_out_ee = rtDW.ADC_Data_Model.Sensor_Rear_Duct3;
+    rtb_out_oc = rtDW.ADC_Data_Model.Sensor_Rear_Duct3;
     if (rtDW.ADC_Data_Model.Sensor_Rear_Duct3 > 32767) {
-      rtb_out_ee = 32767U;
+      rtb_out_oc = 32767U;
     }
 
-    printf("Duct3_R = %d * 0.1 C %d V\n", Duct3_R, (int16_t)rtb_out_ee);
+    printf("Duct3_R = %d * 0.1 C %d V\n", Duct3_R, (int16_t)rtb_out_oc);
     fflush(stdout);
   }
 
@@ -6872,12 +7052,12 @@ void HVAC_model_step(void)
   /* :  if(LOGGER) */
   if (rtDW.LOGGER_ACP != 0.0) {
     /* :  fprintf('Duct4_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
-    rtb_out_ee = rtDW.ADC_Data_Model.Sensor_Rear_Duct4;
+    rtb_out_oc = rtDW.ADC_Data_Model.Sensor_Rear_Duct4;
     if (rtDW.ADC_Data_Model.Sensor_Rear_Duct4 > 32767) {
-      rtb_out_ee = 32767U;
+      rtb_out_oc = 32767U;
     }
 
-    printf("Duct4_R = %d * 0.1 C %d V\n", Duct4_R, (int16_t)rtb_out_ee);
+    printf("Duct4_R = %d * 0.1 C %d V\n", Duct4_R, (int16_t)rtb_out_oc);
     fflush(stdout);
   }
 
@@ -7032,7 +7212,7 @@ void HVAC_model_step(void)
     Incar_FL = 200;
   } else {
     Incar_FL = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_FL,
-      rtConstP.pooled45, rtConstP.pooled5, 1023U);
+      rtConstP.pooled47, rtConstP.pooled5, 1023U);
   }
 
   /* End of Switch: '<S280>/Switch' */
@@ -7078,7 +7258,7 @@ void HVAC_model_step(void)
     Incar_RL = 200;
   } else {
     Incar_RL = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_RL,
-      rtConstP.pooled45, rtConstP.pooled5, 1023U);
+      rtConstP.pooled47, rtConstP.pooled5, 1023U);
   }
 
   /* End of Switch: '<S280>/Switch1' */
@@ -7260,7 +7440,7 @@ void HVAC_model_step(void)
     Incar_FR = 200;
   } else {
     Incar_FR = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_FR,
-      rtConstP.pooled45, rtConstP.pooled5, 1023U);
+      rtConstP.pooled47, rtConstP.pooled5, 1023U);
   }
 
   /* End of Switch: '<S281>/Switch' */
@@ -7306,7 +7486,7 @@ void HVAC_model_step(void)
     Incar_RR = 200;
   } else {
     Incar_RR = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_RR,
-      rtConstP.pooled45, rtConstP.pooled5, 1023U);
+      rtConstP.pooled47, rtConstP.pooled5, 1023U);
   }
 
   /* End of Switch: '<S281>/Switch1' */
@@ -8291,17 +8471,19 @@ void HVAC_model_step(void)
   /* Saturate: '<S1>/Saturation' incorporates:
    *  DataStoreRead: '<S1>/Data Store Read1'
    */
-  if (rtDW.FIU_SET_FL >= 170) {
-    q0 = rtDW.FIU_SET_FL;
+  if (rtDW.FIU_SET_FL > 290) {
+    y = 290;
+  } else if (rtDW.FIU_SET_FL < 170) {
+    y = 170;
   } else {
-    q0 = 170;
+    y = rtDW.FIU_SET_FL;
   }
 
   /* Gain: '<S11>/Gain' incorporates:
    *  Saturate: '<S1>/Saturation'
    */
-  q0 *= 13107;
-  rtb_Gain_ge = (uint8_t)((((uint32_t)q0 & 65536U) != 0U) + (q0 >> 17));
+  y *= 13107;
+  rtb_Gain_ge = (uint8_t)((((uint32_t)y & 65536U) != 0U) + (y >> 17));
 
   /* MATLAB Function: '<S11>/Modes for levels' */
   /* :  get_modes_for_levels = [g_aucMODE_BY_SET_F_LV0; */
@@ -8311,13 +8493,13 @@ void HVAC_model_step(void)
   /* :      g_aucMODE_BY_SET_F_LV4; */
   /* :      g_aucMODE_BY_SET_F_LV5; */
   /* :      ]; */
-  for (q0 = 0; q0 < 13; q0++) {
-    rtb_get_modes_for_levels[6 * q0] = g_aucMODE_BY_SET_F_LV0[q0];
-    rtb_get_modes_for_levels[6 * q0 + 1] = g_aucMODE_BY_SET_F_LV1[q0];
-    rtb_get_modes_for_levels[6 * q0 + 2] = g_aucMODE_BY_SET_F_LV2[q0];
-    rtb_get_modes_for_levels[6 * q0 + 3] = g_aucMODE_BY_SET_F_LV3[q0];
-    rtb_get_modes_for_levels[6 * q0 + 4] = g_aucMODE_BY_SET_F_LV4[q0];
-    rtb_get_modes_for_levels[6 * q0 + 5] = g_aucMODE_BY_SET_F_LV5[q0];
+  for (y = 0; y < 13; y++) {
+    rtb_get_modes_for_levels[6 * y] = g_aucMODE_BY_SET_F_LV0[y];
+    rtb_get_modes_for_levels[6 * y + 1] = g_aucMODE_BY_SET_F_LV1[y];
+    rtb_get_modes_for_levels[6 * y + 2] = g_aucMODE_BY_SET_F_LV2[y];
+    rtb_get_modes_for_levels[6 * y + 3] = g_aucMODE_BY_SET_F_LV3[y];
+    rtb_get_modes_for_levels[6 * y + 4] = g_aucMODE_BY_SET_F_LV4[y];
+    rtb_get_modes_for_levels[6 * y + 5] = g_aucMODE_BY_SET_F_LV5[y];
   }
 
   /* End of MATLAB Function: '<S11>/Modes for levels' */
@@ -8327,8 +8509,8 @@ void HVAC_model_step(void)
    *  Merge: '<S10>/Merge'
    */
   rtb_u_cuz = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Gain_ge,
-    rtConstP.pooled76, rtConstP.pooled42, rtb_get_modes_for_levels,
-    rtConstP.pooled35, 6U);
+    rtConstP.pooled82, rtConstP.pooled43, rtb_get_modes_for_levels,
+    rtConstP.pooled36, 6U);
 
   /* MATLAB Function: '<S11>/Начальные положения заслонок left' */
   left(rtb_u_cuz, rtb_vals_m);
@@ -8336,17 +8518,19 @@ void HVAC_model_step(void)
   /* Saturate: '<S1>/Saturation1' incorporates:
    *  DataStoreRead: '<S1>/Data Store Read2'
    */
-  if (rtDW.FIU_SET_FR >= 170) {
-    q0 = rtDW.FIU_SET_FR;
+  if (rtDW.FIU_SET_FR > 290) {
+    y = 290;
+  } else if (rtDW.FIU_SET_FR < 170) {
+    y = 170;
   } else {
-    q0 = 170;
+    y = rtDW.FIU_SET_FR;
   }
 
   /* Gain: '<S11>/Gain2' incorporates:
    *  Saturate: '<S1>/Saturation1'
    */
-  q0 *= 13107;
-  rtb_Gain2_c = (uint8_t)((((uint32_t)q0 & 65536U) != 0U) + (q0 >> 17));
+  y *= 13107;
+  rtb_Gain2_hu = (uint8_t)((((uint32_t)y & 65536U) != 0U) + (y >> 17));
 
   /* SwitchCase: '<S31>/Switch for Left ' incorporates:
    *  DataStoreRead: '<S1>/Data Store Read'
@@ -8368,7 +8552,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S31>/Bilevel' incorporates:
      *  ActionPort: '<S37>/Action Port'
      */
-    Bilevel(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Bilevel(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S31>/Bilevel' */
     break;
@@ -8386,7 +8570,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S31>/Bilevel2' incorporates:
      *  ActionPort: '<S38>/Action Port'
      */
-    Bilevel2(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Bilevel2(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S31>/Bilevel2' */
     break;
@@ -8404,7 +8588,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S31>/Afoot' incorporates:
      *  ActionPort: '<S35>/Action Port'
      */
-    Afoot(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Afoot(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S31>/Afoot' */
     break;
@@ -8422,7 +8606,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S31>/Afoot_Summer' incorporates:
      *  ActionPort: '<S36>/Action Port'
      */
-    Afoot_Summer(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Afoot_Summer(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S31>/Afoot_Summer' */
     break;
@@ -8434,9 +8618,9 @@ void HVAC_model_step(void)
    *  Gain: '<S11>/Gain2'
    *  Merge: '<S10>/Merge'
    */
-  rtb_u_cuz = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Gain2_c,
-    rtConstP.pooled76, rtConstP.pooled42, rtb_get_modes_for_levels,
-    rtConstP.pooled35, 6U);
+  rtb_u_cuz = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Gain2_hu,
+    rtConstP.pooled82, rtConstP.pooled43, rtb_get_modes_for_levels,
+    rtConstP.pooled36, 6U);
 
   /* MATLAB Function: '<S11>/Начальные положения заслонок right' */
   left(rtb_u_cuz, rtb_vals_m);
@@ -8461,7 +8645,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S32>/Bilevel' incorporates:
      *  ActionPort: '<S146>/Action Port'
      */
-    Bilevel(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Bilevel(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S32>/Bilevel' */
     break;
@@ -8479,7 +8663,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S32>/Bilevel2' incorporates:
      *  ActionPort: '<S147>/Action Port'
      */
-    Bilevel2(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Bilevel2(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S32>/Bilevel2' */
     break;
@@ -8497,7 +8681,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S32>/Afoot' incorporates:
      *  ActionPort: '<S144>/Action Port'
      */
-    Afoot(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Afoot(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S32>/Afoot' */
     break;
@@ -8515,7 +8699,7 @@ void HVAC_model_step(void)
     /* Outputs for IfAction SubSystem: '<S32>/Afoot_Summer' incorporates:
      *  ActionPort: '<S145>/Action Port'
      */
-    Afoot_Summer(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_c);
+    Afoot_Summer(AMB, rtB.Merge_b, Merge, rtb_Gain_ge, rtb_Gain2_hu);
 
     /* End of Outputs for SubSystem: '<S32>/Afoot_Summer' */
     break;
@@ -8549,3742 +8733,38 @@ void HVAC_model_step(void)
 
   /* End of MATLAB Function: '<S10>/Log Ambient Lv' */
 
-  /* BusCreator: '<S4>/Bus Creator' incorporates:
-   *  DataStoreRead: '<S4>/Data Store Read'
-   *  DataStoreRead: '<S4>/Data Store Read1'
-   *  DataStoreRead: '<S4>/Data Store Read10'
-   *  DataStoreRead: '<S4>/Data Store Read11'
-   *  DataStoreRead: '<S4>/Data Store Read12'
-   *  DataStoreRead: '<S4>/Data Store Read13'
-   *  DataStoreRead: '<S4>/Data Store Read14'
-   *  DataStoreRead: '<S4>/Data Store Read15'
-   *  DataStoreRead: '<S4>/Data Store Read16'
-   *  DataStoreRead: '<S4>/Data Store Read17'
-   *  DataStoreRead: '<S4>/Data Store Read18'
-   *  DataStoreRead: '<S4>/Data Store Read19'
-   *  DataStoreRead: '<S4>/Data Store Read2'
-   *  DataStoreRead: '<S4>/Data Store Read20'
-   *  DataStoreRead: '<S4>/Data Store Read21'
-   *  DataStoreRead: '<S4>/Data Store Read22'
-   *  DataStoreRead: '<S4>/Data Store Read23'
-   *  DataStoreRead: '<S4>/Data Store Read24'
-   *  DataStoreRead: '<S4>/Data Store Read25'
-   *  DataStoreRead: '<S4>/Data Store Read26'
-   *  DataStoreRead: '<S4>/Data Store Read3'
-   *  DataStoreRead: '<S4>/Data Store Read4'
-   *  DataStoreRead: '<S4>/Data Store Read5'
-   *  DataStoreRead: '<S4>/Data Store Read6'
-   *  DataStoreRead: '<S4>/Data Store Read7'
-   *  DataStoreRead: '<S4>/Data Store Read8'
-   *  DataStoreRead: '<S4>/Data Store Read9'
-   *  DataStoreWrite: '<S4>/Data Store Write'
+  /* DataTypeConversion: '<S481>/Data Type  Conversion1' incorporates:
+   *  Bias: '<S481>/Bias'
+   *  DataStoreRead: '<S3>/Data Store Read1'
+   *  DataStoreWrite: '<S474>/Data Store Write1'
+   *  DataTypeConversion: '<S481>/Data Type  Conversion'
+   *  Gain: '<S481>/Gain'
+   *  Gain: '<S481>/Gain1'
    */
-  rtDW.CCU_STAT1_MODEL.CCU_ModeFL_Stat = rtDW.FIU_MODE_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_ModeFR_Stat = rtDW.FIU_MODE_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_ModeRL_Stat = rtDW.FIU_MODE_RL;
-  rtDW.CCU_STAT1_MODEL.CCU_ModeRR_Stat = rtDW.FIU_MODE_RR;
-  rtDW.CCU_STAT1_MODEL.CCU_AutoModeFL_Stat = rtDW.FIU_AUTOMODE_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_AutoModeFR_Stat = rtDW.FIU_AUTOMODE_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRL_Face_Stat = rtDW.FIU_FACE_RL;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRL_Foot_Stat = rtDW.FIU_FOOT_RL;
-  rtDW.CCU_STAT1_MODEL.CCU_AutoModeRL_Stat = rtDW.FIU_AUTOMODE_RL;
-  rtDW.CCU_STAT1_MODEL.CCU_AutoModeRR_Stat = rtDW.FIU_AUTOMODE_RR;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRR_Face_Stat = rtDW.FIU_FACE_RR;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRR_Foot_Stat = rtDW.FIU_FOOT_RR;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Def_Stat = rtDW.FIU_DEF_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Face_Stat = rtDW.FIU_FACE_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Foot_Stat = rtDW.FIU_FOOT_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Def_Stat = rtDW.FIU_DEF_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Face_Stat = rtDW.FIU_FACE_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Foot_Stat = rtDW.FIU_FOOT_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_Recirculation_Stat = rtDW.FIU_RECIRC;
-  rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFL_Stat = rtDW.FIU_BLOWERS_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_TargetTempFL_Stat_ro = rtDW.FIU_SET_FL;
-  rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFR_Stat = rtDW.FIU_BLOWERS_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_TargetTempFR_Stat_ro = rtDW.FIU_SET_FR;
-  rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRL_Stat = rtDW.FIU_BLOWERS_RL;
-  rtDW.CCU_STAT1_MODEL.CCU_TargetTempRR_Stat_ro = rtDW.FIU_SET_RR;
-  rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRR_Stat = rtDW.FIU_BLOWERS_RR;
-  rtDW.CCU_STAT1_MODEL.CCU_TargetTempRL_Stat_ro = rtDW.FIU_SET_RL;
+  rtDW.FIU_SET_FL = (uint16_t)((0.5 * (double)
+    rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro + 15.5) * 10.0);
 
-  /* DataStoreWrite: '<S483>/Data Store Write2' */
-  for (i = 0; i < 9; i++) {
-    /* Switch: '<S497>/Switch' incorporates:
-     *  Constant: '<S497>/Constant'
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreRead: '<S497>/Data Store Read'
-     *  Gain: '<S497>/Gain'
-     *  Product: '<S497>/Divide'
-     */
-    if (rtDW.MaxPositionCh0_private[i] != 0) {
-      q0 = 100 * (int16_t)div_nde_s32_floor
-        (Actuator_Ch0_Status_Model.in_CPOS_ALL[i], rtDW.MaxPositionCh0_private[i]);
-    } else {
-      q0 = 0;
-    }
-
-    /* End of Switch: '<S497>/Switch' */
-
-    /* Saturate: '<S497>/Saturation' */
-    if (q0 > 100) {
-      Actuator_pos_percent_Ch0[i] = 100U;
-    } else if (q0 < 0) {
-      Actuator_pos_percent_Ch0[i] = 0U;
-    } else {
-      Actuator_pos_percent_Ch0[i] = (uint8_t)q0;
-    }
-
-    /* End of Saturate: '<S497>/Saturation' */
-  }
-
-  /* End of DataStoreWrite: '<S483>/Data Store Write2' */
-
-  /* Switch: '<S483>/Switch' incorporates:
-   *  Constant: '<S483>/Constant1'
-   *  DataStoreRead: '<S483>/Data Store Read'
-   *  DataStoreRead: '<S483>/Data Store Read2'
+  /* DataTypeConversion: '<S482>/Data Type  Conversion1' incorporates:
+   *  Bias: '<S482>/Bias'
+   *  DataStoreRead: '<S3>/Data Store Read1'
+   *  DataStoreWrite: '<S475>/Data Store Write'
+   *  DataTypeConversion: '<S482>/Data Type  Conversion'
+   *  Gain: '<S482>/Gain'
+   *  Gain: '<S482>/Gain1'
    */
-  if (rtDW.stepSig_private > 0) {
-    rtb_Switch_hx = rtDW.stepSig_private;
-  } else {
-    rtb_Switch_hx = 1;
-  }
-
-  /* End of Switch: '<S483>/Switch' */
-
-  /* SwitchCase: '<S483>/Switch Case' */
-  switch (rtb_Switch_hx) {
-   case 1:
-    /* Outputs for IfAction SubSystem: '<S483>/Stop Mode' incorporates:
-     *  ActionPort: '<S496>/Action Port'
-     */
-    /* If: '<S496>/If1' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S496>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S550>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S550>/Data Store Write1' */
-        rtDW.COM_private[i] = 1U;
-
-        /* DataStoreWrite: '<S550>/Data Store Write' */
-        rtDW.MODE_private[i] = 2U;
-      }
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S550>/Constant'
-       *  Sum: '<S550>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S550>/Write' incorporates:
-       *  DataStoreRead: '<S550>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Stop Mode\n'); */
-        printf("[LIN 1] Stop Mode\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S550>/Write' */
-      /* End of Outputs for SubSystem: '<S496>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S496>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S551>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S551>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S496>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S496>/If1' */
-    /* End of Outputs for SubSystem: '<S483>/Stop Mode' */
-    break;
-
-   case 2:
-    /* Outputs for IfAction SubSystem: '<S483>/Initial CPOS Min' incorporates:
-     *  ActionPort: '<S492>/Action Port'
-     */
-    /* If: '<S492>/If' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S492>/If Action Subsystem' incorporates:
-       *  ActionPort: '<S538>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S538>/Data Store Write' */
-        rtDW.POS_private[i] = 6000U;
-
-        /* DataStoreWrite: '<S538>/Data Store Write1' */
-        rtDW.COM_private[i] = 2U;
-      }
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S538>/Constant'
-       *  Merge: '<S492>/Merge'
-       *  Sum: '<S538>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S538>/Write' incorporates:
-       *  DataStoreRead: '<S538>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Initial CPOS Min\n'); */
-        printf("[LIN 1] Initial CPOS Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S538>/Write' */
-      /* End of Outputs for SubSystem: '<S492>/If Action Subsystem' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S492>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S539>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Merge: '<S492>/Merge'
-       *  SignalConversion generated from: '<S539>/stepIn1'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S492>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S492>/If' */
-    /* End of Outputs for SubSystem: '<S483>/Initial CPOS Min' */
-    break;
-
-   case 3:
-    /* Outputs for IfAction SubSystem: '<S483>/Normal Mode' incorporates:
-     *  ActionPort: '<S495>/Action Port'
-     */
-    /* If: '<S495>/If1' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S495>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S547>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S547>/Data Store Write' */
-        rtDW.MODE_private[i] = 0U;
-
-        /* DataStoreWrite: '<S547>/Data Store Write1' */
-        rtDW.COM_private[i] = 1U;
-      }
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S547>/Constant'
-       *  Sum: '<S547>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S547>/Write' incorporates:
-       *  DataStoreRead: '<S547>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Normal Mode\n'); */
-        printf("[LIN 1] Normal Mode\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S547>/Write' */
-      /* End of Outputs for SubSystem: '<S495>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S495>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S548>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S548>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S495>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S495>/If1' */
-    /* End of Outputs for SubSystem: '<S483>/Normal Mode' */
-    break;
-
-   case 4:
-    /* Outputs for IfAction SubSystem: '<S483>/Move to position Min' incorporates:
-     *  ActionPort: '<S494>/Action Port'
-     */
-    /* If: '<S494>/If1' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S494>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S544>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S544>/Data Store Write4' incorporates:
-         *  Constant: '<S544>/Constant1'
-         */
-        rtDW.Autos_private[i] = 1U;
-
-        /* DataStoreWrite: '<S544>/Data Store Write2' incorporates:
-         *  Constant: '<S544>/Constant10'
-         */
-        rtDW.Stall_private[i] = 1U;
-
-        /* DataStoreWrite: '<S544>/Data Store Write3' */
-        rtDW.Lnoise_private[i] = 0U;
-
-        /* DataStoreWrite: '<S544>/Data Store Write5' incorporates:
-         *  Constant: '<S544>/Constant2'
-         */
-        rtDW.Speed_private[i] = 3U;
-
-        /* DataStoreWrite: '<S544>/Data Store Write6' incorporates:
-         *  Constant: '<S544>/Constant3'
-         */
-        rtDW.Coils_private[i] = 3U;
-
-        /* DataStoreWrite: '<S544>/Data Store Write' */
-        rtDW.POS_private[i] = 0U;
-
-        /* DataStoreWrite: '<S544>/Data Store Write1' incorporates:
-         *  Constant: '<S544>/Constant9'
-         */
-        rtDW.COM_private[i] = 3U;
-      }
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S544>/Constant'
-       *  Sum: '<S544>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S544>/Write' incorporates:
-       *  DataStoreRead: '<S544>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Move to position Min\n'); */
-        printf("[LIN 1] Move to position Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S544>/Write' */
-      /* End of Outputs for SubSystem: '<S494>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S494>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S545>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S545>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S494>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S494>/If1' */
-    /* End of Outputs for SubSystem: '<S483>/Move to position Min' */
-    break;
-
-   case 5:
-    /* Outputs for IfAction SubSystem: '<S483>/Check Stall Min' incorporates:
-     *  ActionPort: '<S489>/Action Port'
-     */
-    /* Logic: '<S489>/Logical Operator3' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreRead: '<S489>/Data Store Read'
-     *  Logic: '<S489>/Logical Operator1'
-     *  Logic: '<S489>/Logical Operator2'
-     *  RelationalOperator: '<S489>/Relational Operator'
-     *  RelationalOperator: '<S489>/Relational Operator1'
-     */
-    for (i = 0; i < 9; i++) {
-      rtb_LogicalOperator3_a0[i] =
-        ((Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1) ||
-         (Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 0) ||
-         (rtDW.ErrorCalibration_private[i] == 0));
-    }
-
-    /* End of Logic: '<S489>/Logical Operator3' */
-
-    /* Logic: '<S489>/Logical Operator' incorporates:
-     *  Logic: '<S489>/Logical Operator3'
-     */
-    rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-    for (q0 = 0; q0 < 8; q0++) {
-      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_a0[q0
-        + 1]);
-    }
-
-    /* If: '<S489>/If2' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  DataTypeConversion: '<S489>/Data Type Conversion'
-     *  DataTypeConversion: '<S489>/Data Type Conversion1'
-     *  Logic: '<S489>/Logical Operator'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
-    {
-      /* Outputs for IfAction SubSystem: '<S489>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S502>/Action Port'
-       */
-      /* DataStoreWrite: '<S502>/Data Store Write1' */
-      for (q0 = 0; q0 < 9; q0++) {
-        /* Switch: '<S502>/Switch' incorporates:
-         *  DataStoreRead: '<S502>/Data Store Read1'
-         */
-        if (rtDW.ErrorCalibration_private[q0] != 0) {
-          rtDW.MinPositionCh0_private[q0] =
-            Actuator_Ch0_Status_Model.in_CPOS_ALL[q0];
-        }
-
-        /* End of Switch: '<S502>/Switch' */
-      }
-
-      /* End of DataStoreWrite: '<S502>/Data Store Write1' */
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S502>/Constant'
-       *  Sum: '<S502>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S502>/Write' incorporates:
-       *  DataStoreRead: '<S502>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Check Stall Min\n'); */
-        printf("[LIN 1] Check Stall Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S502>/Write' */
-      /* End of Outputs for SubSystem: '<S489>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S489>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S503>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S503>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S489>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S489>/If2' */
-    /* End of Outputs for SubSystem: '<S483>/Check Stall Min' */
-    break;
-
-   case 6:
-    /* Outputs for IfAction SubSystem: '<S483>/Initial CPOS Max' incorporates:
-     *  ActionPort: '<S491>/Action Port'
-     */
-    /* If: '<S491>/If1' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S491>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S535>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S535>/Data Store Write1' */
-        rtDW.COM_private[i] = 2U;
-
-        /* DataStoreWrite: '<S535>/Data Store Write' */
-        rtDW.POS_private[i] = 0U;
-      }
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S535>/Constant'
-       *  Sum: '<S535>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S535>/Write' incorporates:
-       *  DataStoreRead: '<S535>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Initial CPOS Max\n'); */
-        printf("[LIN 1] Initial CPOS Max\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S535>/Write' */
-      /* End of Outputs for SubSystem: '<S491>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S491>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S536>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S536>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S491>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S491>/If1' */
-    /* End of Outputs for SubSystem: '<S483>/Initial CPOS Max' */
-    break;
-
-   case 7:
-    /* Outputs for IfAction SubSystem: '<S483>/Move to position Max' incorporates:
-     *  ActionPort: '<S493>/Action Port'
-     */
-    /* If: '<S493>/If1' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S493>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S541>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S541>/Data Store Write4' incorporates:
-         *  Constant: '<S541>/Constant1'
-         */
-        rtDW.Autos_private[i] = 1U;
-
-        /* DataStoreWrite: '<S541>/Data Store Write2' incorporates:
-         *  Constant: '<S541>/Constant10'
-         */
-        rtDW.Stall_private[i] = 1U;
-
-        /* DataStoreWrite: '<S541>/Data Store Write3' */
-        rtDW.Lnoise_private[i] = 0U;
-
-        /* DataStoreWrite: '<S541>/Data Store Write5' incorporates:
-         *  Constant: '<S541>/Constant2'
-         */
-        rtDW.Speed_private[i] = 3U;
-
-        /* DataStoreWrite: '<S541>/Data Store Write' */
-        rtDW.POS_private[i] = 6000U;
-
-        /* DataStoreWrite: '<S541>/Data Store Write1' incorporates:
-         *  Constant: '<S541>/Constant9'
-         */
-        rtDW.COM_private[i] = 3U;
-
-        /* DataStoreWrite: '<S541>/Data Store Write6' */
-        rtDW.Coils_private[i] = 0U;
-      }
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S541>/Constant'
-       *  Sum: '<S541>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S541>/Write' incorporates:
-       *  DataStoreRead: '<S541>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Move to position Max\n'); */
-        printf("[LIN 1] Move to position Max\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S541>/Write' */
-      /* End of Outputs for SubSystem: '<S493>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S493>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S542>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S542>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S493>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S493>/If1' */
-    /* End of Outputs for SubSystem: '<S483>/Move to position Max' */
-    break;
-
-   case 8:
-    /* Outputs for IfAction SubSystem: '<S483>/Check Stall Max' incorporates:
-     *  ActionPort: '<S488>/Action Port'
-     */
-    /* Logic: '<S488>/Logical Operator3' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreRead: '<S488>/Data Store Read'
-     *  Logic: '<S488>/Logical Operator'
-     *  Logic: '<S488>/Logical Operator2'
-     *  RelationalOperator: '<S488>/Relational Operator'
-     *  RelationalOperator: '<S488>/Relational Operator1'
-     */
-    for (i = 0; i < 9; i++) {
-      rtb_LogicalOperator3_a0[i] =
-        ((Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1) ||
-         (Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 6000) ||
-         (rtDW.ErrorCalibration_private[i] == 0));
-    }
-
-    /* End of Logic: '<S488>/Logical Operator3' */
-
-    /* Logic: '<S488>/Logical Operator1' incorporates:
-     *  Logic: '<S488>/Logical Operator3'
-     */
-    rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-    for (q0 = 0; q0 < 8; q0++) {
-      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_a0[q0
-        + 1]);
-    }
-
-    /* If: '<S488>/If2' incorporates:
-     *  DataStoreRead: '<S483>/Data Store Read1'
-     *  DataStoreWrite: '<S483>/Data Store Write1'
-     *  DataTypeConversion: '<S488>/Data Type Conversion'
-     *  DataTypeConversion: '<S488>/Data Type Conversion1'
-     *  Logic: '<S488>/Logical Operator1'
-     *  SignalConversion generated from: '<S483>/Bus Selector'
-     */
-    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
-        (Actuator_Ch0_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
-    {
-      /* Outputs for IfAction SubSystem: '<S488>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S499>/Action Port'
-       */
-      /* DataStoreWrite: '<S499>/Data Store Write1' */
-      for (q0 = 0; q0 < 9; q0++) {
-        /* Switch: '<S499>/Switch' incorporates:
-         *  DataStoreRead: '<S499>/Data Store Read1'
-         */
-        if (rtDW.ErrorCalibration_private[q0] != 0) {
-          rtDW.MaxPositionCh0_private[q0] =
-            Actuator_Ch0_Status_Model.in_CPOS_ALL[q0];
-        }
-
-        /* End of Switch: '<S499>/Switch' */
-      }
-
-      /* End of DataStoreWrite: '<S499>/Data Store Write1' */
-
-      /* Merge: '<S483>/Merge' incorporates:
-       *  Constant: '<S499>/Constant'
-       *  Sum: '<S499>/step inc'
-       */
-      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S499>/Write' incorporates:
-       *  DataStoreRead: '<S499>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 1] Check Stall MAX\n'); */
-        printf("[LIN 1] Check Stall MAX\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S499>/Write' */
-      /* End of Outputs for SubSystem: '<S488>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S488>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S500>/Action Port'
-       */
-      /* Merge: '<S483>/Merge' incorporates:
-       *  SignalConversion generated from: '<S500>/stepIn'
-       */
-      rtB.Merge_l = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S488>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S488>/If2' */
-    /* End of Outputs for SubSystem: '<S483>/Check Stall Max' */
-    break;
-
-   case 9:
-    /* Outputs for IfAction SubSystem: '<S483>/Homing' incorporates:
-     *  ActionPort: '<S490>/Action Port'
-     */
-    /* Product: '<S505>/Divide1' incorporates:
-     *  Constant: '<S505>/ACT1'
-     *  DataStoreRead: '<S505>/MAX ACT1T '
-     */
-    for (i = 0; i < 9; i++) {
-      rtb_Divide1_gdi[i] = (double)rtDW.MaxPositionCh0_private[i] / (double)
-        rtConstP.ACT1_Value[i];
-    }
-
-    /* End of Product: '<S505>/Divide1' */
-
-    /* SwitchCase: '<S490>/Switch Case' incorporates:
-     *  DataStoreRead: '<S490>/Data Store Read4'
-     */
-    switch (rtDW.stepHoming_private) {
-     case 0:
-      /* Outputs for IfAction SubSystem: '<S490>/Switch Case Action Subsystem' incorporates:
-       *  ActionPort: '<S506>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* RelationalOperator: '<S511>/Compare' */
-        rtb_Divide1 = rtb_Divide1_gdi[i];
-
-        /* Logic: '<S506>/Logical Operator' incorporates:
-         *  Constant: '<S511>/Constant'
-         *  Constant: '<S512>/Constant'
-         *  RelationalOperator: '<S511>/Compare'
-         *  RelationalOperator: '<S512>/Compare'
-         */
-        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
-        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S514>/Data Type Conversion' incorporates:
-         *  DataStoreRead: '<S514>/Data Store Read'
-         *  DataStoreWrite: '<S514>/Data Store Write'
-         *  Logic: '<S514>/Logical Operator'
-         *  Logic: '<S514>/Logical Operator1'
-         */
-        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
-          (rtDW.ErrorCalibration_private[i] != 0));
-      }
-
-      /* MATLAB Function: '<S506>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S506>/Data Store Read5'
-       *  DataStoreRead: '<S506>/MIN ACT1T 1'
-       *  Logic: '<S506>/Logical Operator2'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 1] Homing 0\n"); */
-        printf("[LIN 1] Homing 0\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 9; i++) {
-          /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-          printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                 (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
-                 rtb_Divide1_gdi[i], (int16_t)!rtb_LogicalOperator3_a0[i]);
-          fflush(stdout);
-        }
-      }
-
-      /* End of MATLAB Function: '<S506>/MAX POSITION' */
-
-      /* Logic: '<S506>/Logical Operator1' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* Switch: '<S506>/Switch' incorporates:
-       *  Logic: '<S506>/Logical Operator1'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S490>/Merge' incorporates:
-         *  Constant: '<S506>/Constant1'
-         */
-        rtB.Merge_h1 = 4;
-      } else {
-        /* Merge: '<S490>/Merge' incorporates:
-         *  Constant: '<S506>/Constant'
-         */
-        rtB.Merge_h1 = 1;
-      }
-
-      /* End of Switch: '<S506>/Switch' */
-      /* End of Outputs for SubSystem: '<S490>/Switch Case Action Subsystem' */
-      break;
-
-     case 1:
-      /* Outputs for IfAction SubSystem: '<S490>/Switch Case Action Subsystem1' incorporates:
-       *  ActionPort: '<S507>/Action Port'
-       */
-      /* RelationalOperator: '<S516>/Compare' incorporates:
-       *  Constant: '<S516>/Constant'
-       */
-      for (i = 0; i < 9; i++) {
-        rtb_LogicalOperator3_a0[i] = (rtb_Divide1_gdi[i] > 1.5);
-      }
-
-      /* End of RelationalOperator: '<S516>/Compare' */
-
-      /* Logic: '<S515>/Logical Operator' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* DataTypeConversion: '<S515>/Data Type Conversion' incorporates:
-       *  DataStoreWrite: '<S515>/Data Store Write1'
-       *  Logic: '<S515>/Logical Operator'
-       */
-      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
-      for (i = 0; i < 9; i++) {
-        /* DataTypeConversion: '<S515>/Data Type Conversion1' incorporates:
-         *  DataStoreWrite: '<S515>/Data Store Write2'
-         */
-        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
-        rtDW.COM_private[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S515>/Data Type Conversion2' incorporates:
-         *  DataStoreRead: '<S515>/Data Store Read'
-         *  DataStoreWrite: '<S515>/Data Store Write3'
-         *  Logic: '<S515>/Logical Operator1'
-         */
-        rtDW.ErrorActuator[i] = (uint8_t)(rtb_LogicalOperator1 ||
-          (rtDW.ErrorActuator[i] != 0));
-
-        /* DataStoreWrite: '<S515>/Data Store Write' */
-        rtDW.MODE_private[i] = 2U;
-      }
-
-      /* MATLAB Function: '<S515>/Write ERROR' incorporates:
-       *  DataStoreRead: '<S515>/Data Store Read6'
-       */
-      /* :  if(LOGGER>=0) */
-      if (rtDW.LOGGER_LIN >= 0.0) {
-        /* :  for i = 1:numel(ErrCallibration) */
-        for (i = 0; i < 9; i++) {
-          /* :  if ErrCallibration(i) == 1 */
-          if (rtb_LogicalOperator3_a0[i]) {
-            /* :  fprintf('[LIN 1] Failure with actuator #%d\n', int16(i)); */
-            printf("[LIN 1] Failure with actuator #%d\n", (int16_t)(i + 1));
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S515>/Write ERROR' */
-      for (i = 0; i < 9; i++) {
-        /* Logic: '<S507>/Logical Operator1' */
-        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
-
-        /* DataTypeConversion: '<S507>/Data Type Conversion' incorporates:
-         *  DataStoreRead: '<S507>/Data Store Read'
-         *  DataStoreWrite: '<S507>/Data Store Write'
-         *  Logic: '<S507>/Logical Operator'
-         *  Logic: '<S507>/Logical Operator1'
-         */
-        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
-          (rtDW.ErrorCalibration_private[i] != 0));
-
-        /* DataStoreWrite: '<S519>/Data Store Write' incorporates:
-         *  DataTypeConversion: '<S519>/Data Type Conversion'
-         */
-        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
-      }
-
-      /* DataStoreWrite: '<S518>/Data Store Write' incorporates:
-       *  Constant: '<S518>/Constant'
-       */
-      rtDW.stepSig_private = 1;
-
-      /* MATLAB Function: '<S507>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S507>/Data Store Read5'
-       *  DataStoreRead: '<S507>/MIN ACT1T 1'
-       *  DataStoreWrite: '<S507>/Data Store Write'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 1] Homing 1. Start Callibration \n"); */
-        printf("[LIN 1] Homing 1. Start Callibration \n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 9; i++) {
-          /* :  if(ERRORS(i)==1) */
-          if (rtDW.ErrorCalibration_private[i] == 1) {
-            /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-            printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                   (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
-                   rtb_Divide1_gdi[i], (int16_t)rtDW.ErrorCalibration_private[i]);
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S507>/MAX POSITION' */
-
-      /* Logic: '<S507>/Logical Operator2' incorporates:
-       *  DataStoreWrite: '<S507>/Data Store Write'
-       */
-      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private[0] != 0);
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          (rtDW.ErrorCalibration_private[q0 + 1] != 0));
-      }
-
-      /* Switch: '<S507>/Switch' incorporates:
-       *  Logic: '<S507>/Logical Operator2'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S490>/Merge' incorporates:
-         *  Constant: '<S518>/Constant1'
-         */
-        rtB.Merge_h1 = 2;
-      } else {
-        /* Merge: '<S490>/Merge' incorporates:
-         *  Constant: '<S507>/Constant1'
-         */
-        rtB.Merge_h1 = 4;
-      }
-
-      /* End of Switch: '<S507>/Switch' */
-      /* End of Outputs for SubSystem: '<S490>/Switch Case Action Subsystem1' */
-      break;
-
-     case 2:
-      /* Outputs for IfAction SubSystem: '<S490>/Switch Case Action Subsystem2' incorporates:
-       *  ActionPort: '<S508>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* RelationalOperator: '<S521>/Compare' */
-        rtb_Divide1 = rtb_Divide1_gdi[i];
-
-        /* Logic: '<S508>/Logical Operator3' incorporates:
-         *  Constant: '<S521>/Constant'
-         *  Constant: '<S522>/Constant'
-         *  DataStoreRead: '<S508>/Data Store Read'
-         *  Logic: '<S508>/Logical Operator1'
-         *  Logic: '<S508>/Logical Operator4'
-         *  RelationalOperator: '<S521>/Compare'
-         *  RelationalOperator: '<S522>/Compare'
-         */
-        rtb_LogicalOperator1 = (((rtb_Divide1 < 0.97) || (rtb_Divide1 > 1.03)) &&
-          (rtDW.ErrorCalibration_private[i] != 0));
-        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S508>/Data Type Conversion' incorporates:
-         *  DataStoreWrite: '<S508>/Data Store Write1'
-         */
-        rtDW.ErrorCalibration_private[i] = rtb_LogicalOperator1;
-      }
-
-      /* MATLAB Function: '<S508>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S508>/Data Store Read5'
-       *  DataStoreRead: '<S508>/MIN ACT1T 1'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 1] Homing 3. Callibration \n"); */
-        printf("[LIN 1] Homing 3. Callibration \n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 9; i++) {
-          /* :  if(ERRORS(i)==1) */
-          if (rtb_LogicalOperator3_a0[i]) {
-            /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-            printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                   (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
-                   rtb_Divide1_gdi[i], 1);
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S508>/MAX POSITION' */
-
-      /* Logic: '<S508>/Logical Operator2' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* Switch: '<S508>/Switch' incorporates:
-       *  Logic: '<S508>/Logical Operator2'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S490>/Merge' incorporates:
-         *  Constant: '<S508>/Constant3'
-         */
-        rtB.Merge_h1 = 3;
-      } else {
-        /* Merge: '<S490>/Merge' incorporates:
-         *  Constant: '<S508>/Constant1'
-         */
-        rtB.Merge_h1 = 4;
-      }
-
-      /* End of Switch: '<S508>/Switch' */
-      /* End of Outputs for SubSystem: '<S490>/Switch Case Action Subsystem2' */
-      break;
-
-     case 3:
-      /* Outputs for IfAction SubSystem: '<S490>/Switch Case Action Subsystem3' incorporates:
-       *  ActionPort: '<S509>/Action Port'
-       */
-      /* MATLAB Function: '<S509>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S509>/Data Store Read1'
-       *  DataStoreRead: '<S509>/Data Store Read5'
-       */
-      /* :  if(LOGGER>1) */
-      if (rtDW.LOGGER_LIN > 1.0) {
-        /* :  fprintf("[LIN 1] Homing 3. Start Time on step %d\n",int16(step)); */
-        rtb_Divide1 = rt_roundd(rtDW.ErrorHomming_private);
-        if (rtb_Divide1 < 32768.0) {
-          if (rtb_Divide1 >= -32768.0) {
-            AMB = (int16_t)rtb_Divide1;
-          } else {
-            AMB = INT16_MIN;
-          }
-        } else {
-          AMB = INT16_MAX;
-        }
-
-        printf("[LIN 1] Homing 3. Start Time on step %d\n", AMB);
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S509>/MAX POSITION' */
-
-      /* If: '<S509>/If' incorporates:
-       *  DataStoreRead: '<S509>/Data Store Read1'
-       */
-      if (rtDW.ErrorHomming_private < 10.0) {
-        /* Outputs for IfAction SubSystem: '<S509>/If Action Subsystem' incorporates:
-         *  ActionPort: '<S524>/Action Port'
-         */
-        /* MATLAB Function: '<S524>/MATLAB Function' incorporates:
-         *  DataStoreRead: '<S524>/Data Store Read'
-         *  DataStoreRead: '<S524>/Data Store Read1'
-         */
-        MATLABFunction(rtDW.Start_timer_i, rtDW.t_now, &rtb_dt_ih,
-                       &rtDW.sf_MATLABFunction);
-
-        /* MATLAB Function: '<S524>/MAX POSITION' incorporates:
-         *  DataStoreRead: '<S524>/Data Store Read5'
-         */
-        /* :  if(LOGGER>1) */
-        if (rtDW.LOGGER_LIN > 1.0) {
-          /* :  fprintf("[LIN 1] Homing 3. Start TIme dt = %d \n",int32(data)); */
-          rtb_dt_fa = rtb_dt_ih;
-          if (rtb_dt_ih > 2147483647U) {
-            rtb_dt_fa = 2147483647U;
-          }
-
-          printf("[LIN 1] Homing 3. Start TIme dt = %d \n", (int32_t)rtb_dt_fa);
-          fflush(stdout);
-        }
-
-        /* End of MATLAB Function: '<S524>/MAX POSITION' */
-
-        /* If: '<S524>/If' */
-        if (rtb_dt_ih > 30000U) {
-          /* Outputs for IfAction SubSystem: '<S524>/If Action Subsystem' incorporates:
-           *  ActionPort: '<S527>/Action Port'
-           */
-          /* Merge: '<S490>/Merge' */
-          IfActionSubsystem(&rtB.Merge_h1, &rtDW.ErrorHomming_private,
-                            &rtDW.Start_timer_i, &rtDW.stepSig_private);
-
-          /* End of Outputs for SubSystem: '<S524>/If Action Subsystem' */
-        } else {
-          /* Outputs for IfAction SubSystem: '<S524>/If Action Subsystem1' incorporates:
-           *  ActionPort: '<S528>/Action Port'
-           */
-          /* Merge: '<S490>/Merge' */
-          IfActionSubsystem1(&rtB.Merge_h1, &rtDW.Start_timer_i);
-
-          /* End of Outputs for SubSystem: '<S524>/If Action Subsystem1' */
-        }
-
-        /* End of If: '<S524>/If' */
-        /* End of Outputs for SubSystem: '<S509>/If Action Subsystem' */
-      } else {
-        /* Outputs for IfAction SubSystem: '<S509>/If Action Subsystem1' incorporates:
-         *  ActionPort: '<S525>/Action Port'
-         */
-        IfActionSubsystem1_d(&rtB.Merge_h1, &rtDW.CCU_ActuatorErrF_Stat_private,
-                             rtDW.COM_private, rtDW.ErrorActuator,
-                             rtDW.ErrorCalibration_private, &rtDW.LOGGER_LIN,
-                             rtDW.MODE_private, rtDW.dtc_state_error_model);
-
-        /* End of Outputs for SubSystem: '<S509>/If Action Subsystem1' */
-      }
-
-      /* End of If: '<S509>/If' */
-      /* End of Outputs for SubSystem: '<S490>/Switch Case Action Subsystem3' */
-      break;
-
-     case 4:
-      /* Outputs for IfAction SubSystem: '<S490>/Switch Case Action Subsystem4' incorporates:
-       *  ActionPort: '<S510>/Action Port'
-       */
-      /* DataStoreWrite: '<S510>/Data Store Write' incorporates:
-       *  Constant: '<S510>/Constant'
-       */
-      rtDW.stepSig_private = 10;
-
-      /* Merge: '<S490>/Merge' incorporates:
-       *  Constant: '<S510>/Constant1'
-       *  SignalConversion generated from: '<S510>/step'
-       */
-      rtB.Merge_h1 = 5;
-
-      /* MATLAB Function: '<S510>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S510>/Data Store Read5'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 1] Homing. Callibration successful \n"); */
-        printf("[LIN 1] Homing. Callibration successful \n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S510>/MAX POSITION' */
-      /* End of Outputs for SubSystem: '<S490>/Switch Case Action Subsystem4' */
-      break;
-    }
-
-    /* End of SwitchCase: '<S490>/Switch Case' */
-
-    /* DataStoreWrite: '<S490>/Data Store Write2' */
-    rtDW.stepHoming_private = rtB.Merge_h1;
-
-    /* Merge: '<S483>/Merge' incorporates:
-     *  DataStoreRead: '<S490>/Data Store Read7'
-     */
-    rtB.Merge_l = rtDW.stepSig_private;
-
-    /* End of Outputs for SubSystem: '<S483>/Homing' */
-    break;
-  }
-
-  /* End of SwitchCase: '<S483>/Switch Case' */
-
-  /* DataStoreWrite: '<S483>/Finish write stepSig' */
-  rtDW.stepSig_private = rtB.Merge_l;
-  for (i = 0; i < 9; i++) {
-    /* BusCreator: '<S486>/Bus Creator' incorporates:
-     *  DataStoreRead: '<S486>/Data Store Read'
-     *  DataStoreRead: '<S486>/Data Store Read1'
-     *  DataStoreRead: '<S486>/Data Store Read2'
-     *  DataStoreRead: '<S486>/Data Store Read3'
-     *  DataStoreRead: '<S486>/Data Store Read4'
-     *  DataStoreRead: '<S486>/Data Store Read5'
-     *  DataStoreRead: '<S486>/Data Store Read6'
-     *  DataStoreRead: '<S486>/Data Store Read7'
-     *  DataStoreRead: '<S486>/Data Store Read8'
-     *  DataStoreWrite: '<S486>/Data Store Write'
-     */
-    Actuator_Ch0_Command_Model.POS[i] = rtDW.POS_private[i];
-    Actuator_Ch0_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private[i];
-    Actuator_Ch0_Command_Model.MODE[i] = rtDW.MODE_private[i];
-    Actuator_Ch0_Command_Model.COM[i] = rtDW.COM_private[i];
-    Actuator_Ch0_Command_Model.Stall_SET[i] = rtDW.Stall_private[i];
-    Actuator_Ch0_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private[i];
-    Actuator_Ch0_Command_Model.Autos_SET[i] = rtDW.Autos_private[i];
-    Actuator_Ch0_Command_Model.Speed_SET[i] = rtDW.Speed_private[i];
-    Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private[i];
-
-    /* RelationalOperator: '<S498>/Compare' incorporates:
-     *  Constant: '<S498>/Constant'
-     *  DataStoreRead: '<S487>/Data Store Read2'
-     */
-    rtb_LogicalOperator3_a0[i] = (rtDW.ErrorCalibration_private[i] == 0);
-  }
-
-  /* Logic: '<S487>/Logical Operator' */
-  rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-  for (q0 = 0; q0 < 8; q0++) {
-    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_LogicalOperator3_a0[q0 +
-      1]);
-  }
-
-  for (i = 0; i < 9; i++) {
-    /* Switch: '<S487>/Switch1' incorporates:
-     *  Constant: '<S487>/Constant'
-     *  Constant: '<S487>/Constant3'
-     *  DataStoreRead: '<S487>/Data Store Read2'
-     *  DataStoreWrite: '<S487>/Data Store Write7'
-     *  Logic: '<S487>/Logical Operator'
-     *  Product: '<S487>/Product'
-     */
-    if (rtb_LogicalOperator1) {
-      rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
-        rtDW.ErrorCalibration_private[i] * rtConstP.Constant3_Value[i]);
-    } else {
-      rtDW.BUS_ADR_private[i] = 0U;
-    }
-
-    /* End of Switch: '<S487>/Switch1' */
-
-    /* DataStoreWrite: '<S487>/Data Store Write' */
-    rtDW.COM_private[i] = 0U;
-
-    /* Switch: '<S564>/Switch' incorporates:
-     *  Constant: '<S564>/Constant'
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreRead: '<S564>/Data Store Read'
-     *  Gain: '<S564>/Gain'
-     *  Product: '<S564>/Divide'
-     */
-    if (rtDW.MaxPositionCh1_private[i] != 0) {
-      q0 = 100 * (int16_t)div_nde_s32_floor
-        (Actuator_Ch1_Status_Model.in_CPOS_ALL[i], rtDW.MaxPositionCh1_private[i]);
-    } else {
-      q0 = 0;
-    }
-
-    /* End of Switch: '<S564>/Switch' */
-
-    /* Saturate: '<S564>/Saturation' */
-    if (q0 > 100) {
-      /* DataStoreWrite: '<S484>/Data Store Write2' */
-      rtb_DataTypeConversion_c1[i] = 100U;
-    } else if (q0 < 0) {
-      /* DataStoreWrite: '<S484>/Data Store Write2' */
-      rtb_DataTypeConversion_c1[i] = 0U;
-    } else {
-      /* DataStoreWrite: '<S484>/Data Store Write2' */
-      rtb_DataTypeConversion_c1[i] = (uint8_t)q0;
-    }
-
-    /* End of Saturate: '<S564>/Saturation' */
-  }
-
-  /* Switch: '<S484>/Switch' incorporates:
-   *  Constant: '<S484>/Constant1'
-   *  DataStoreRead: '<S484>/Data Store Read'
-   *  DataStoreRead: '<S484>/Data Store Read2'
+  rtDW.FIU_SET_FR = (uint16_t)((0.5 * (double)
+    rtDW.FIU_CCU1_MODEL.FIU_TargetTempFR_Val_ro + 15.5) * 10.0);
+
+  /* DataTypeConversion: '<S457>/Data Type  Conversion1' incorporates:
+   *  Bias: '<S480>/Bias'
+   *  DataStoreRead: '<S3>/Data Store Read2'
+   *  DataStoreWrite: '<S457>/Data Store Write1'
+   *  DataTypeConversion: '<S480>/Data Type  Conversion'
+   *  Gain: '<S480>/Gain'
+   *  Gain: '<S480>/Gain1'
    */
-  if (rtDW.stepSig_private_j > 0) {
-    rtb_Switch_hx = rtDW.stepSig_private_j;
-  } else {
-    rtb_Switch_hx = 1;
-  }
-
-  /* End of Switch: '<S484>/Switch' */
-
-  /* SwitchCase: '<S484>/Switch Case' */
-  switch (rtb_Switch_hx) {
-   case 1:
-    /* Outputs for IfAction SubSystem: '<S484>/Stop Mode' incorporates:
-     *  ActionPort: '<S563>/Action Port'
-     */
-    /* If: '<S563>/If1' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S563>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S617>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S617>/Data Store Write1' */
-        rtDW.COM_private_n[i] = 1U;
-
-        /* DataStoreWrite: '<S617>/Data Store Write' */
-        rtDW.MODE_private_a[i] = 2U;
-      }
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S617>/Constant'
-       *  Sum: '<S617>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S617>/Write' incorporates:
-       *  DataStoreRead: '<S617>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Stop Mode\n'); */
-        printf("[LIN 2] Stop Mode\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S617>/Write' */
-      /* End of Outputs for SubSystem: '<S563>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S563>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S618>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S618>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S563>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S563>/If1' */
-    /* End of Outputs for SubSystem: '<S484>/Stop Mode' */
-    break;
-
-   case 2:
-    /* Outputs for IfAction SubSystem: '<S484>/Initial CPOS Min' incorporates:
-     *  ActionPort: '<S559>/Action Port'
-     */
-    /* If: '<S559>/If' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S559>/If Action Subsystem' incorporates:
-       *  ActionPort: '<S605>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S605>/Data Store Write' */
-        rtDW.POS_private_o[i] = 6000U;
-
-        /* DataStoreWrite: '<S605>/Data Store Write1' */
-        rtDW.COM_private_n[i] = 2U;
-      }
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S605>/Constant'
-       *  Merge: '<S559>/Merge'
-       *  Sum: '<S605>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S605>/Write' incorporates:
-       *  DataStoreRead: '<S605>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Initial CPOS Min\n'); */
-        printf("[LIN 2] Initial CPOS Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S605>/Write' */
-      /* End of Outputs for SubSystem: '<S559>/If Action Subsystem' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S559>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S606>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Merge: '<S559>/Merge'
-       *  SignalConversion generated from: '<S606>/stepIn1'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S559>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S559>/If' */
-    /* End of Outputs for SubSystem: '<S484>/Initial CPOS Min' */
-    break;
-
-   case 3:
-    /* Outputs for IfAction SubSystem: '<S484>/Normal Mode' incorporates:
-     *  ActionPort: '<S562>/Action Port'
-     */
-    /* If: '<S562>/If1' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S562>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S614>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S614>/Data Store Write' */
-        rtDW.MODE_private_a[i] = 0U;
-
-        /* DataStoreWrite: '<S614>/Data Store Write1' */
-        rtDW.COM_private_n[i] = 1U;
-      }
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S614>/Constant'
-       *  Sum: '<S614>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S614>/Write' incorporates:
-       *  DataStoreRead: '<S614>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('LIN 2] Normal Mode\n'); */
-        printf("LIN 2] Normal Mode\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S614>/Write' */
-      /* End of Outputs for SubSystem: '<S562>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S562>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S615>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S615>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S562>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S562>/If1' */
-    /* End of Outputs for SubSystem: '<S484>/Normal Mode' */
-    break;
-
-   case 4:
-    /* Outputs for IfAction SubSystem: '<S484>/Move to position Min' incorporates:
-     *  ActionPort: '<S561>/Action Port'
-     */
-    /* If: '<S561>/If1' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S561>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S611>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S611>/Data Store Write4' incorporates:
-         *  Constant: '<S611>/Constant1'
-         */
-        rtDW.Autos_private_a[i] = 1U;
-
-        /* DataStoreWrite: '<S611>/Data Store Write2' incorporates:
-         *  Constant: '<S611>/Constant10'
-         */
-        rtDW.Stall_private_h[i] = 1U;
-
-        /* DataStoreWrite: '<S611>/Data Store Write3' */
-        rtDW.Lnoise_private_p[i] = 0U;
-
-        /* DataStoreWrite: '<S611>/Data Store Write5' incorporates:
-         *  Constant: '<S611>/Constant2'
-         */
-        rtDW.Speed_private_e[i] = 3U;
-
-        /* DataStoreWrite: '<S611>/Data Store Write6' incorporates:
-         *  Constant: '<S611>/Constant3'
-         */
-        rtDW.Coils_private_e[i] = 3U;
-
-        /* DataStoreWrite: '<S611>/Data Store Write' */
-        rtDW.POS_private_o[i] = 0U;
-
-        /* DataStoreWrite: '<S611>/Data Store Write1' incorporates:
-         *  Constant: '<S611>/Constant9'
-         */
-        rtDW.COM_private_n[i] = 3U;
-      }
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S611>/Constant'
-       *  Sum: '<S611>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S611>/Write' incorporates:
-       *  DataStoreRead: '<S611>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Move to position Min\n'); */
-        printf("[LIN 2] Move to position Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S611>/Write' */
-      /* End of Outputs for SubSystem: '<S561>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S561>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S612>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S612>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S561>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S561>/If1' */
-    /* End of Outputs for SubSystem: '<S484>/Move to position Min' */
-    break;
-
-   case 5:
-    /* Outputs for IfAction SubSystem: '<S484>/Check Stall Min' incorporates:
-     *  ActionPort: '<S556>/Action Port'
-     */
-    /* Logic: '<S556>/Logical Operator3' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreRead: '<S556>/Data Store Read'
-     *  Logic: '<S556>/Logical Operator1'
-     *  Logic: '<S556>/Logical Operator2'
-     *  RelationalOperator: '<S556>/Relational Operator'
-     *  RelationalOperator: '<S556>/Relational Operator1'
-     */
-    for (i = 0; i < 6; i++) {
-      rtb_LogicalOperator3_ev[i] =
-        ((Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1) ||
-         (Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 0) ||
-         (rtDW.ErrorCalibration_private_b[i] == 0));
-    }
-
-    /* End of Logic: '<S556>/Logical Operator3' */
-
-    /* Logic: '<S556>/Logical Operator' incorporates:
-     *  Logic: '<S556>/Logical Operator3'
-     */
-    rtb_LogicalOperator1 = rtb_LogicalOperator3_ev[0];
-    for (q0 = 0; q0 < 5; q0++) {
-      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_ev[q0
-        + 1]);
-    }
-
-    /* If: '<S556>/If2' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  DataTypeConversion: '<S556>/Data Type Conversion'
-     *  DataTypeConversion: '<S556>/Data Type Conversion1'
-     *  Logic: '<S556>/Logical Operator'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
-    {
-      /* Outputs for IfAction SubSystem: '<S556>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S569>/Action Port'
-       */
-      /* DataStoreWrite: '<S569>/Data Store Write1' */
-      for (q0 = 0; q0 < 9; q0++) {
-        /* Switch: '<S569>/Switch' incorporates:
-         *  DataStoreRead: '<S569>/Data Store Read1'
-         */
-        if (rtDW.ErrorCalibration_private_b[q0] != 0) {
-          rtDW.MinPositionCh1_private[q0] =
-            Actuator_Ch1_Status_Model.in_CPOS_ALL[q0];
-        }
-
-        /* End of Switch: '<S569>/Switch' */
-      }
-
-      /* End of DataStoreWrite: '<S569>/Data Store Write1' */
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S569>/Constant'
-       *  Sum: '<S569>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S569>/Write' incorporates:
-       *  DataStoreRead: '<S569>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Check Stall Min\n'); */
-        printf("[LIN 2] Check Stall Min\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(data) */
-        for (i = 0; i < 9; i++) {
-          /* :  fprintf('[LIN 2] MIN = %d ', int16(data(i))); */
-          printf("[LIN 2] MIN = %d ", Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
-          fflush(stdout);
-        }
-
-        /* :  fprintf('\n'); */
-        printf("\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S569>/Write' */
-      /* End of Outputs for SubSystem: '<S556>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S556>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S570>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S570>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S556>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S556>/If2' */
-    /* End of Outputs for SubSystem: '<S484>/Check Stall Min' */
-    break;
-
-   case 6:
-    /* Outputs for IfAction SubSystem: '<S484>/Initial CPOS Max' incorporates:
-     *  ActionPort: '<S558>/Action Port'
-     */
-    /* If: '<S558>/If1' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S558>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S602>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S602>/Data Store Write1' */
-        rtDW.COM_private_n[i] = 2U;
-
-        /* DataStoreWrite: '<S602>/Data Store Write' */
-        rtDW.POS_private_o[i] = 0U;
-      }
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S602>/Constant'
-       *  Sum: '<S602>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S602>/Write' incorporates:
-       *  DataStoreRead: '<S602>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Initial CPOS Max\n'); */
-        printf("[LIN 2] Initial CPOS Max\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S602>/Write' */
-      /* End of Outputs for SubSystem: '<S558>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S558>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S603>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S603>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S558>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S558>/If1' */
-    /* End of Outputs for SubSystem: '<S484>/Initial CPOS Max' */
-    break;
-
-   case 7:
-    /* Outputs for IfAction SubSystem: '<S484>/Move to position Max' incorporates:
-     *  ActionPort: '<S560>/Action Port'
-     */
-    /* If: '<S560>/If1' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S560>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S608>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S608>/Data Store Write4' incorporates:
-         *  Constant: '<S608>/Constant1'
-         */
-        rtDW.Autos_private_a[i] = 1U;
-
-        /* DataStoreWrite: '<S608>/Data Store Write2' incorporates:
-         *  Constant: '<S608>/Constant10'
-         */
-        rtDW.Stall_private_h[i] = 1U;
-
-        /* DataStoreWrite: '<S608>/Data Store Write3' */
-        rtDW.Lnoise_private_p[i] = 0U;
-
-        /* DataStoreWrite: '<S608>/Data Store Write5' incorporates:
-         *  Constant: '<S608>/Constant2'
-         */
-        rtDW.Speed_private_e[i] = 3U;
-
-        /* DataStoreWrite: '<S608>/Data Store Write6' incorporates:
-         *  Constant: '<S608>/Constant3'
-         */
-        rtDW.Coils_private_e[i] = 3U;
-
-        /* DataStoreWrite: '<S608>/Data Store Write' */
-        rtDW.POS_private_o[i] = 6000U;
-
-        /* DataStoreWrite: '<S608>/Data Store Write1' incorporates:
-         *  Constant: '<S608>/Constant9'
-         */
-        rtDW.COM_private_n[i] = 3U;
-      }
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S608>/Constant'
-       *  Sum: '<S608>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S608>/Write' incorporates:
-       *  DataStoreRead: '<S608>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Move to position Max\n'); */
-        printf("[LIN 2] Move to position Max\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S608>/Write' */
-      /* End of Outputs for SubSystem: '<S560>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S560>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S609>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S609>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S560>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S560>/If1' */
-    /* End of Outputs for SubSystem: '<S484>/Move to position Max' */
-    break;
-
-   case 8:
-    /* Outputs for IfAction SubSystem: '<S484>/Check Stall Max' incorporates:
-     *  ActionPort: '<S555>/Action Port'
-     */
-    /* Logic: '<S555>/Logical Operator3' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreRead: '<S555>/Data Store Read'
-     *  Logic: '<S555>/Logical Operator'
-     *  Logic: '<S555>/Logical Operator2'
-     *  RelationalOperator: '<S555>/Relational Operator'
-     *  RelationalOperator: '<S555>/Relational Operator1'
-     */
-    for (i = 0; i < 6; i++) {
-      rtb_LogicalOperator3_ev[i] =
-        ((Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1) ||
-         (Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 6000) ||
-         (rtDW.ErrorCalibration_private_b[i] == 0));
-    }
-
-    /* End of Logic: '<S555>/Logical Operator3' */
-
-    /* Logic: '<S555>/Logical Operator1' incorporates:
-     *  Logic: '<S555>/Logical Operator3'
-     */
-    rtb_LogicalOperator1 = rtb_LogicalOperator3_ev[0];
-    for (q0 = 0; q0 < 5; q0++) {
-      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_ev[q0
-        + 1]);
-    }
-
-    /* If: '<S555>/If2' incorporates:
-     *  DataStoreRead: '<S484>/Data Store Read1'
-     *  DataStoreWrite: '<S484>/Data Store Write1'
-     *  DataTypeConversion: '<S555>/Data Type Conversion'
-     *  DataTypeConversion: '<S555>/Data Type Conversion1'
-     *  Logic: '<S555>/Logical Operator1'
-     *  SignalConversion generated from: '<S484>/Bus Selector'
-     */
-    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
-        (Actuator_Ch1_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
-    {
-      /* Outputs for IfAction SubSystem: '<S555>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S566>/Action Port'
-       */
-      /* DataStoreWrite: '<S566>/Data Store Write1' */
-      for (i = 0; i < 9; i++) {
-        /* Switch: '<S566>/Switch' incorporates:
-         *  DataStoreRead: '<S566>/Data Store Read1'
-         */
-        if (rtDW.ErrorCalibration_private_b[i] != 0) {
-          rtDW.MaxPositionCh1_private[i] =
-            Actuator_Ch1_Status_Model.in_CPOS_ALL[i];
-        } else {
-          rtDW.MaxPositionCh1_private[i] = 0;
-        }
-
-        /* End of Switch: '<S566>/Switch' */
-      }
-
-      /* End of DataStoreWrite: '<S566>/Data Store Write1' */
-
-      /* Merge: '<S484>/Merge' incorporates:
-       *  Constant: '<S566>/Constant'
-       *  Sum: '<S566>/step inc'
-       */
-      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S566>/Write' incorporates:
-       *  DataStoreRead: '<S566>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 2] Check Stall MAX\n'); */
-        printf("[LIN 2] Check Stall MAX\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(data) */
-        for (i = 0; i < 9; i++) {
-          /* :  fprintf('[LIN 2] MAX = %d ', int16(data(i))); */
-          printf("[LIN 2] MAX = %d ", Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
-          fflush(stdout);
-        }
-
-        /* :  fprintf('\n'); */
-        printf("\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S566>/Write' */
-      /* End of Outputs for SubSystem: '<S555>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S555>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S567>/Action Port'
-       */
-      /* Merge: '<S484>/Merge' incorporates:
-       *  SignalConversion generated from: '<S567>/stepIn'
-       */
-      rtB.Merge_h = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S555>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S555>/If2' */
-    /* End of Outputs for SubSystem: '<S484>/Check Stall Max' */
-    break;
-
-   case 9:
-    /* Outputs for IfAction SubSystem: '<S484>/Homing' incorporates:
-     *  ActionPort: '<S557>/Action Port'
-     */
-    /* Product: '<S572>/Divide1' incorporates:
-     *  Constant: '<S572>/ACT1'
-     *  DataStoreRead: '<S572>/MAX ACT1T '
-     */
-    for (i = 0; i < 6; i++) {
-      rtb_Divide1_gdi[i] = (double)rtDW.MaxPositionCh1_private[i] / (double)
-        rtConstP.ACT1_Value_d[i];
-    }
-
-    /* End of Product: '<S572>/Divide1' */
-
-    /* SignalConversion generated from: '<S572>/Vector Concatenate' incorporates:
-     *  Constant: '<S572>/Constant'
-     */
-    rtb_Divide1_gdi[6] = 1.0;
-    rtb_Divide1_gdi[7] = 1.0;
-    rtb_Divide1_gdi[8] = 1.0;
-
-    /* SwitchCase: '<S557>/Switch Case' incorporates:
-     *  DataStoreRead: '<S557>/Data Store Read4'
-     */
-    switch (rtDW.stepHoming_private_p) {
-     case 0:
-      /* Outputs for IfAction SubSystem: '<S557>/Switch Case Action Subsystem' incorporates:
-       *  ActionPort: '<S573>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* RelationalOperator: '<S578>/Compare' */
-        rtb_Divide1 = rtb_Divide1_gdi[i];
-
-        /* Logic: '<S573>/Logical Operator' incorporates:
-         *  Constant: '<S578>/Constant'
-         *  Constant: '<S579>/Constant'
-         *  RelationalOperator: '<S578>/Compare'
-         *  RelationalOperator: '<S579>/Compare'
-         */
-        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
-        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S581>/Data Type Conversion' incorporates:
-         *  DataStoreRead: '<S581>/Data Store Read'
-         *  DataStoreWrite: '<S581>/Data Store Write'
-         *  Logic: '<S581>/Logical Operator'
-         *  Logic: '<S581>/Logical Operator1'
-         */
-        rtDW.ErrorCalibration_private_b[i] = (uint8_t)((!rtb_LogicalOperator1) &&
-          (rtDW.ErrorCalibration_private_b[i] != 0));
-      }
-
-      /* MATLAB Function: '<S573>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S573>/Data Store Read5'
-       *  DataStoreRead: '<S573>/MIN ACT1T 1'
-       *  Logic: '<S573>/Logical Operator2'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 2] Homing 0\n"); */
-        printf("[LIN 2] Homing 0\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 6; i++) {
-          /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-          printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                 (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
-                 rtb_Divide1_gdi[i], (int16_t)!rtb_LogicalOperator3_a0[i]);
-          fflush(stdout);
-        }
-      }
-
-      /* End of MATLAB Function: '<S573>/MAX POSITION' */
-
-      /* Logic: '<S573>/Logical Operator1' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* Switch: '<S573>/Switch' incorporates:
-       *  Logic: '<S573>/Logical Operator1'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S557>/Merge' incorporates:
-         *  Constant: '<S573>/Constant1'
-         */
-        rtB.Merge_hu = 4;
-      } else {
-        /* Merge: '<S557>/Merge' incorporates:
-         *  Constant: '<S573>/Constant'
-         */
-        rtB.Merge_hu = 1;
-      }
-
-      /* End of Switch: '<S573>/Switch' */
-      /* End of Outputs for SubSystem: '<S557>/Switch Case Action Subsystem' */
-      break;
-
-     case 1:
-      /* Outputs for IfAction SubSystem: '<S557>/Switch Case Action Subsystem1' incorporates:
-       *  ActionPort: '<S574>/Action Port'
-       */
-      /* RelationalOperator: '<S583>/Compare' incorporates:
-       *  Constant: '<S583>/Constant'
-       */
-      for (i = 0; i < 9; i++) {
-        rtb_LogicalOperator3_a0[i] = (rtb_Divide1_gdi[i] > 1.5);
-      }
-
-      /* End of RelationalOperator: '<S583>/Compare' */
-
-      /* Logic: '<S582>/Logical Operator' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* DataTypeConversion: '<S582>/Data Type Conversion' incorporates:
-       *  DataStoreWrite: '<S582>/Data Store Write1'
-       *  Logic: '<S582>/Logical Operator'
-       */
-      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
-      for (i = 0; i < 9; i++) {
-        /* DataTypeConversion: '<S582>/Data Type Conversion1' incorporates:
-         *  DataStoreWrite: '<S582>/Data Store Write2'
-         */
-        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
-        rtDW.COM_private_n[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S582>/Data Type Conversion2' incorporates:
-         *  DataStoreRead: '<S582>/Data Store Read'
-         *  DataStoreWrite: '<S582>/Data Store Write3'
-         *  Logic: '<S582>/Logical Operator1'
-         */
-        rtDW.ErrorActuator_c[i] = (uint8_t)(rtb_LogicalOperator1 ||
-          (rtDW.ErrorActuator_c[i] != 0));
-
-        /* DataStoreWrite: '<S582>/Data Store Write' */
-        rtDW.MODE_private_a[i] = 2U;
-      }
-
-      /* MATLAB Function: '<S582>/Write ERROR' incorporates:
-       *  DataStoreRead: '<S582>/Data Store Read6'
-       */
-      /* :  if(LOGGER>=0) */
-      if (rtDW.LOGGER_LIN >= 0.0) {
-        /* :  for i = 1:numel(ErrCallibration) */
-        for (i = 0; i < 9; i++) {
-          /* :  if ErrCallibration(i) == 1 */
-          if (rtb_LogicalOperator3_a0[i]) {
-            /* :  fprintf('[LIN 2] Failure with actuator #%d\n', int16(i)); */
-            printf("[LIN 2] Failure with actuator #%d\n", (int16_t)(i + 1));
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S582>/Write ERROR' */
-      for (i = 0; i < 9; i++) {
-        /* Logic: '<S574>/Logical Operator1' */
-        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
-
-        /* DataTypeConversion: '<S574>/Data Type Conversion' incorporates:
-         *  DataStoreRead: '<S574>/Data Store Read'
-         *  DataStoreWrite: '<S574>/Data Store Write'
-         *  Logic: '<S574>/Logical Operator'
-         *  Logic: '<S574>/Logical Operator1'
-         */
-        rtDW.ErrorCalibration_private_b[i] = (uint8_t)((!rtb_LogicalOperator1) &&
-          (rtDW.ErrorCalibration_private_b[i] != 0));
-
-        /* DataStoreWrite: '<S586>/Data Store Write' incorporates:
-         *  DataTypeConversion: '<S586>/Data Type Conversion'
-         */
-        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
-      }
-
-      /* DataStoreWrite: '<S585>/Data Store Write' incorporates:
-       *  Constant: '<S585>/Constant'
-       */
-      rtDW.stepSig_private_j = 1;
-
-      /* MATLAB Function: '<S574>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S574>/Data Store Read5'
-       *  DataStoreRead: '<S574>/MIN ACT1T 1'
-       *  DataStoreWrite: '<S574>/Data Store Write'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 2] Homing 1. Start Callibration \n"); */
-        printf("[LIN 2] Homing 1. Start Callibration \n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 6; i++) {
-          /* :  if(ERRORS(i)==1) */
-          if (rtDW.ErrorCalibration_private_b[i] == 1) {
-            /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-            printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                   (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
-                   rtb_Divide1_gdi[i], (int16_t)
-                   rtDW.ErrorCalibration_private_b[i]);
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S574>/MAX POSITION' */
-
-      /* Logic: '<S574>/Logical Operator2' incorporates:
-       *  DataStoreWrite: '<S574>/Data Store Write'
-       */
-      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private_b[0] != 0);
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          (rtDW.ErrorCalibration_private_b[q0 + 1] != 0));
-      }
-
-      /* Switch: '<S574>/Switch' incorporates:
-       *  Logic: '<S574>/Logical Operator2'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S557>/Merge' incorporates:
-         *  Constant: '<S585>/Constant1'
-         */
-        rtB.Merge_hu = 2;
-      } else {
-        /* Merge: '<S557>/Merge' incorporates:
-         *  Constant: '<S574>/Constant1'
-         */
-        rtB.Merge_hu = 4;
-      }
-
-      /* End of Switch: '<S574>/Switch' */
-      /* End of Outputs for SubSystem: '<S557>/Switch Case Action Subsystem1' */
-      break;
-
-     case 2:
-      /* Outputs for IfAction SubSystem: '<S557>/Switch Case Action Subsystem2' incorporates:
-       *  ActionPort: '<S575>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* RelationalOperator: '<S588>/Compare' */
-        rtb_Divide1 = rtb_Divide1_gdi[i];
-
-        /* Logic: '<S575>/Logical Operator3' incorporates:
-         *  Constant: '<S588>/Constant'
-         *  Constant: '<S589>/Constant'
-         *  DataStoreRead: '<S575>/Data Store Read'
-         *  Logic: '<S575>/Logical Operator1'
-         *  Logic: '<S575>/Logical Operator4'
-         *  RelationalOperator: '<S588>/Compare'
-         *  RelationalOperator: '<S589>/Compare'
-         */
-        rtb_LogicalOperator1 = (((rtb_Divide1 < 0.97) || (rtb_Divide1 > 1.03)) &&
-          (rtDW.ErrorCalibration_private_b[i] != 0));
-        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S575>/Data Type Conversion' incorporates:
-         *  DataStoreWrite: '<S575>/Data Store Write1'
-         */
-        rtDW.ErrorCalibration_private_b[i] = rtb_LogicalOperator1;
-      }
-
-      /* MATLAB Function: '<S575>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S575>/Data Store Read5'
-       *  DataStoreRead: '<S575>/MIN ACT1T 1'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 2] Homing 3. Callibration \n"); */
-        printf("[LIN 2] Homing 3. Callibration \n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 6; i++) {
-          /* :  if(ERRORS(i)==1) */
-          if (rtb_LogicalOperator3_a0[i]) {
-            /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-            printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                   (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
-                   rtb_Divide1_gdi[i], 1);
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S575>/MAX POSITION' */
-
-      /* Logic: '<S575>/Logical Operator2' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* Switch: '<S575>/Switch' incorporates:
-       *  Logic: '<S575>/Logical Operator2'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S557>/Merge' incorporates:
-         *  Constant: '<S575>/Constant3'
-         */
-        rtB.Merge_hu = 3;
-      } else {
-        /* Merge: '<S557>/Merge' incorporates:
-         *  Constant: '<S575>/Constant1'
-         */
-        rtB.Merge_hu = 4;
-      }
-
-      /* End of Switch: '<S575>/Switch' */
-      /* End of Outputs for SubSystem: '<S557>/Switch Case Action Subsystem2' */
-      break;
-
-     case 3:
-      /* Outputs for IfAction SubSystem: '<S557>/Switch Case Action Subsystem3' incorporates:
-       *  ActionPort: '<S576>/Action Port'
-       */
-      /* MATLAB Function: '<S576>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S576>/Data Store Read1'
-       *  DataStoreRead: '<S576>/Data Store Read5'
-       */
-      /* :  if(LOGGER>1) */
-      if (rtDW.LOGGER_LIN > 1.0) {
-        /* :  fprintf("[LIN 2] Homing 3. Start Time on step %d\n",int16(step)); */
-        rtb_Divide1 = rt_roundd(rtDW.ErrorHomming_private_j);
-        if (rtb_Divide1 < 32768.0) {
-          if (rtb_Divide1 >= -32768.0) {
-            AMB = (int16_t)rtb_Divide1;
-          } else {
-            AMB = INT16_MIN;
-          }
-        } else {
-          AMB = INT16_MAX;
-        }
-
-        printf("[LIN 2] Homing 3. Start Time on step %d\n", AMB);
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S576>/MAX POSITION' */
-
-      /* If: '<S576>/If' incorporates:
-       *  DataStoreRead: '<S576>/Data Store Read1'
-       */
-      if (rtDW.ErrorHomming_private_j < 10.0) {
-        /* Outputs for IfAction SubSystem: '<S576>/If Action Subsystem' incorporates:
-         *  ActionPort: '<S591>/Action Port'
-         */
-        /* MATLAB Function: '<S591>/MATLAB Function' incorporates:
-         *  DataStoreRead: '<S591>/Data Store Read'
-         *  DataStoreRead: '<S591>/Data Store Read1'
-         */
-        MATLABFunction(rtDW.Start_timer_l, rtDW.t_now, &rtb_dt_ih,
-                       &rtDW.sf_MATLABFunction_i);
-
-        /* MATLAB Function: '<S591>/MAX POSITION' incorporates:
-         *  DataStoreRead: '<S591>/Data Store Read5'
-         */
-        /* :  if(LOGGER>1) */
-        if (rtDW.LOGGER_LIN > 1.0) {
-          /* :  fprintf("[LIN 2] Homing 3. Start TIme dt = %d \n",int32(data)); */
-          rtb_dt_fa = rtb_dt_ih;
-          if (rtb_dt_ih > 2147483647U) {
-            rtb_dt_fa = 2147483647U;
-          }
-
-          printf("[LIN 2] Homing 3. Start TIme dt = %d \n", (int32_t)rtb_dt_fa);
-          fflush(stdout);
-        }
-
-        /* End of MATLAB Function: '<S591>/MAX POSITION' */
-
-        /* If: '<S591>/If' */
-        if (rtb_dt_ih > 30000U) {
-          /* Outputs for IfAction SubSystem: '<S591>/If Action Subsystem' incorporates:
-           *  ActionPort: '<S594>/Action Port'
-           */
-          /* Merge: '<S557>/Merge' */
-          IfActionSubsystem(&rtB.Merge_hu, &rtDW.ErrorHomming_private_j,
-                            &rtDW.Start_timer_l, &rtDW.stepSig_private_j);
-
-          /* End of Outputs for SubSystem: '<S591>/If Action Subsystem' */
-        } else {
-          /* Outputs for IfAction SubSystem: '<S591>/If Action Subsystem1' incorporates:
-           *  ActionPort: '<S595>/Action Port'
-           */
-          /* Merge: '<S557>/Merge' */
-          IfActionSubsystem1(&rtB.Merge_hu, &rtDW.Start_timer_l);
-
-          /* End of Outputs for SubSystem: '<S591>/If Action Subsystem1' */
-        }
-
-        /* End of If: '<S591>/If' */
-        /* End of Outputs for SubSystem: '<S576>/If Action Subsystem' */
-      } else {
-        /* Outputs for IfAction SubSystem: '<S576>/If Action Subsystem1' incorporates:
-         *  ActionPort: '<S592>/Action Port'
-         */
-        IfActionSubsystem1_d(&rtB.Merge_hu, &rtDW.CCU_ActuatorErrF_Stat_private,
-                             rtDW.COM_private_n, rtDW.ErrorActuator_c,
-                             rtDW.ErrorCalibration_private_b, &rtDW.LOGGER_LIN,
-                             rtDW.MODE_private_a, rtDW.dtc_state_error_model);
-
-        /* End of Outputs for SubSystem: '<S576>/If Action Subsystem1' */
-      }
-
-      /* End of If: '<S576>/If' */
-      /* End of Outputs for SubSystem: '<S557>/Switch Case Action Subsystem3' */
-      break;
-
-     case 4:
-      /* Outputs for IfAction SubSystem: '<S557>/Switch Case Action Subsystem4' incorporates:
-       *  ActionPort: '<S577>/Action Port'
-       */
-      /* DataStoreWrite: '<S577>/Data Store Write' incorporates:
-       *  Constant: '<S577>/Constant'
-       */
-      rtDW.stepSig_private_j = 10;
-
-      /* Merge: '<S557>/Merge' incorporates:
-       *  Constant: '<S577>/Constant1'
-       *  SignalConversion generated from: '<S577>/step'
-       */
-      rtB.Merge_hu = 5;
-
-      /* MATLAB Function: '<S577>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S577>/Data Store Read5'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 2] Homing. Callibration successful \n"); */
-        printf("[LIN 2] Homing. Callibration successful \n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S577>/MAX POSITION' */
-      /* End of Outputs for SubSystem: '<S557>/Switch Case Action Subsystem4' */
-      break;
-    }
-
-    /* End of SwitchCase: '<S557>/Switch Case' */
-
-    /* DataStoreWrite: '<S557>/Data Store Write2' */
-    rtDW.stepHoming_private_p = rtB.Merge_hu;
-
-    /* Merge: '<S484>/Merge' incorporates:
-     *  DataStoreRead: '<S557>/Data Store Read7'
-     */
-    rtB.Merge_h = rtDW.stepSig_private_j;
-
-    /* End of Outputs for SubSystem: '<S484>/Homing' */
-    break;
-  }
-
-  /* End of SwitchCase: '<S484>/Switch Case' */
-
-  /* DataStoreWrite: '<S484>/Finish write stepSig' */
-  rtDW.stepSig_private_j = rtB.Merge_h;
-
-  /* BusCreator: '<S553>/Bus Creator' incorporates:
-   *  DataStoreRead: '<S553>/Data Store Read'
-   *  DataStoreRead: '<S553>/Data Store Read1'
-   *  DataStoreRead: '<S553>/Data Store Read2'
-   *  DataStoreRead: '<S553>/Data Store Read3'
-   *  DataStoreRead: '<S553>/Data Store Read4'
-   *  DataStoreRead: '<S553>/Data Store Read5'
-   *  DataStoreRead: '<S553>/Data Store Read6'
-   *  DataStoreRead: '<S553>/Data Store Read7'
-   *  DataStoreRead: '<S553>/Data Store Read8'
-   *  DataStoreWrite: '<S553>/Data Store Write'
-   */
-  for (i = 0; i < 9; i++) {
-    Actuator_Ch1_Command_Model.POS[i] = rtDW.POS_private_o[i];
-    Actuator_Ch1_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_m[i];
-    Actuator_Ch1_Command_Model.MODE[i] = rtDW.MODE_private_a[i];
-    Actuator_Ch1_Command_Model.COM[i] = rtDW.COM_private_n[i];
-    Actuator_Ch1_Command_Model.Stall_SET[i] = rtDW.Stall_private_h[i];
-    Actuator_Ch1_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_p[i];
-    Actuator_Ch1_Command_Model.Autos_SET[i] = rtDW.Autos_private_a[i];
-    Actuator_Ch1_Command_Model.Speed_SET[i] = rtDW.Speed_private_e[i];
-    Actuator_Ch1_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_e[i];
-  }
-
-  /* End of BusCreator: '<S553>/Bus Creator' */
-
-  /* RelationalOperator: '<S565>/Compare' incorporates:
-   *  Constant: '<S565>/Constant'
-   *  DataStoreRead: '<S554>/Data Store Read2'
-   */
-  for (i = 0; i < 6; i++) {
-    rtb_Compare_l2[i] = (rtDW.ErrorCalibration_private_b[i] == 0);
-  }
-
-  /* End of RelationalOperator: '<S565>/Compare' */
-
-  /* Logic: '<S554>/Logical Operator' */
-  rtb_LogicalOperator1 = rtb_Compare_l2[0];
-  for (q0 = 0; q0 < 5; q0++) {
-    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_Compare_l2[q0 + 1]);
-  }
-
-  /* Switch: '<S554>/Switch1' incorporates:
-   *  Constant: '<S554>/Constant'
-   *  Constant: '<S554>/Constant3'
-   *  DataStoreRead: '<S554>/Data Store Read2'
-   *  Logic: '<S554>/Logical Operator'
-   *  Product: '<S554>/Product'
-   */
-  for (i = 0; i < 6; i++) {
-    if (rtb_LogicalOperator1) {
-      rtb_DataTypeConversion_np[i] = (uint8_t)((uint32_t)
-        rtDW.ErrorCalibration_private_b[i] * rtConstP.Constant3_Value_i[i]);
-    } else {
-      rtb_DataTypeConversion_np[i] = 0U;
-    }
-  }
-
-  /* End of Switch: '<S554>/Switch1' */
-
-  /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
-   *  Constant: '<S554>/Constant1'
-   */
-  rtb_DataTypeConversion_np[6] = 0U;
-  rtb_DataTypeConversion_np[7] = 0U;
-  rtb_DataTypeConversion_np[8] = 0U;
-  for (i = 0; i < 9; i++) {
-    /* DataStoreWrite: '<S554>/Data Store Write7' */
-    rtDW.BUS_ADR_private_m[i] = rtb_DataTypeConversion_np[i];
-
-    /* DataStoreWrite: '<S554>/Data Store Write' */
-    rtDW.COM_private_n[i] = 0U;
-
-    /* Switch: '<S631>/Switch' incorporates:
-     *  Constant: '<S631>/Constant'
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreRead: '<S631>/Data Store Read'
-     *  Gain: '<S631>/Gain'
-     *  Product: '<S631>/Divide'
-     */
-    if (rtDW.MaxPositionCh2_private[i] != 0) {
-      q0 = 100 * (int16_t)div_nde_s32_floor
-        (Actuator_Ch2_Status_Model.in_CPOS_ALL[i], rtDW.MaxPositionCh2_private[i]);
-    } else {
-      q0 = 0;
-    }
-
-    /* End of Switch: '<S631>/Switch' */
-
-    /* Saturate: '<S631>/Saturation' */
-    if (q0 > 100) {
-      /* DataTypeConversion: '<S631>/Data Type Conversion' */
-      rtb_DataTypeConversion_ns[i] = 100U;
-    } else if (q0 < 0) {
-      /* DataTypeConversion: '<S631>/Data Type Conversion' */
-      rtb_DataTypeConversion_ns[i] = 0U;
-    } else {
-      /* DataTypeConversion: '<S631>/Data Type Conversion' */
-      rtb_DataTypeConversion_ns[i] = (uint8_t)q0;
-    }
-
-    /* End of Saturate: '<S631>/Saturation' */
-  }
-
-  /* Switch: '<S485>/Switch' incorporates:
-   *  Constant: '<S485>/Constant1'
-   *  DataStoreRead: '<S485>/Data Store Read'
-   *  DataStoreRead: '<S485>/Data Store Read2'
-   */
-  if (rtDW.stepSig_private_o > 0) {
-    rtb_Switch_hx = rtDW.stepSig_private_o;
-  } else {
-    rtb_Switch_hx = 1;
-  }
-
-  /* End of Switch: '<S485>/Switch' */
-
-  /* SwitchCase: '<S485>/Switch Case' */
-  switch (rtb_Switch_hx) {
-   case 1:
-    /* Outputs for IfAction SubSystem: '<S485>/Stop Mode' incorporates:
-     *  ActionPort: '<S630>/Action Port'
-     */
-    /* If: '<S630>/If1' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S630>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S684>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S684>/Data Store Write1' */
-        rtDW.COM_private_b[i] = 1U;
-
-        /* DataStoreWrite: '<S684>/Data Store Write' */
-        rtDW.MODE_private_p[i] = 2U;
-      }
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S684>/Constant'
-       *  Sum: '<S684>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S684>/Write' incorporates:
-       *  DataStoreRead: '<S684>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Stop Mode\n'); */
-        printf("[LIN 3] Stop Mode\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S684>/Write' */
-      /* End of Outputs for SubSystem: '<S630>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S630>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S685>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S685>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S630>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S630>/If1' */
-    /* End of Outputs for SubSystem: '<S485>/Stop Mode' */
-    break;
-
-   case 2:
-    /* Outputs for IfAction SubSystem: '<S485>/Initial CPOS Min' incorporates:
-     *  ActionPort: '<S626>/Action Port'
-     */
-    /* If: '<S626>/If' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S626>/If Action Subsystem' incorporates:
-       *  ActionPort: '<S672>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S672>/Data Store Write' */
-        rtDW.POS_private_g[i] = 6000U;
-
-        /* DataStoreWrite: '<S672>/Data Store Write1' */
-        rtDW.COM_private_b[i] = 2U;
-      }
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S672>/Constant'
-       *  Merge: '<S626>/Merge'
-       *  Sum: '<S672>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S672>/Write' incorporates:
-       *  DataStoreRead: '<S672>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Initial CPOS Min\n'); */
-        printf("[LIN 3] Initial CPOS Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S672>/Write' */
-      /* End of Outputs for SubSystem: '<S626>/If Action Subsystem' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S626>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S673>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Merge: '<S626>/Merge'
-       *  SignalConversion generated from: '<S673>/stepIn1'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S626>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S626>/If' */
-    /* End of Outputs for SubSystem: '<S485>/Initial CPOS Min' */
-    break;
-
-   case 3:
-    /* Outputs for IfAction SubSystem: '<S485>/Normal Mode' incorporates:
-     *  ActionPort: '<S629>/Action Port'
-     */
-    /* If: '<S629>/If1' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S629>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S681>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S681>/Data Store Write' */
-        rtDW.MODE_private_p[i] = 0U;
-
-        /* DataStoreWrite: '<S681>/Data Store Write1' */
-        rtDW.COM_private_b[i] = 1U;
-      }
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S681>/Constant'
-       *  Sum: '<S681>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S681>/Write' incorporates:
-       *  DataStoreRead: '<S681>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Normal Mode\n'); */
-        printf("[LIN 3] Normal Mode\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S681>/Write' */
-      /* End of Outputs for SubSystem: '<S629>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S629>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S682>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S682>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S629>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S629>/If1' */
-    /* End of Outputs for SubSystem: '<S485>/Normal Mode' */
-    break;
-
-   case 4:
-    /* Outputs for IfAction SubSystem: '<S485>/Move to position Min' incorporates:
-     *  ActionPort: '<S628>/Action Port'
-     */
-    /* If: '<S628>/If1' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S628>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S678>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S678>/Data Store Write4' incorporates:
-         *  Constant: '<S678>/Constant1'
-         */
-        rtDW.Autos_private_k[i] = 1U;
-
-        /* DataStoreWrite: '<S678>/Data Store Write2' incorporates:
-         *  Constant: '<S678>/Constant10'
-         */
-        rtDW.Stall_private_h3[i] = 1U;
-
-        /* DataStoreWrite: '<S678>/Data Store Write3' */
-        rtDW.Lnoise_private_k[i] = 0U;
-
-        /* DataStoreWrite: '<S678>/Data Store Write5' incorporates:
-         *  Constant: '<S678>/Constant2'
-         */
-        rtDW.Speed_private_o[i] = 3U;
-
-        /* DataStoreWrite: '<S678>/Data Store Write6' incorporates:
-         *  Constant: '<S678>/Constant3'
-         */
-        rtDW.Coils_private_m[i] = 3U;
-
-        /* DataStoreWrite: '<S678>/Data Store Write' */
-        rtDW.POS_private_g[i] = 0U;
-
-        /* DataStoreWrite: '<S678>/Data Store Write1' incorporates:
-         *  Constant: '<S678>/Constant9'
-         */
-        rtDW.COM_private_b[i] = 3U;
-      }
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S678>/Constant'
-       *  Sum: '<S678>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S678>/Write' incorporates:
-       *  DataStoreRead: '<S678>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Move to position Min\n'); */
-        printf("[LIN 3] Move to position Min\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S678>/Write' */
-      /* End of Outputs for SubSystem: '<S628>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S628>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S679>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S679>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S628>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S628>/If1' */
-    /* End of Outputs for SubSystem: '<S485>/Move to position Min' */
-    break;
-
-   case 5:
-    /* Outputs for IfAction SubSystem: '<S485>/Check Stall Min' incorporates:
-     *  ActionPort: '<S623>/Action Port'
-     */
-    /* Logic: '<S623>/Logical Operator3' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreRead: '<S623>/Data Store Read'
-     *  Logic: '<S623>/Logical Operator1'
-     *  Logic: '<S623>/Logical Operator2'
-     *  RelationalOperator: '<S623>/Relational Operator'
-     *  RelationalOperator: '<S623>/Relational Operator1'
-     */
-    for (i = 0; i < 8; i++) {
-      rtb_Compare_l2[i] = ((Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1)
-                           || (Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 0) ||
-                           (rtDW.ErrorCalibration_private_h[i] == 0));
-    }
-
-    /* End of Logic: '<S623>/Logical Operator3' */
-
-    /* Logic: '<S623>/Logical Operator' incorporates:
-     *  Logic: '<S623>/Logical Operator3'
-     */
-    rtb_LogicalOperator1 = rtb_Compare_l2[0];
-    for (q0 = 0; q0 < 7; q0++) {
-      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_Compare_l2[q0 + 1]);
-    }
-
-    /* If: '<S623>/If2' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  DataTypeConversion: '<S623>/Data Type Conversion'
-     *  DataTypeConversion: '<S623>/Data Type Conversion1'
-     *  Logic: '<S623>/Logical Operator'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
-    {
-      /* Outputs for IfAction SubSystem: '<S623>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S636>/Action Port'
-       */
-      /* DataStoreWrite: '<S636>/Data Store Write1' */
-      for (q0 = 0; q0 < 9; q0++) {
-        /* Switch: '<S636>/Switch' incorporates:
-         *  DataStoreRead: '<S636>/Data Store Read1'
-         */
-        if (rtDW.ErrorCalibration_private_h[q0] != 0) {
-          rtDW.MinPositionCh2_private[q0] =
-            Actuator_Ch2_Status_Model.in_CPOS_ALL[q0];
-        }
-
-        /* End of Switch: '<S636>/Switch' */
-      }
-
-      /* End of DataStoreWrite: '<S636>/Data Store Write1' */
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S636>/Constant'
-       *  Sum: '<S636>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S636>/Write' incorporates:
-       *  DataStoreRead: '<S636>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Check Stall Min\n'); */
-        printf("[LIN 3] Check Stall Min\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(data) */
-        for (i = 0; i < 9; i++) {
-          /* :  fprintf('[LIN 3] MIN = %d ', int16(data(i))); */
-          printf("[LIN 3] MIN = %d ", Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
-          fflush(stdout);
-        }
-
-        /* :  fprintf('\n'); */
-        printf("\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S636>/Write' */
-      /* End of Outputs for SubSystem: '<S623>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S623>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S637>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S637>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S623>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S623>/If2' */
-    /* End of Outputs for SubSystem: '<S485>/Check Stall Min' */
-    break;
-
-   case 6:
-    /* Outputs for IfAction SubSystem: '<S485>/Initial CPOS Max' incorporates:
-     *  ActionPort: '<S625>/Action Port'
-     */
-    /* If: '<S625>/If1' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S625>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S669>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S669>/Data Store Write1' */
-        rtDW.COM_private_b[i] = 2U;
-
-        /* DataStoreWrite: '<S669>/Data Store Write' */
-        rtDW.POS_private_g[i] = 0U;
-      }
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S669>/Constant'
-       *  Sum: '<S669>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S669>/Write' incorporates:
-       *  DataStoreRead: '<S669>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Initial CPOS Max\n'); */
-        printf("[LIN 3] Initial CPOS Max\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S669>/Write' */
-      /* End of Outputs for SubSystem: '<S625>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S625>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S670>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S670>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S625>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S625>/If1' */
-    /* End of Outputs for SubSystem: '<S485>/Initial CPOS Max' */
-    break;
-
-   case 7:
-    /* Outputs for IfAction SubSystem: '<S485>/Move to position Max' incorporates:
-     *  ActionPort: '<S627>/Action Port'
-     */
-    /* If: '<S627>/If1' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
-      /* Outputs for IfAction SubSystem: '<S627>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S675>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* DataStoreWrite: '<S675>/Data Store Write4' incorporates:
-         *  Constant: '<S675>/Constant1'
-         */
-        rtDW.Autos_private_k[i] = 1U;
-
-        /* DataStoreWrite: '<S675>/Data Store Write2' incorporates:
-         *  Constant: '<S675>/Constant10'
-         */
-        rtDW.Stall_private_h3[i] = 1U;
-
-        /* DataStoreWrite: '<S675>/Data Store Write3' */
-        rtDW.Lnoise_private_k[i] = 0U;
-
-        /* DataStoreWrite: '<S675>/Data Store Write5' incorporates:
-         *  Constant: '<S675>/Constant2'
-         */
-        rtDW.Speed_private_o[i] = 3U;
-
-        /* DataStoreWrite: '<S675>/Data Store Write6' incorporates:
-         *  Constant: '<S675>/Constant3'
-         */
-        rtDW.Coils_private_m[i] = 3U;
-
-        /* DataStoreWrite: '<S675>/Data Store Write' */
-        rtDW.POS_private_g[i] = 6000U;
-
-        /* DataStoreWrite: '<S675>/Data Store Write1' incorporates:
-         *  Constant: '<S675>/Constant9'
-         */
-        rtDW.COM_private_b[i] = 3U;
-      }
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S675>/Constant'
-       *  Sum: '<S675>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S675>/Write' incorporates:
-       *  DataStoreRead: '<S675>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Move to position Max\n'); */
-        printf("[LIN 3] Move to position Max\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S675>/Write' */
-      /* End of Outputs for SubSystem: '<S627>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S627>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S676>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S676>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S627>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S627>/If1' */
-    /* End of Outputs for SubSystem: '<S485>/Move to position Max' */
-    break;
-
-   case 8:
-    /* Outputs for IfAction SubSystem: '<S485>/Check Stall Max' incorporates:
-     *  ActionPort: '<S622>/Action Port'
-     */
-    /* Logic: '<S622>/Logical Operator3' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreRead: '<S622>/Data Store Read'
-     *  Logic: '<S622>/Logical Operator'
-     *  Logic: '<S622>/Logical Operator2'
-     *  RelationalOperator: '<S622>/Relational Operator'
-     *  RelationalOperator: '<S622>/Relational Operator1'
-     */
-    for (i = 0; i < 8; i++) {
-      rtb_Compare_l2[i] = ((Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1)
-                           || (Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 6000)
-                           || (rtDW.ErrorCalibration_private_h[i] == 0));
-    }
-
-    /* End of Logic: '<S622>/Logical Operator3' */
-
-    /* Logic: '<S622>/Logical Operator1' incorporates:
-     *  Logic: '<S622>/Logical Operator3'
-     */
-    rtb_LogicalOperator1 = rtb_Compare_l2[0];
-    for (q0 = 0; q0 < 7; q0++) {
-      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_Compare_l2[q0 + 1]);
-    }
-
-    /* If: '<S622>/If2' incorporates:
-     *  DataStoreRead: '<S485>/Data Store Read1'
-     *  DataStoreWrite: '<S485>/Data Store Write1'
-     *  DataTypeConversion: '<S622>/Data Type Conversion'
-     *  DataTypeConversion: '<S622>/Data Type Conversion1'
-     *  Logic: '<S622>/Logical Operator1'
-     *  SignalConversion generated from: '<S485>/Bus Selector'
-     */
-    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
-        (Actuator_Ch2_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
-    {
-      /* Outputs for IfAction SubSystem: '<S622>/If Action Subsystem2' incorporates:
-       *  ActionPort: '<S633>/Action Port'
-       */
-      /* DataStoreWrite: '<S633>/Data Store Write1' */
-      for (i = 0; i < 9; i++) {
-        /* Switch: '<S633>/Switch' incorporates:
-         *  DataStoreRead: '<S633>/Data Store Read1'
-         */
-        if (rtDW.ErrorCalibration_private_h[i] != 0) {
-          rtDW.MaxPositionCh2_private[i] =
-            Actuator_Ch2_Status_Model.in_CPOS_ALL[i];
-        } else {
-          rtDW.MaxPositionCh2_private[i] = 0;
-        }
-
-        /* End of Switch: '<S633>/Switch' */
-      }
-
-      /* End of DataStoreWrite: '<S633>/Data Store Write1' */
-
-      /* Merge: '<S485>/Merge' incorporates:
-       *  Constant: '<S633>/Constant'
-       *  Sum: '<S633>/step inc'
-       */
-      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
-
-      /* MATLAB Function: '<S633>/Write' incorporates:
-       *  DataStoreRead: '<S633>/Data Store Read3'
-       */
-      /* :  if(LOGGER == 2) */
-      if (rtDW.LOGGER_LIN == 2.0) {
-        /* :  fprintf('[LIN 3] Check Stall MAX\n'); */
-        printf("[LIN 3] Check Stall MAX\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(data) */
-        for (i = 0; i < 9; i++) {
-          /* :  fprintf('[LIN 3] MAX = %d ', int16(data(i))); */
-          printf("[LIN 3] MAX = %d ", Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
-          fflush(stdout);
-        }
-
-        /* :  fprintf('\n'); */
-        printf("\n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S633>/Write' */
-      /* End of Outputs for SubSystem: '<S622>/If Action Subsystem2' */
-    } else {
-      /* Outputs for IfAction SubSystem: '<S622>/If Action Subsystem3' incorporates:
-       *  ActionPort: '<S634>/Action Port'
-       */
-      /* Merge: '<S485>/Merge' incorporates:
-       *  SignalConversion generated from: '<S634>/stepIn'
-       */
-      rtB.Merge_bj = rtb_Switch_hx;
-
-      /* End of Outputs for SubSystem: '<S622>/If Action Subsystem3' */
-    }
-
-    /* End of If: '<S622>/If2' */
-    /* End of Outputs for SubSystem: '<S485>/Check Stall Max' */
-    break;
-
-   case 9:
-    /* Outputs for IfAction SubSystem: '<S485>/Homing' incorporates:
-     *  ActionPort: '<S624>/Action Port'
-     */
-    /* Product: '<S639>/Divide1' incorporates:
-     *  Constant: '<S639>/ACT1'
-     *  DataStoreRead: '<S639>/MAX ACT1T '
-     */
-    for (i = 0; i < 8; i++) {
-      rtb_Divide1_gdi[i] = (double)rtDW.MaxPositionCh2_private[i] / (double)
-        rtConstP.ACT1_Value_o[i];
-    }
-
-    /* End of Product: '<S639>/Divide1' */
-
-    /* SignalConversion generated from: '<S639>/Vector Concatenate' incorporates:
-     *  Constant: '<S639>/Constant'
-     */
-    rtb_Divide1_gdi[8] = 1.0;
-
-    /* SwitchCase: '<S624>/Switch Case' incorporates:
-     *  DataStoreRead: '<S624>/Data Store Read4'
-     */
-    switch (rtDW.stepHoming_private_f) {
-     case 0:
-      /* Outputs for IfAction SubSystem: '<S624>/Switch Case Action Subsystem' incorporates:
-       *  ActionPort: '<S640>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* RelationalOperator: '<S645>/Compare' */
-        rtb_Divide1 = rtb_Divide1_gdi[i];
-
-        /* Logic: '<S640>/Logical Operator' incorporates:
-         *  Constant: '<S645>/Constant'
-         *  Constant: '<S646>/Constant'
-         *  RelationalOperator: '<S645>/Compare'
-         *  RelationalOperator: '<S646>/Compare'
-         */
-        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
-        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S648>/Data Type Conversion' incorporates:
-         *  DataStoreRead: '<S648>/Data Store Read'
-         *  DataStoreWrite: '<S648>/Data Store Write'
-         *  Logic: '<S648>/Logical Operator'
-         *  Logic: '<S648>/Logical Operator1'
-         */
-        rtDW.ErrorCalibration_private_h[i] = (uint8_t)((!rtb_LogicalOperator1) &&
-          (rtDW.ErrorCalibration_private_h[i] != 0));
-      }
-
-      /* MATLAB Function: '<S640>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S640>/Data Store Read5'
-       *  DataStoreRead: '<S640>/MIN ACT1T 1'
-       *  Logic: '<S640>/Logical Operator2'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 3] Homing 0\n"); */
-        printf("[LIN 3] Homing 0\n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 6; i++) {
-          /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-          printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                 (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
-                 rtb_Divide1_gdi[i], (int16_t)!rtb_LogicalOperator3_a0[i]);
-          fflush(stdout);
-        }
-      }
-
-      /* End of MATLAB Function: '<S640>/MAX POSITION' */
-
-      /* Logic: '<S640>/Logical Operator1' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* Switch: '<S640>/Switch' incorporates:
-       *  Logic: '<S640>/Logical Operator1'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S624>/Merge' incorporates:
-         *  Constant: '<S640>/Constant1'
-         */
-        rtB.Merge_j = 4;
-      } else {
-        /* Merge: '<S624>/Merge' incorporates:
-         *  Constant: '<S640>/Constant'
-         */
-        rtB.Merge_j = 1;
-      }
-
-      /* End of Switch: '<S640>/Switch' */
-      /* End of Outputs for SubSystem: '<S624>/Switch Case Action Subsystem' */
-      break;
-
-     case 1:
-      /* Outputs for IfAction SubSystem: '<S624>/Switch Case Action Subsystem1' incorporates:
-       *  ActionPort: '<S641>/Action Port'
-       */
-      /* RelationalOperator: '<S650>/Compare' incorporates:
-       *  Constant: '<S650>/Constant'
-       */
-      for (i = 0; i < 9; i++) {
-        rtb_LogicalOperator3_a0[i] = (rtb_Divide1_gdi[i] > 1.5);
-      }
-
-      /* End of RelationalOperator: '<S650>/Compare' */
-
-      /* Logic: '<S649>/Logical Operator' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* DataTypeConversion: '<S649>/Data Type Conversion' incorporates:
-       *  DataStoreWrite: '<S649>/Data Store Write1'
-       *  Logic: '<S649>/Logical Operator'
-       */
-      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
-      for (i = 0; i < 9; i++) {
-        /* DataTypeConversion: '<S649>/Data Type Conversion1' incorporates:
-         *  DataStoreWrite: '<S649>/Data Store Write2'
-         */
-        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
-        rtDW.COM_private_b[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S649>/Data Type Conversion2' incorporates:
-         *  DataStoreRead: '<S649>/Data Store Read'
-         *  DataStoreWrite: '<S649>/Data Store Write3'
-         *  Logic: '<S649>/Logical Operator1'
-         */
-        rtDW.ErrorActuator_o[i] = (uint8_t)(rtb_LogicalOperator1 ||
-          (rtDW.ErrorActuator_o[i] != 0));
-
-        /* DataStoreWrite: '<S649>/Data Store Write' */
-        rtDW.MODE_private_p[i] = 2U;
-      }
-
-      /* MATLAB Function: '<S649>/Write ERROR' incorporates:
-       *  DataStoreRead: '<S649>/Data Store Read6'
-       */
-      /* :  if(LOGGER>=0) */
-      if (rtDW.LOGGER_LIN >= 0.0) {
-        /* :  for i = 1:numel(ErrCallibration) */
-        for (i = 0; i < 9; i++) {
-          /* :  if ErrCallibration(i) == 1 */
-          if (rtb_LogicalOperator3_a0[i]) {
-            /* :  fprintf('[LIN 3] Failure with actuator #%d\n', int16(i)); */
-            printf("[LIN 3] Failure with actuator #%d\n", (int16_t)(i + 1));
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S649>/Write ERROR' */
-      for (i = 0; i < 9; i++) {
-        /* Logic: '<S641>/Logical Operator1' */
-        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
-
-        /* DataTypeConversion: '<S641>/Data Type Conversion' incorporates:
-         *  DataStoreRead: '<S641>/Data Store Read'
-         *  DataStoreWrite: '<S641>/Data Store Write'
-         *  Logic: '<S641>/Logical Operator'
-         *  Logic: '<S641>/Logical Operator1'
-         */
-        rtDW.ErrorCalibration_private_h[i] = (uint8_t)((!rtb_LogicalOperator1) &&
-          (rtDW.ErrorCalibration_private_h[i] != 0));
-
-        /* DataStoreWrite: '<S653>/Data Store Write' incorporates:
-         *  DataTypeConversion: '<S653>/Data Type Conversion'
-         */
-        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
-      }
-
-      /* DataStoreWrite: '<S652>/Data Store Write' incorporates:
-       *  Constant: '<S652>/Constant'
-       */
-      rtDW.stepSig_private_o = 1;
-
-      /* MATLAB Function: '<S641>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S641>/Data Store Read5'
-       *  DataStoreRead: '<S641>/MIN ACT1T 1'
-       *  DataStoreWrite: '<S641>/Data Store Write'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 3] Homing 1. Start Callibration \n"); */
-        printf("[LIN 3] Homing 1. Start Callibration \n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 6; i++) {
-          /* :  if(ERRORS(i)==1) */
-          if (rtDW.ErrorCalibration_private_h[i] == 1) {
-            /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-            printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                   (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
-                   rtb_Divide1_gdi[i], (int16_t)
-                   rtDW.ErrorCalibration_private_h[i]);
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S641>/MAX POSITION' */
-
-      /* Logic: '<S641>/Logical Operator2' incorporates:
-       *  DataStoreWrite: '<S641>/Data Store Write'
-       */
-      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private_h[0] != 0);
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          (rtDW.ErrorCalibration_private_h[q0 + 1] != 0));
-      }
-
-      /* Switch: '<S641>/Switch' incorporates:
-       *  Logic: '<S641>/Logical Operator2'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S624>/Merge' incorporates:
-         *  Constant: '<S652>/Constant1'
-         */
-        rtB.Merge_j = 2;
-      } else {
-        /* Merge: '<S624>/Merge' incorporates:
-         *  Constant: '<S641>/Constant1'
-         */
-        rtB.Merge_j = 4;
-      }
-
-      /* End of Switch: '<S641>/Switch' */
-      /* End of Outputs for SubSystem: '<S624>/Switch Case Action Subsystem1' */
-      break;
-
-     case 2:
-      /* Outputs for IfAction SubSystem: '<S624>/Switch Case Action Subsystem2' incorporates:
-       *  ActionPort: '<S642>/Action Port'
-       */
-      for (i = 0; i < 9; i++) {
-        /* RelationalOperator: '<S655>/Compare' */
-        rtb_Divide1 = rtb_Divide1_gdi[i];
-
-        /* Logic: '<S642>/Logical Operator3' incorporates:
-         *  Constant: '<S655>/Constant'
-         *  Constant: '<S656>/Constant'
-         *  DataStoreRead: '<S642>/Data Store Read'
-         *  Logic: '<S642>/Logical Operator1'
-         *  Logic: '<S642>/Logical Operator4'
-         *  RelationalOperator: '<S655>/Compare'
-         *  RelationalOperator: '<S656>/Compare'
-         */
-        rtb_LogicalOperator1 = (((rtb_Divide1 < 0.97) || (rtb_Divide1 > 1.03)) &&
-          (rtDW.ErrorCalibration_private_h[i] != 0));
-        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
-
-        /* DataTypeConversion: '<S642>/Data Type Conversion' incorporates:
-         *  DataStoreWrite: '<S642>/Data Store Write1'
-         */
-        rtDW.ErrorCalibration_private_h[i] = rtb_LogicalOperator1;
-      }
-
-      /* MATLAB Function: '<S642>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S642>/Data Store Read5'
-       *  DataStoreRead: '<S642>/MIN ACT1T 1'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 3] Homing 3. Callibration \n"); */
-        printf("[LIN 3] Homing 3. Callibration \n");
-        fflush(stdout);
-
-        /* :  for i = 1:numel(MAX) */
-        for (i = 0; i < 6; i++) {
-          /* :  if(ERRORS(i)==1) */
-          if (rtb_LogicalOperator3_a0[i]) {
-            /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
-            printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
-                   (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
-                   rtb_Divide1_gdi[i], 1);
-            fflush(stdout);
-          }
-        }
-      }
-
-      /* End of MATLAB Function: '<S642>/MAX POSITION' */
-
-      /* Logic: '<S642>/Logical Operator2' */
-      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
-      for (q0 = 0; q0 < 8; q0++) {
-        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
-          rtb_LogicalOperator3_a0[q0 + 1]);
-      }
-
-      /* Switch: '<S642>/Switch' incorporates:
-       *  Logic: '<S642>/Logical Operator2'
-       */
-      if (rtb_LogicalOperator1) {
-        /* Merge: '<S624>/Merge' incorporates:
-         *  Constant: '<S642>/Constant3'
-         */
-        rtB.Merge_j = 3;
-      } else {
-        /* Merge: '<S624>/Merge' incorporates:
-         *  Constant: '<S642>/Constant1'
-         */
-        rtB.Merge_j = 4;
-      }
-
-      /* End of Switch: '<S642>/Switch' */
-      /* End of Outputs for SubSystem: '<S624>/Switch Case Action Subsystem2' */
-      break;
-
-     case 3:
-      /* Outputs for IfAction SubSystem: '<S624>/Switch Case Action Subsystem3' incorporates:
-       *  ActionPort: '<S643>/Action Port'
-       */
-      /* MATLAB Function: '<S643>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S643>/Data Store Read1'
-       *  DataStoreRead: '<S643>/Data Store Read5'
-       */
-      /* :  if(LOGGER>1) */
-      if (rtDW.LOGGER_LIN > 1.0) {
-        /* :  fprintf("[LIN 3] Homing 3. Start Time on step %d\n",int16(step)); */
-        rtb_Divide1 = rt_roundd(rtDW.ErrorHomming_private_m);
-        if (rtb_Divide1 < 32768.0) {
-          if (rtb_Divide1 >= -32768.0) {
-            AMB = (int16_t)rtb_Divide1;
-          } else {
-            AMB = INT16_MIN;
-          }
-        } else {
-          AMB = INT16_MAX;
-        }
-
-        printf("[LIN 3] Homing 3. Start Time on step %d\n", AMB);
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S643>/MAX POSITION' */
-
-      /* If: '<S643>/If' incorporates:
-       *  DataStoreRead: '<S643>/Data Store Read1'
-       */
-      if (rtDW.ErrorHomming_private_m < 10.0) {
-        /* Outputs for IfAction SubSystem: '<S643>/If Action Subsystem' incorporates:
-         *  ActionPort: '<S658>/Action Port'
-         */
-        /* MATLAB Function: '<S658>/MATLAB Function' incorporates:
-         *  DataStoreRead: '<S658>/Data Store Read'
-         *  DataStoreRead: '<S658>/Data Store Read1'
-         */
-        MATLABFunction(rtDW.Start_timer, rtDW.t_now, &rtb_dt_ih,
-                       &rtDW.sf_MATLABFunction_c);
-
-        /* MATLAB Function: '<S658>/MAX POSITION' incorporates:
-         *  DataStoreRead: '<S658>/Data Store Read5'
-         */
-        /* :  if(LOGGER>1) */
-        if (rtDW.LOGGER_LIN > 1.0) {
-          /* :  fprintf("[LIN 3] Homing 3. Start TIme dt = %d \n",int32(data)); */
-          rtb_dt_fa = rtb_dt_ih;
-          if (rtb_dt_ih > 2147483647U) {
-            rtb_dt_fa = 2147483647U;
-          }
-
-          printf("[LIN 3] Homing 3. Start TIme dt = %d \n", (int32_t)rtb_dt_fa);
-          fflush(stdout);
-        }
-
-        /* End of MATLAB Function: '<S658>/MAX POSITION' */
-
-        /* If: '<S658>/If' */
-        if (rtb_dt_ih > 30000U) {
-          /* Outputs for IfAction SubSystem: '<S658>/If Action Subsystem' incorporates:
-           *  ActionPort: '<S661>/Action Port'
-           */
-          /* Merge: '<S624>/Merge' */
-          IfActionSubsystem(&rtB.Merge_j, &rtDW.ErrorHomming_private_m,
-                            &rtDW.Start_timer, &rtDW.stepSig_private_o);
-
-          /* End of Outputs for SubSystem: '<S658>/If Action Subsystem' */
-        } else {
-          /* Outputs for IfAction SubSystem: '<S658>/If Action Subsystem1' incorporates:
-           *  ActionPort: '<S662>/Action Port'
-           */
-          /* Merge: '<S624>/Merge' */
-          IfActionSubsystem1(&rtB.Merge_j, &rtDW.Start_timer);
-
-          /* End of Outputs for SubSystem: '<S658>/If Action Subsystem1' */
-        }
-
-        /* End of If: '<S658>/If' */
-        /* End of Outputs for SubSystem: '<S643>/If Action Subsystem' */
-      } else {
-        /* Outputs for IfAction SubSystem: '<S643>/If Action Subsystem1' incorporates:
-         *  ActionPort: '<S659>/Action Port'
-         */
-        IfActionSubsystem1_d(&rtB.Merge_j, &rtDW.CCU_ActuatorErrF_Stat_private,
-                             rtDW.COM_private_b, rtDW.ErrorActuator_o,
-                             rtDW.ErrorCalibration_private_h, &rtDW.LOGGER_LIN,
-                             rtDW.MODE_private_p, rtDW.dtc_state_error_model);
-
-        /* End of Outputs for SubSystem: '<S643>/If Action Subsystem1' */
-      }
-
-      /* End of If: '<S643>/If' */
-      /* End of Outputs for SubSystem: '<S624>/Switch Case Action Subsystem3' */
-      break;
-
-     case 4:
-      /* Outputs for IfAction SubSystem: '<S624>/Switch Case Action Subsystem4' incorporates:
-       *  ActionPort: '<S644>/Action Port'
-       */
-      /* DataStoreWrite: '<S644>/Data Store Write' incorporates:
-       *  Constant: '<S644>/Constant'
-       */
-      rtDW.stepSig_private_o = 10;
-
-      /* Merge: '<S624>/Merge' incorporates:
-       *  Constant: '<S644>/Constant1'
-       *  SignalConversion generated from: '<S644>/step'
-       */
-      rtB.Merge_j = 5;
-
-      /* MATLAB Function: '<S644>/MAX POSITION' incorporates:
-       *  DataStoreRead: '<S644>/Data Store Read5'
-       */
-      /* :  if(LOGGER>0) */
-      if (rtDW.LOGGER_LIN > 0.0) {
-        /* :  fprintf("[LIN 3] Homing. Callibration successful \n"); */
-        printf("[LIN 3] Homing. Callibration successful \n");
-        fflush(stdout);
-      }
-
-      /* End of MATLAB Function: '<S644>/MAX POSITION' */
-      /* End of Outputs for SubSystem: '<S624>/Switch Case Action Subsystem4' */
-      break;
-    }
-
-    /* End of SwitchCase: '<S624>/Switch Case' */
-
-    /* DataStoreWrite: '<S624>/Data Store Write2' */
-    rtDW.stepHoming_private_f = rtB.Merge_j;
-
-    /* Merge: '<S485>/Merge' incorporates:
-     *  DataStoreRead: '<S624>/Data Store Read7'
-     */
-    rtB.Merge_bj = rtDW.stepSig_private_o;
-
-    /* End of Outputs for SubSystem: '<S485>/Homing' */
-    break;
-  }
-
-  /* End of SwitchCase: '<S485>/Switch Case' */
-
-  /* Outport: '<Root>/CCU_Errors_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read10'
-   */
-  rtY.CCU_Errors_model = CCU_Errors_Model;
-
-  /* DataStoreWrite: '<S485>/Finish write stepSig' */
-  rtDW.stepSig_private_o = rtB.Merge_bj;
-
-  /* BusCreator: '<S620>/Bus Creator' incorporates:
-   *  DataStoreRead: '<S620>/Data Store Read'
-   *  DataStoreRead: '<S620>/Data Store Read1'
-   *  DataStoreRead: '<S620>/Data Store Read2'
-   *  DataStoreRead: '<S620>/Data Store Read3'
-   *  DataStoreRead: '<S620>/Data Store Read4'
-   *  DataStoreRead: '<S620>/Data Store Read5'
-   *  DataStoreRead: '<S620>/Data Store Read6'
-   *  DataStoreRead: '<S620>/Data Store Read7'
-   *  DataStoreRead: '<S620>/Data Store Read8'
-   *  DataStoreWrite: '<S620>/Data Store Write'
-   */
-  for (i = 0; i < 9; i++) {
-    Actuator_Ch2_Command_Model.POS[i] = rtDW.POS_private_g[i];
-    Actuator_Ch2_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_p[i];
-    Actuator_Ch2_Command_Model.MODE[i] = rtDW.MODE_private_p[i];
-    Actuator_Ch2_Command_Model.COM[i] = rtDW.COM_private_b[i];
-    Actuator_Ch2_Command_Model.Stall_SET[i] = rtDW.Stall_private_h3[i];
-    Actuator_Ch2_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_k[i];
-    Actuator_Ch2_Command_Model.Autos_SET[i] = rtDW.Autos_private_k[i];
-    Actuator_Ch2_Command_Model.Speed_SET[i] = rtDW.Speed_private_o[i];
-    Actuator_Ch2_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_m[i];
-  }
-
-  /* End of BusCreator: '<S620>/Bus Creator' */
-
-  /* RelationalOperator: '<S632>/Compare' incorporates:
-   *  Constant: '<S632>/Constant'
-   *  DataStoreRead: '<S621>/Data Store Read2'
-   */
-  for (i = 0; i < 8; i++) {
-    rtb_Compare_l2[i] = (rtDW.ErrorCalibration_private_h[i] == 0);
-  }
-
-  /* End of RelationalOperator: '<S632>/Compare' */
-
-  /* Logic: '<S621>/Logical Operator' */
-  rtb_LogicalOperator1 = rtb_Compare_l2[0];
-  for (q0 = 0; q0 < 7; q0++) {
-    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_Compare_l2[q0 + 1]);
-  }
-
-  /* Switch: '<S621>/Switch1' incorporates:
-   *  Constant: '<S621>/Constant'
-   *  Constant: '<S621>/Constant3'
-   *  DataStoreRead: '<S621>/Data Store Read2'
-   *  Logic: '<S621>/Logical Operator'
-   *  Product: '<S621>/Product'
-   */
-  for (i = 0; i < 8; i++) {
-    if (rtb_LogicalOperator1) {
-      rtb_DataTypeConversion_np[i] = (uint8_t)((uint32_t)
-        rtDW.ErrorCalibration_private_h[i] * rtConstP.Constant3_Value_j[i]);
-    } else {
-      rtb_DataTypeConversion_np[i] = 0U;
-    }
-  }
-
-  /* End of Switch: '<S621>/Switch1' */
-
-  /* SignalConversion generated from: '<S621>/Vector Concatenate' incorporates:
-   *  Constant: '<S621>/Constant1'
-   */
-  rtb_DataTypeConversion_np[8] = 0U;
-  for (i = 0; i < 9; i++) {
-    /* DataStoreWrite: '<S621>/Data Store Write7' */
-    rtDW.BUS_ADR_private_p[i] = rtb_DataTypeConversion_np[i];
-
-    /* DataStoreWrite: '<S621>/Data Store Write' */
-    rtDW.COM_private_b[i] = 0U;
-  }
-
-  /* DataStoreWrite: '<S5>/Data Store Write' incorporates:
-   *  Constant: '<S5>/Constant'
-   */
-  rtDW.LOGGER_LIN = 1.0;
-
-  /* BusCreator: '<S7>/Bus Creator' incorporates:
-   *  Constant: '<S7>/Constant2'
-   *  Constant: '<S7>/Constant3'
-   *  DataStoreRead: '<S7>/Data Store Read3'
-   *  DataStoreRead: '<S7>/Data Store Read4'
-   *  DataStoreWrite: '<S7>/Data Store Write'
-   */
-  PWM_Get.pwmPercentFront = rtDW.PWM_front;
-  PWM_Get.pwmPercentRear = rtDW.PWM_rear;
-  PWM_Get.pwmPercentFrontReserved = 0U;
-  PWM_Get.pwmPercentRearReserved = 0U;
-
-  /* MATLAB Function: '<S7>/Write' incorporates:
-   *  DataStoreRead: '<S7>/Data Store Read'
-   */
-  /* :  if(LOGGER) */
-  /* :  fprintf('pwmPercentFront = %u \n',data); */
-  printf("pwmPercentFront = %u \n", rtDW.PWM_Set_Model.pwmPercentFront);
-  fflush(stdout);
-
-  /* MATLAB Function: '<S7>/Write1' incorporates:
-   *  DataStoreRead: '<S7>/Data Store Read'
-   */
-  /* :  if(LOGGER) */
-  /* :  fprintf('pwmPercentRear = %u \n',data); */
-  printf("pwmPercentRear = %u \n", rtDW.PWM_Set_Model.pwmPercentRear);
-  fflush(stdout);
-
-  /* MATLAB Function: '<S7>/Write2' incorporates:
-   *  DataStoreRead: '<S7>/Data Store Read'
-   */
-  /* :  if(LOGGER) */
-  /* :  fprintf('pwmPercentFrontReserved = %u \n',data); */
-  printf("pwmPercentFrontReserved = %u \n",
-         rtDW.PWM_Set_Model.pwmPercentFrontReserved);
-  fflush(stdout);
-
-  /* MATLAB Function: '<S7>/Write3' incorporates:
-   *  DataStoreRead: '<S7>/Data Store Read'
-   */
-  /* :  if(LOGGER) */
-  /* :  fprintf('pwmPercentRearReserved = %u \n',data); */
-  printf("pwmPercentRearReserved = %u \n",
-         rtDW.PWM_Set_Model.pwmPercentRearReserved);
-  fflush(stdout);
-
-  /* BusCreator: '<S1238>/Bus Creator1' incorporates:
-   *  DataStoreRead: '<S1238>/Data Store Read1'
-   *  DataStoreRead: '<S1238>/Data Store Read10'
-   *  DataStoreRead: '<S1238>/Data Store Read11'
-   *  DataStoreRead: '<S1238>/Data Store Read13'
-   *  DataStoreRead: '<S1238>/Data Store Read15'
-   *  DataStoreRead: '<S1238>/Data Store Read17'
-   *  DataStoreRead: '<S1238>/Data Store Read19'
-   *  DataStoreRead: '<S1238>/Data Store Read3'
-   *  DataStoreRead: '<S1238>/Data Store Read4'
-   *  DataStoreRead: '<S1238>/Data Store Read8'
-   *  DataStoreWrite: '<S1238>/Data Store Write1'
-   */
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Fb_Select = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Lower_Fb = Duct3_F;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Lower_Tgt = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Side_Fb = Duct5_F;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Upper_Fb = Duct1_F;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Upper_Tgt = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_MultMsg_Idx = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Fb_Select = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Lower_Fb = Duct4_F;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Lower_Tgt = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Side_Fb = Duct6_F;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Upper_Fb = Duct2_F;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Upper_Tgt = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Fb = Duct3_R;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Fb_Select = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Side_Fb = Duct1_R;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Tgt = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Fb = Duct4_R;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Fb_Select = 0;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Side_Fb = Duct2_R;
-  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Tgt = 0;
-
-  /* BusCreator: '<S1239>/Bus Creator1' incorporates:
-   *  DataStoreRead: '<S1239>/Data Store Read3'
-   *  DataStoreRead: '<S1239>/Data Store Read4'
-   *  DataStoreWrite: '<S1239>/Data Store Write1'
-   */
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act00_Def = Actuator_pos_percent_Ch0[0];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act01_Vent_SFL = Actuator_pos_percent_Ch0[5];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act02_Vent_CFL = Actuator_pos_percent_Ch0[4];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act03_Foot_1FL = Actuator_pos_percent_Ch0[7];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act04_Foot_2FL = Actuator_pos_percent_Ch0[8];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act05_Vent_CFR = rtb_DataTypeConversion_c1[1];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act06_Vent_SFR = rtb_DataTypeConversion_c1[2];
-  rtDW.dbgCAN_dbg_Act0_model.dbg_Act07_Foot_1FR = rtb_DataTypeConversion_c1[4];
-
-  /* BusCreator: '<S1239>/Bus Creator3' incorporates:
-   *  DataStoreRead: '<S1239>/Data Store Read3'
-   *  DataStoreRead: '<S1239>/Data Store Read4'
-   *  DataStoreWrite: '<S1239>/Data Store Write2'
-   *  DataStoreWrite: '<S485>/Data Store Write2'
-   */
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act16_TempL_FL = Actuator_pos_percent_Ch0[6];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act17_TempU_FR = rtb_DataTypeConversion_c1[0];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act18_TempL_FR = rtb_DataTypeConversion_c1[3];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act19_Temp_RL = rtb_DataTypeConversion_ns[1];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act20_Temp_RR = rtb_DataTypeConversion_ns[0];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act21_Rec = Actuator_pos_percent_Ch0[1];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act22_OSA = rtb_DataTypeConversion_ns[8];
-  rtDW.dbgCAN_dbg_Act2_model.dbg_Act23_SealingValve = Actuator_pos_percent_Ch0[2];
-
-  /* BusCreator: '<S1239>/Bus Creator2' incorporates:
-   *  DataStoreRead: '<S1239>/Data Store Read3'
-   *  DataStoreRead: '<S1239>/Data Store Read4'
-   *  DataStoreWrite: '<S1239>/Data Store Write3'
-   *  DataStoreWrite: '<S485>/Data Store Write2'
-   */
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act08_Foot_2FR = rtb_DataTypeConversion_c1[5];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act09_Vent_SRL = rtb_DataTypeConversion_ns[2];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act10_Vent_CRL = rtb_DataTypeConversion_ns[4];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act11_Foot_RL = rtb_DataTypeConversion_ns[3];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act12_Vent_CRR = rtb_DataTypeConversion_ns[5];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act13_Vent_SRR = rtb_DataTypeConversion_ns[7];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act14_Foot_RR = rtb_DataTypeConversion_ns[6];
-  rtDW.dbgCAN_dbg_Act1_model.dbg_Act15_TempU_FL = Actuator_pos_percent_Ch0[3];
-
-  /* BusCreator: '<S1240>/Bus Creator' incorporates:
-   *  DataStoreRead: '<S1240>/Data Store Read'
-   *  DataStoreRead: '<S1240>/Data Store Read1'
-   *  DataStoreWrite: '<S1240>/Data Store Write'
-   */
-  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_F = Eva_F;
-  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_R = Eva_R;
-  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_Target = 0;
-  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_Diff_FrontRear = 0;
-
-  /* Outport: '<Root>/PWM_Get' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read7'
-   */
-  rtY.PWM_Get_f = PWM_Get;
-
-  /* Outport: '<Root>/dtc_state_error_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read1'
-   */
-  memcpy(&rtY.dtc_state_error_model[0], &rtDW.dtc_state_error_model[0], 127U *
-         sizeof(uint8_t));
-
-  /* Outport: '<Root>/dbgCAN_dbg_Act0_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read3'
-   */
-  rtY.dbgCAN_dbg_Act0_model = rtDW.dbgCAN_dbg_Act0_model;
-
-  /* Outport: '<Root>/dbgCAN_dbg_Act1_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read4'
-   */
-  rtY.dbgCAN_dbg_Act1_model = rtDW.dbgCAN_dbg_Act1_model;
-
-  /* Outport: '<Root>/dbgCAN_dbg_Act2_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read5'
-   */
-  rtY.dbgCAN_dbg_Act2_model = rtDW.dbgCAN_dbg_Act2_model;
-
-  /* Outport: '<Root>/CCU_Stat1_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read6'
-   */
-  rtY.CCU_Stat1_model = rtDW.CCU_STAT1_MODEL;
-
-  /* Outport: '<Root>/dbgCAN_dbg_Sen_Duct_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read8'
-   */
-  rtY.dbgCAN_dbg_Sen_Duct_model = rtDW.dbgCAN_dbg_Sen_Duct_model;
-
-  /* Outport: '<Root>/dbgCAN_dbg_Sen_Eva_model' incorporates:
-   *  DataStoreRead: '<Root>/Data Store Read9'
-   */
-  rtY.dbgCAN_dbg_Sen_Eva_model = rtDW.dbgCAN_dbg_Sen_Eva_model;
+  FIU_SET_RR = (uint16_t)((0.5 * (double)
+    rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro + 15.5) * 10.0);
 
   /* Outputs for Enabled SubSystem: '<S3>/Subsystem1' incorporates:
    *  EnablePort: '<S435>/Enable'
@@ -12340,16 +8820,21 @@ void HVAC_model_step(void)
   /* Outputs for Enabled SubSystem: '<S3>/Subsystem14' incorporates:
    *  EnablePort: '<S440>/Enable'
    */
+  /* SignalConversion generated from: '<S3>/Bus Selector' incorporates:
+   *  DataStoreRead: '<S3>/Data Store Read1'
+   */
   if (rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFL_Req > 0) {
     /* DataStoreWrite: '<S440>/Data Store Write14' */
     rtDW.FIU_BLOWERS_FL = rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFL_Req;
   }
 
+  /* End of SignalConversion generated from: '<S3>/Bus Selector' */
   /* End of Outputs for SubSystem: '<S3>/Subsystem14' */
 
   /* Outputs for Enabled SubSystem: '<S3>/Subsystem15' incorporates:
    *  EnablePort: '<S441>/Enable'
    */
+  /* DataStoreRead: '<S3>/Data Store Read1' */
   if (rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFR_Req > 0) {
     /* DataStoreWrite: '<S441>/Data Store Write15' */
     rtDW.FIU_BLOWERS_FR = rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFR_Req;
@@ -12387,40 +8872,6 @@ void HVAC_model_step(void)
 
   /* End of Outputs for SubSystem: '<S3>/Subsystem18' */
 
-  /* Outputs for Enabled SubSystem: '<S3>/Subsystem5' incorporates:
-   *  EnablePort: '<S474>/Enable'
-   */
-  if (rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro > 0) {
-    /* DataTypeConversion: '<S481>/Data Type  Conversion1' incorporates:
-     *  Bias: '<S481>/Bias'
-     *  DataStoreWrite: '<S474>/Data Store Write1'
-     *  DataTypeConversion: '<S481>/Data Type  Conversion'
-     *  Gain: '<S481>/Gain'
-     *  Gain: '<S481>/Gain1'
-     */
-    rtDW.FIU_SET_FL = (uint8_t)((0.5 * (double)
-      rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro + 15.5) * 10.0);
-  }
-
-  /* End of Outputs for SubSystem: '<S3>/Subsystem5' */
-
-  /* Outputs for Enabled SubSystem: '<S3>/Subsystem6' incorporates:
-   *  EnablePort: '<S475>/Enable'
-   */
-  if (rtDW.FIU_CCU1_MODEL.FIU_TargetTempFR_Val_ro > 0) {
-    /* DataTypeConversion: '<S482>/Data Type  Conversion1' incorporates:
-     *  Bias: '<S482>/Bias'
-     *  DataStoreWrite: '<S475>/Data Store Write'
-     *  DataTypeConversion: '<S482>/Data Type  Conversion'
-     *  Gain: '<S482>/Gain'
-     *  Gain: '<S482>/Gain1'
-     */
-    rtDW.FIU_SET_FR = (uint8_t)((0.5 * (double)
-      rtDW.FIU_CCU1_MODEL.FIU_TargetTempFR_Val_ro + 15.5) * 10.0);
-  }
-
-  /* End of Outputs for SubSystem: '<S3>/Subsystem6' */
-
   /* Outputs for Enabled SubSystem: '<S3>/Subsystem7' incorporates:
    *  EnablePort: '<S476>/Enable'
    */
@@ -12449,343 +8900,4790 @@ void HVAC_model_step(void)
     rtDW.FIU_FOOT_FL = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Foot_Req;
   }
 
-  /* End of DataStoreRead: '<S3>/Data Store Read1' */
   /* End of Outputs for SubSystem: '<S3>/Subsystem9' */
 
-  /* Outputs for Enabled SubSystem: '<S3>/Subsystem2' incorporates:
-   *  EnablePort: '<S446>/Enable'
+  /* BusCreator: '<S4>/Bus Creator' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read'
+   *  DataStoreRead: '<S4>/Data Store Read1'
+   *  DataStoreRead: '<S4>/Data Store Read10'
+   *  DataStoreRead: '<S4>/Data Store Read17'
+   *  DataStoreRead: '<S4>/Data Store Read18'
+   *  DataStoreRead: '<S4>/Data Store Read19'
+   *  DataStoreRead: '<S4>/Data Store Read2'
+   *  DataStoreRead: '<S4>/Data Store Read20'
+   *  DataStoreRead: '<S4>/Data Store Read21'
+   *  DataStoreRead: '<S4>/Data Store Read22'
+   *  DataStoreRead: '<S4>/Data Store Read23'
+   *  DataStoreRead: '<S4>/Data Store Read24'
+   *  DataStoreRead: '<S4>/Data Store Read3'
+   *  DataStoreRead: '<S4>/Data Store Read4'
+   *  DataStoreRead: '<S4>/Data Store Read5'
+   *  DataStoreRead: '<S4>/Data Store Read6'
+   *  DataStoreRead: '<S4>/Data Store Read7'
+   *  DataStoreRead: '<S4>/Data Store Read8'
+   *  DataStoreRead: '<S4>/Data Store Read9'
+   *  DataStoreWrite: '<S4>/Data Store Write'
+   *  Switch: '<S485>/Switch'
+   *  Switch: '<S486>/Switch'
+   *  Switch: '<S487>/Switch'
+   *  Switch: '<S488>/Switch'
+   *  Switch: '<S489>/Switch'
+   *  Switch: '<S490>/Switch'
+   *  Switch: '<S491>/Switch'
+   *  Switch: '<S492>/Switch'
+   *  Switch: '<S495>/Switch'
+   *  Switch: '<S496>/Switch'
+   *  Switch: '<S497>/Switch'
+   *  Switch: '<S498>/Switch'
+   *  Switch: '<S499>/Switch'
+   *  Switch: '<S500>/Switch'
    */
-  /* DataStoreRead: '<S3>/Data Store Read2' */
-  if (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRL_Val_ro > 0) {
-    /* DataTypeConversion: '<S446>/Data Type  Conversion1' incorporates:
-     *  Bias: '<S479>/Bias'
-     *  DataStoreWrite: '<S446>/Data Store Write1'
-     *  DataTypeConversion: '<S479>/Data Type  Conversion'
-     *  Gain: '<S479>/Gain'
-     *  Gain: '<S479>/Gain1'
+  rtDW.CCU_STAT1_MODEL.CCU_ModeFL_Stat = (uint8_t)(rtDW.FIU_MODE_FL > 1);
+  rtDW.CCU_STAT1_MODEL.CCU_ModeFR_Stat = (uint8_t)(rtDW.FIU_MODE_FR > 1);
+  rtDW.CCU_STAT1_MODEL.CCU_ModeRL_Stat = (uint8_t)(rtDW.FIU_MODE_RL > 1);
+  rtDW.CCU_STAT1_MODEL.CCU_ModeRR_Stat = (uint8_t)(rtDW.FIU_MODE_RR > 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AutoModeFL_Stat = rtDW.FIU_AUTOMODE_FL;
+  rtDW.CCU_STAT1_MODEL.CCU_AutoModeFR_Stat = rtDW.FIU_AUTOMODE_FR;
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRL_Face_Stat = (uint8_t)(rtDW.FIU_FACE_RL
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRL_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_RL
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AutoModeRL_Stat = rtDW.FIU_AUTOMODE_RL;
+  rtDW.CCU_STAT1_MODEL.CCU_AutoModeRR_Stat = rtDW.FIU_AUTOMODE_RR;
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRR_Face_Stat = (uint8_t)(rtDW.FIU_FACE_RR
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRR_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_RR
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Def_Stat = (uint8_t)(rtDW.FIU_DEF_FL <=
+    1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Face_Stat = (uint8_t)(rtDW.FIU_FACE_FL
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_FL
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Def_Stat = (uint8_t)(rtDW.FIU_DEF_FR <=
+    1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Face_Stat = (uint8_t)(rtDW.FIU_FACE_FR
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_FR
+    <= 1);
+  rtDW.CCU_STAT1_MODEL.CCU_Recirculation_Stat = rtDW.FIU_RECIRC;
+
+  /* Switch: '<S4>/Switch4' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read11'
+   */
+  if (rtDW.FIU_BLOWERS_FL > 7) {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  Constant: '<S4>/manual1'
+     *  DataStoreWrite: '<S4>/Data Store Write'
      */
-    rtDW.FIU_SET_RL = (uint8_t)((0.5 * (double)
-      rtDW.FIU_CCU2_MODEL.FIU_TargetTempRL_Val_ro + 15.5) * 10.0);
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFL_Stat = 0U;
+  } else {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFL_Stat = rtDW.FIU_BLOWERS_FL;
   }
 
-  /* End of Outputs for SubSystem: '<S3>/Subsystem2' */
+  /* End of Switch: '<S4>/Switch4' */
 
-  /* Outputs for Enabled SubSystem: '<S3>/Subsystem3' incorporates:
-   *  EnablePort: '<S457>/Enable'
+  /* Saturate: '<S483>/Saturation' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read13'
    */
-  if (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro > 0) {
-    /* DataTypeConversion: '<S457>/Data Type  Conversion1' incorporates:
-     *  Bias: '<S480>/Bias'
-     *  DataStoreWrite: '<S457>/Data Store Write1'
-     *  DataTypeConversion: '<S480>/Data Type  Conversion'
-     *  Gain: '<S480>/Gain'
-     *  Gain: '<S480>/Gain1'
-     */
-    rtDW.FIU_SET_RR = (uint8_t)((0.5 * (double)
-      rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro + 15.5) * 10.0);
+  if (rtDW.FIU_SET_FL > 310) {
+    rtb_out_oc = 310U;
+  } else if (rtDW.FIU_SET_FL < 155) {
+    rtb_out_oc = 155U;
+  } else {
+    rtb_out_oc = rtDW.FIU_SET_FL;
   }
 
-  /* End of DataStoreRead: '<S3>/Data Store Read2' */
-  /* End of Outputs for SubSystem: '<S3>/Subsystem3' */
-
-  /* Outputs for Atomic SubSystem: '<Root>/PWM and valves in manual' */
-  /* MATLAB Function: '<S688>/AF for Vent mode' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* BusCreator: '<S4>/Bus Creator' incorporates:
+   *  Bias: '<S483>/Bias'
+   *  DataStoreWrite: '<S4>/Data Store Write'
+   *  DataTypeConversion: '<S483>/Data Type Conversion'
+   *  Gain: '<S483>/Gain'
+   *  Gain: '<S483>/Gain1'
+   *  Saturate: '<S483>/Saturation'
    */
-  AFforVentmode(rtDW.FIU_BLOWERS_FR, &rtb_out_ee);
+  rtDW.CCU_STAT1_MODEL.CCU_TargetTempFL_Stat_ro = (uint8_t)((0.10000038146972656
+    * (double)rtb_out_oc - 15.5) * 2.0);
 
-  /* MATLAB Function: '<S688>/AF for Bi Level' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* Switch: '<S4>/Switch5' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read12'
    */
-  AFforBiLevel(rtDW.FIU_BLOWERS_FR, &rtb_out_bc);
+  if (rtDW.FIU_BLOWERS_FR > 7) {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  Constant: '<S4>/manual1'
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFR_Stat = 0U;
+  } else {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFR_Stat = rtDW.FIU_BLOWERS_FR;
+  }
 
-  /* MATLAB Function: '<S688>/AF for Foot' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* End of Switch: '<S4>/Switch5' */
+
+  /* Saturate: '<S494>/Saturation' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read14'
    */
-  AFforFoot(rtDW.FIU_BLOWERS_FR, &rtb_out_hi);
+  if (rtDW.FIU_SET_FR > 310) {
+    rtb_out_oc = 310U;
+  } else if (rtDW.FIU_SET_FR < 155) {
+    rtb_out_oc = 155U;
+  } else {
+    rtb_out_oc = rtDW.FIU_SET_FR;
+  }
 
-  /* MATLAB Function: '<S688>/AF for Foor + Def' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* BusCreator: '<S4>/Bus Creator' incorporates:
+   *  Bias: '<S494>/Bias'
+   *  DataStoreWrite: '<S4>/Data Store Write'
+   *  DataTypeConversion: '<S494>/Data Type Conversion'
+   *  Gain: '<S494>/Gain'
+   *  Gain: '<S494>/Gain1'
+   *  Saturate: '<S494>/Saturation'
    */
-  AFforFoorDef(rtDW.FIU_BLOWERS_FR, &rtb_out_cb);
+  rtDW.CCU_STAT1_MODEL.CCU_TargetTempFR_Stat_ro = (uint8_t)((0.10000038146972656
+    * (double)rtb_out_oc - 15.5) * 2.0);
 
-  /* MATLAB Function: '<S688>/AF for Def' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* Switch: '<S4>/Switch6' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read26'
    */
-  AFforDef(rtDW.FIU_BLOWERS_FR, &rtb_out_hz);
+  if (rtDW.FIU_BLOWERS_RL > 7) {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  Constant: '<S4>/manual1'
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRL_Stat = 0U;
+  } else {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRL_Stat = rtDW.FIU_BLOWERS_RL;
+  }
 
-  /* MATLAB Function: '<S688>/AF for Hi_Level' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* End of Switch: '<S4>/Switch6' */
+
+  /* Saturate: '<S484>/Saturation' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read15'
    */
-  AFforHi_Level(rtDW.FIU_BLOWERS_FR, &rtb_out_i4);
+  if (FIU_SET_RR > 310) {
+    rtb_out_oc = 310U;
+  } else {
+    rtb_out_oc = FIU_SET_RR;
+  }
 
-  /* MultiPortSwitch: '<S688>/Multiport Switch' incorporates:
-   *  Constant: '<S688>/Constant'
-   *  Constant: '<S688>/Constant1'
-   *  Constant: '<S688>/Constant2'
-   *  Constant: '<S688>/Constant3'
-   *  DataStoreRead: '<S6>/Data Store Read6'
-   *  DataStoreRead: '<S6>/Data Store Read8'
-   *  DataStoreRead: '<S6>/Data Store Read9'
-   *  Gain: '<S688>/Gain1'
-   *  Gain: '<S688>/Gain2'
-   *  RelationalOperator: '<S688>/Relational Operator'
-   *  RelationalOperator: '<S688>/Relational Operator1'
-   *  RelationalOperator: '<S688>/Relational Operator2'
-   *  Sum: '<S688>/Add'
+  /* BusCreator: '<S4>/Bus Creator' incorporates:
+   *  Bias: '<S484>/Bias'
+   *  DataStoreWrite: '<S4>/Data Store Write'
+   *  DataTypeConversion: '<S484>/Data Type Conversion'
+   *  Gain: '<S484>/Gain'
+   *  Gain: '<S484>/Gain1'
+   *  Saturate: '<S484>/Saturation'
    */
-  switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FL == 1) << 1) + (uint32_t)
-                     (rtDW.FIU_DEF_FL == 1)) + (uint32_t)((rtDW.FIU_FOOT_FL == 1)
-            << 2))) {
-   case 0:
-    rtb_out_ee = 0U;
-    break;
+  rtDW.CCU_STAT1_MODEL.CCU_TargetTempRR_Stat_ro = (uint8_t)((0.10000038146972656
+    * (double)rtb_out_oc - 15.5) * 2.0);
 
+  /* Switch: '<S4>/Switch7' incorporates:
+   *  DataStoreRead: '<S4>/Data Store Read25'
+   */
+  if (rtDW.FIU_BLOWERS_RR > 7) {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  Constant: '<S4>/manual1'
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRR_Stat = 0U;
+  } else {
+    /* BusCreator: '<S4>/Bus Creator' incorporates:
+     *  DataStoreWrite: '<S4>/Data Store Write'
+     */
+    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRR_Stat = rtDW.FIU_BLOWERS_RR;
+  }
+
+  /* End of Switch: '<S4>/Switch7' */
+
+  /* DataTypeConversion: '<S446>/Data Type  Conversion1' incorporates:
+   *  Bias: '<S479>/Bias'
+   *  DataStoreRead: '<S3>/Data Store Read2'
+   *  DataTypeConversion: '<S479>/Data Type  Conversion'
+   *  Gain: '<S479>/Gain'
+   *  Gain: '<S479>/Gain1'
+   */
+  rtb_out_oc = (uint16_t)((0.5 * (double)
+    rtDW.FIU_CCU2_MODEL.FIU_TargetTempRL_Val_ro + 15.5) * 10.0);
+
+  /* Saturate: '<S493>/Saturation' */
+  if (rtb_out_oc > 310) {
+    rtb_out_oc = 310U;
+  }
+
+  /* BusCreator: '<S4>/Bus Creator' incorporates:
+   *  Bias: '<S493>/Bias'
+   *  DataStoreWrite: '<S4>/Data Store Write'
+   *  DataTypeConversion: '<S493>/Data Type Conversion'
+   *  Gain: '<S493>/Gain'
+   *  Gain: '<S493>/Gain1'
+   *  Saturate: '<S493>/Saturation'
+   */
+  rtDW.CCU_STAT1_MODEL.CCU_TargetTempRL_Stat_ro = (uint8_t)((0.10000038146972656
+    * (double)rtb_out_oc - 15.5) * 2.0);
+  for (i = 0; i < 9; i++) {
+    /* Switch: '<S515>/Switch' incorporates:
+     *  Constant: '<S515>/Constant'
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreRead: '<S515>/Data Store Read'
+     *  Gain: '<S515>/Gain'
+     *  Product: '<S515>/Divide'
+     */
+    if (rtDW.MaxPositionCh0_private[i] != 0) {
+      y = 100 * (int16_t)div_nde_s32_floor
+        (Actuator_Ch0_Status_Model.in_CPOS_ALL[i], rtDW.MaxPositionCh0_private[i]);
+    } else {
+      y = 0;
+    }
+
+    /* End of Switch: '<S515>/Switch' */
+
+    /* Saturate: '<S515>/Saturation' */
+    if (y > 100) {
+      y = 100;
+    } else if (y < 0) {
+      y = 0;
+    }
+
+    /* End of Saturate: '<S515>/Saturation' */
+
+    /* DataTypeConversion: '<S515>/Data Type Conversion' incorporates:
+     *  DataTypeConversion: '<S652>/Data Type Conversion'
+     */
+    rtb_DataTypeConversion_ns[i] = (uint8_t)y;
+
+    /* DataStoreWrite: '<S501>/Data Store Write2' incorporates:
+     *  DataTypeConversion: '<S515>/Data Type Conversion'
+     */
+    Actuator_pos_percent_Ch0[i] = (uint8_t)y;
+  }
+
+  /* Switch: '<S501>/Switch' incorporates:
+   *  Constant: '<S501>/Constant1'
+   *  DataStoreRead: '<S501>/Data Store Read'
+   *  DataStoreRead: '<S501>/Data Store Read2'
+   */
+  if (rtDW.stepSig_private > 0) {
+    rtb_Switch_hx = rtDW.stepSig_private;
+  } else {
+    rtb_Switch_hx = 1;
+  }
+
+  /* End of Switch: '<S501>/Switch' */
+
+  /* SwitchCase: '<S501>/Switch Case' */
+  switch (rtb_Switch_hx) {
    case 1:
+    /* Outputs for IfAction SubSystem: '<S501>/Stop Mode' incorporates:
+     *  ActionPort: '<S514>/Action Port'
+     */
+    /* If: '<S514>/If1' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S514>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S571>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S571>/Data Store Write1' */
+        rtDW.COM_private[i] = 1U;
+
+        /* DataStoreWrite: '<S571>/Data Store Write' */
+        rtDW.MODE_private[i] = 2U;
+      }
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S571>/Constant'
+       *  Sum: '<S571>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S571>/Write' incorporates:
+       *  DataStoreRead: '<S571>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Stop Mode\n'); */
+        printf("[LIN 1] Stop Mode\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S571>/Write' */
+      /* End of Outputs for SubSystem: '<S514>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S514>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S572>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S572>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S514>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S514>/If1' */
+    /* End of Outputs for SubSystem: '<S501>/Stop Mode' */
     break;
 
    case 2:
-    rtb_out_ee = rtb_out_bc;
+    /* Outputs for IfAction SubSystem: '<S501>/Initial CPOS Min' incorporates:
+     *  ActionPort: '<S510>/Action Port'
+     */
+    /* If: '<S510>/If' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S510>/If Action Subsystem' incorporates:
+       *  ActionPort: '<S559>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S559>/Data Store Write' */
+        rtDW.POS_private[i] = 6000U;
+
+        /* DataStoreWrite: '<S559>/Data Store Write1' */
+        rtDW.COM_private[i] = 2U;
+      }
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S559>/Constant'
+       *  Merge: '<S510>/Merge'
+       *  Sum: '<S559>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S559>/Write' incorporates:
+       *  DataStoreRead: '<S559>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Initial CPOS Min\n'); */
+        printf("[LIN 1] Initial CPOS Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S559>/Write' */
+      /* End of Outputs for SubSystem: '<S510>/If Action Subsystem' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S510>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S560>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Merge: '<S510>/Merge'
+       *  SignalConversion generated from: '<S560>/stepIn1'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S510>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S510>/If' */
+    /* End of Outputs for SubSystem: '<S501>/Initial CPOS Min' */
     break;
 
    case 3:
-    rtb_out_ee = rtb_out_hi;
+    /* Outputs for IfAction SubSystem: '<S501>/Normal Mode' incorporates:
+     *  ActionPort: '<S513>/Action Port'
+     */
+    /* If: '<S513>/If1' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S513>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S568>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S568>/Data Store Write' */
+        rtDW.MODE_private[i] = 0U;
+
+        /* DataStoreWrite: '<S568>/Data Store Write1' */
+        rtDW.COM_private[i] = 1U;
+      }
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S568>/Constant'
+       *  Sum: '<S568>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S568>/Write' incorporates:
+       *  DataStoreRead: '<S568>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Normal Mode\n'); */
+        printf("[LIN 1] Normal Mode\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S568>/Write' */
+      /* End of Outputs for SubSystem: '<S513>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S513>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S569>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S569>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S513>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S513>/If1' */
+    /* End of Outputs for SubSystem: '<S501>/Normal Mode' */
     break;
 
    case 4:
-    rtb_out_ee = rtb_out_cb;
+    /* Outputs for IfAction SubSystem: '<S501>/Move to position Min' incorporates:
+     *  ActionPort: '<S512>/Action Port'
+     */
+    /* If: '<S512>/If1' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S512>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S565>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S565>/Data Store Write4' incorporates:
+         *  Constant: '<S565>/Constant1'
+         */
+        rtDW.Autos_private[i] = 1U;
+
+        /* DataStoreWrite: '<S565>/Data Store Write2' incorporates:
+         *  Constant: '<S565>/Constant10'
+         */
+        rtDW.Stall_private[i] = 1U;
+
+        /* DataStoreWrite: '<S565>/Data Store Write3' */
+        rtDW.Lnoise_private[i] = 0U;
+
+        /* DataStoreWrite: '<S565>/Data Store Write5' incorporates:
+         *  Constant: '<S565>/Constant2'
+         */
+        rtDW.Speed_private[i] = 3U;
+
+        /* DataStoreWrite: '<S565>/Data Store Write6' incorporates:
+         *  Constant: '<S565>/Constant3'
+         */
+        rtDW.Coils_private[i] = 3U;
+
+        /* DataStoreWrite: '<S565>/Data Store Write' */
+        rtDW.POS_private[i] = 0U;
+
+        /* DataStoreWrite: '<S565>/Data Store Write1' incorporates:
+         *  Constant: '<S565>/Constant9'
+         */
+        rtDW.COM_private[i] = 3U;
+      }
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S565>/Constant'
+       *  Sum: '<S565>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S565>/Write' incorporates:
+       *  DataStoreRead: '<S565>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Move to position Min\n'); */
+        printf("[LIN 1] Move to position Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S565>/Write' */
+      /* End of Outputs for SubSystem: '<S512>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S512>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S566>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S566>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S512>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S512>/If1' */
+    /* End of Outputs for SubSystem: '<S501>/Move to position Min' */
     break;
 
    case 5:
-    rtb_out_ee = rtb_out_hz;
+    /* Outputs for IfAction SubSystem: '<S501>/Check Stall Min' incorporates:
+     *  ActionPort: '<S507>/Action Port'
+     */
+    /* Logic: '<S507>/Logical Operator3' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreRead: '<S507>/Data Store Read'
+     *  Logic: '<S507>/Logical Operator1'
+     *  Logic: '<S507>/Logical Operator2'
+     *  RelationalOperator: '<S507>/Relational Operator'
+     *  RelationalOperator: '<S507>/Relational Operator1'
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_LogicalOperator3_a0[i] =
+        ((Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1) ||
+         (Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 0) ||
+         (rtDW.ErrorCalibration_private[i] == 0));
+    }
+
+    /* End of Logic: '<S507>/Logical Operator3' */
+
+    /* Logic: '<S507>/Logical Operator' incorporates:
+     *  Logic: '<S507>/Logical Operator3'
+     */
+    rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+    for (y = 0; y < 8; y++) {
+      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_a0[y
+        + 1]);
+    }
+
+    /* If: '<S507>/If2' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  DataTypeConversion: '<S507>/Data Type Conversion'
+     *  DataTypeConversion: '<S507>/Data Type Conversion1'
+     *  Logic: '<S507>/Logical Operator'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
+    {
+      /* Outputs for IfAction SubSystem: '<S507>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S520>/Action Port'
+       */
+      /* DataStoreWrite: '<S520>/Data Store Write1' */
+      for (y = 0; y < 9; y++) {
+        /* Switch: '<S520>/Switch' incorporates:
+         *  DataStoreRead: '<S520>/Data Store Read1'
+         */
+        if (rtDW.ErrorCalibration_private[y] != 0) {
+          rtDW.MinPositionCh0_private[y] =
+            Actuator_Ch0_Status_Model.in_CPOS_ALL[y];
+        }
+
+        /* End of Switch: '<S520>/Switch' */
+      }
+
+      /* End of DataStoreWrite: '<S520>/Data Store Write1' */
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S520>/Constant'
+       *  Sum: '<S520>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S520>/Write' incorporates:
+       *  DataStoreRead: '<S520>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Check Stall Min\n'); */
+        printf("[LIN 1] Check Stall Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S520>/Write' */
+      /* End of Outputs for SubSystem: '<S507>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S507>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S521>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S521>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S507>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S507>/If2' */
+    /* End of Outputs for SubSystem: '<S501>/Check Stall Min' */
     break;
 
    case 6:
-    rtb_out_ee = rtb_out_i4;
+    /* Outputs for IfAction SubSystem: '<S501>/Initial CPOS Max' incorporates:
+     *  ActionPort: '<S509>/Action Port'
+     */
+    /* If: '<S509>/If1' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S509>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S556>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S556>/Data Store Write1' */
+        rtDW.COM_private[i] = 2U;
+
+        /* DataStoreWrite: '<S556>/Data Store Write' */
+        rtDW.POS_private[i] = 0U;
+      }
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S556>/Constant'
+       *  Sum: '<S556>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S556>/Write' incorporates:
+       *  DataStoreRead: '<S556>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Initial CPOS Max\n'); */
+        printf("[LIN 1] Initial CPOS Max\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S556>/Write' */
+      /* End of Outputs for SubSystem: '<S509>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S509>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S557>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S557>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S509>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S509>/If1' */
+    /* End of Outputs for SubSystem: '<S501>/Initial CPOS Max' */
     break;
 
-   default:
-    rtb_out_ee = 0U;
+   case 7:
+    /* Outputs for IfAction SubSystem: '<S501>/Move to position Max' incorporates:
+     *  ActionPort: '<S511>/Action Port'
+     */
+    /* If: '<S511>/If1' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S511>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S562>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S562>/Data Store Write4' incorporates:
+         *  Constant: '<S562>/Constant1'
+         */
+        rtDW.Autos_private[i] = 1U;
+
+        /* DataStoreWrite: '<S562>/Data Store Write2' incorporates:
+         *  Constant: '<S562>/Constant10'
+         */
+        rtDW.Stall_private[i] = 1U;
+
+        /* DataStoreWrite: '<S562>/Data Store Write3' */
+        rtDW.Lnoise_private[i] = 0U;
+
+        /* DataStoreWrite: '<S562>/Data Store Write5' incorporates:
+         *  Constant: '<S562>/Constant2'
+         */
+        rtDW.Speed_private[i] = 3U;
+
+        /* DataStoreWrite: '<S562>/Data Store Write' */
+        rtDW.POS_private[i] = 6000U;
+
+        /* DataStoreWrite: '<S562>/Data Store Write1' incorporates:
+         *  Constant: '<S562>/Constant9'
+         */
+        rtDW.COM_private[i] = 3U;
+
+        /* DataStoreWrite: '<S562>/Data Store Write6' */
+        rtDW.Coils_private[i] = 0U;
+      }
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S562>/Constant'
+       *  Sum: '<S562>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S562>/Write' incorporates:
+       *  DataStoreRead: '<S562>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Move to position Max\n'); */
+        printf("[LIN 1] Move to position Max\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S562>/Write' */
+      /* End of Outputs for SubSystem: '<S511>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S511>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S563>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S563>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S511>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S511>/If1' */
+    /* End of Outputs for SubSystem: '<S501>/Move to position Max' */
+    break;
+
+   case 8:
+    /* Outputs for IfAction SubSystem: '<S501>/Check Stall Max' incorporates:
+     *  ActionPort: '<S506>/Action Port'
+     */
+    /* Logic: '<S506>/Logical Operator3' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreRead: '<S506>/Data Store Read'
+     *  Logic: '<S506>/Logical Operator'
+     *  Logic: '<S506>/Logical Operator2'
+     *  RelationalOperator: '<S506>/Relational Operator'
+     *  RelationalOperator: '<S506>/Relational Operator1'
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_LogicalOperator3_a0[i] =
+        ((Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1) ||
+         (Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 6000) ||
+         (rtDW.ErrorCalibration_private[i] == 0));
+    }
+
+    /* End of Logic: '<S506>/Logical Operator3' */
+
+    /* Logic: '<S506>/Logical Operator1' incorporates:
+     *  Logic: '<S506>/Logical Operator3'
+     */
+    rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+    for (y = 0; y < 8; y++) {
+      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_a0[y
+        + 1]);
+    }
+
+    /* If: '<S506>/If2' incorporates:
+     *  DataStoreRead: '<S501>/Data Store Read1'
+     *  DataStoreWrite: '<S501>/Data Store Write1'
+     *  DataTypeConversion: '<S506>/Data Type Conversion'
+     *  DataTypeConversion: '<S506>/Data Type Conversion1'
+     *  Logic: '<S506>/Logical Operator1'
+     *  SignalConversion generated from: '<S501>/Bus Selector'
+     */
+    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
+        (Actuator_Ch0_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
+    {
+      /* Outputs for IfAction SubSystem: '<S506>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S517>/Action Port'
+       */
+      /* DataStoreWrite: '<S517>/Data Store Write1' */
+      for (y = 0; y < 9; y++) {
+        /* Switch: '<S517>/Switch' incorporates:
+         *  DataStoreRead: '<S517>/Data Store Read1'
+         */
+        if (rtDW.ErrorCalibration_private[y] != 0) {
+          rtDW.MaxPositionCh0_private[y] =
+            Actuator_Ch0_Status_Model.in_CPOS_ALL[y];
+        }
+
+        /* End of Switch: '<S517>/Switch' */
+      }
+
+      /* End of DataStoreWrite: '<S517>/Data Store Write1' */
+
+      /* Merge: '<S501>/Merge' incorporates:
+       *  Constant: '<S517>/Constant'
+       *  Sum: '<S517>/step inc'
+       */
+      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S517>/Write' incorporates:
+       *  DataStoreRead: '<S517>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 1] Check Stall MAX\n'); */
+        printf("[LIN 1] Check Stall MAX\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S517>/Write' */
+      /* End of Outputs for SubSystem: '<S506>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S506>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S518>/Action Port'
+       */
+      /* Merge: '<S501>/Merge' incorporates:
+       *  SignalConversion generated from: '<S518>/stepIn'
+       */
+      rtB.Merge_l = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S506>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S506>/If2' */
+    /* End of Outputs for SubSystem: '<S501>/Check Stall Max' */
+    break;
+
+   case 9:
+    /* Outputs for IfAction SubSystem: '<S501>/Homing' incorporates:
+     *  ActionPort: '<S508>/Action Port'
+     */
+    /* Product: '<S523>/Divide1' incorporates:
+     *  Constant: '<S523>/ACT1'
+     *  DataStoreRead: '<S523>/MAX ACT1T '
+     */
+    for (i = 0; i < 9; i++) {
+      rtb_Divide1_gdi[i] = (double)rtDW.MaxPositionCh0_private[i] / (double)
+        rtConstP.ACT1_Value[i];
+    }
+
+    /* End of Product: '<S523>/Divide1' */
+
+    /* SwitchCase: '<S508>/Switch Case' incorporates:
+     *  DataStoreRead: '<S508>/Data Store Read4'
+     */
+    switch (rtDW.stepHoming_private) {
+     case 0:
+      /* Outputs for IfAction SubSystem: '<S508>/Switch Case Action Subsystem' incorporates:
+       *  ActionPort: '<S524>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* RelationalOperator: '<S529>/Compare' */
+        rtb_Divide1 = rtb_Divide1_gdi[i];
+
+        /* Logic: '<S524>/Logical Operator' incorporates:
+         *  Constant: '<S529>/Constant'
+         *  Constant: '<S530>/Constant'
+         *  RelationalOperator: '<S529>/Compare'
+         *  RelationalOperator: '<S530>/Compare'
+         */
+        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
+        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S532>/Data Type Conversion' incorporates:
+         *  DataStoreRead: '<S532>/Data Store Read'
+         *  DataStoreWrite: '<S532>/Data Store Write'
+         *  Logic: '<S532>/Logical Operator'
+         *  Logic: '<S532>/Logical Operator1'
+         */
+        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
+          (rtDW.ErrorCalibration_private[i] != 0));
+      }
+
+      /* MATLAB Function: '<S524>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S524>/Data Store Read5'
+       *  DataStoreRead: '<S524>/MIN ACT1T 1'
+       *  Logic: '<S524>/Logical Operator2'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 1] Homing 0\n"); */
+        printf("[LIN 1] Homing 0\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 9; i++) {
+          /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+          printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                 (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
+                 rtb_Divide1_gdi[i], (int16_t)!rtb_LogicalOperator3_a0[i]);
+          fflush(stdout);
+        }
+      }
+
+      /* End of MATLAB Function: '<S524>/MAX POSITION' */
+
+      /* Logic: '<S524>/Logical Operator1' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* Switch: '<S524>/Switch' incorporates:
+       *  Logic: '<S524>/Logical Operator1'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S508>/Merge' incorporates:
+         *  Constant: '<S524>/Constant1'
+         */
+        rtB.Merge_h1 = 4;
+      } else {
+        /* Merge: '<S508>/Merge' incorporates:
+         *  Constant: '<S524>/Constant'
+         */
+        rtB.Merge_h1 = 1;
+      }
+
+      /* End of Switch: '<S524>/Switch' */
+      /* End of Outputs for SubSystem: '<S508>/Switch Case Action Subsystem' */
+      break;
+
+     case 1:
+      /* Outputs for IfAction SubSystem: '<S508>/Switch Case Action Subsystem1' incorporates:
+       *  ActionPort: '<S525>/Action Port'
+       */
+      /* RelationalOperator: '<S534>/Compare' incorporates:
+       *  Constant: '<S534>/Constant'
+       */
+      for (i = 0; i < 9; i++) {
+        rtb_LogicalOperator3_a0[i] = (rtb_Divide1_gdi[i] > 1.5);
+      }
+
+      /* End of RelationalOperator: '<S534>/Compare' */
+
+      /* Logic: '<S533>/Logical Operator' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* DataTypeConversion: '<S533>/Data Type Conversion' incorporates:
+       *  DataStoreWrite: '<S533>/Data Store Write1'
+       *  Logic: '<S533>/Logical Operator'
+       */
+      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
+      for (i = 0; i < 9; i++) {
+        /* DataTypeConversion: '<S533>/Data Type Conversion1' incorporates:
+         *  DataStoreWrite: '<S533>/Data Store Write2'
+         */
+        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
+        rtDW.COM_private[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S533>/Data Type Conversion2' incorporates:
+         *  DataStoreRead: '<S533>/Data Store Read'
+         *  DataStoreWrite: '<S533>/Data Store Write3'
+         *  Logic: '<S533>/Logical Operator1'
+         */
+        rtDW.ErrorActuator[i] = (uint8_t)(rtb_LogicalOperator1 ||
+          (rtDW.ErrorActuator[i] != 0));
+
+        /* DataStoreWrite: '<S533>/Data Store Write' */
+        rtDW.MODE_private[i] = 2U;
+      }
+
+      /* MATLAB Function: '<S533>/Write ERROR' incorporates:
+       *  DataStoreRead: '<S533>/Data Store Read6'
+       */
+      /* :  if(LOGGER>=0) */
+      if (rtDW.LOGGER_LIN >= 0.0) {
+        /* :  for i = 1:numel(ErrCallibration) */
+        for (i = 0; i < 9; i++) {
+          /* :  if ErrCallibration(i) == 1 */
+          if (rtb_LogicalOperator3_a0[i]) {
+            /* :  fprintf('[LIN 1] Failure with actuator #%d\n', int16(i)); */
+            printf("[LIN 1] Failure with actuator #%d\n", (int16_t)(i + 1));
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S533>/Write ERROR' */
+      for (i = 0; i < 9; i++) {
+        /* Logic: '<S525>/Logical Operator1' */
+        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
+
+        /* DataTypeConversion: '<S525>/Data Type Conversion' incorporates:
+         *  DataStoreRead: '<S525>/Data Store Read'
+         *  DataStoreWrite: '<S525>/Data Store Write'
+         *  Logic: '<S525>/Logical Operator'
+         *  Logic: '<S525>/Logical Operator1'
+         */
+        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
+          (rtDW.ErrorCalibration_private[i] != 0));
+
+        /* DataStoreWrite: '<S537>/Data Store Write' incorporates:
+         *  DataTypeConversion: '<S537>/Data Type Conversion'
+         */
+        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
+      }
+
+      /* DataStoreWrite: '<S536>/Data Store Write' incorporates:
+       *  Constant: '<S536>/Constant'
+       */
+      rtDW.stepSig_private = 1;
+
+      /* MATLAB Function: '<S525>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S525>/Data Store Read5'
+       *  DataStoreRead: '<S525>/MIN ACT1T 1'
+       *  DataStoreWrite: '<S525>/Data Store Write'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 1] Homing 1. Start Callibration \n"); */
+        printf("[LIN 1] Homing 1. Start Callibration \n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 9; i++) {
+          /* :  if(ERRORS(i)==1) */
+          if (rtDW.ErrorCalibration_private[i] == 1) {
+            /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+            printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                   (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
+                   rtb_Divide1_gdi[i], (int16_t)rtDW.ErrorCalibration_private[i]);
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S525>/MAX POSITION' */
+
+      /* Logic: '<S525>/Logical Operator2' incorporates:
+       *  DataStoreWrite: '<S525>/Data Store Write'
+       */
+      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private[0] != 0);
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          (rtDW.ErrorCalibration_private[y + 1] != 0));
+      }
+
+      /* Switch: '<S525>/Switch' incorporates:
+       *  Logic: '<S525>/Logical Operator2'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S508>/Merge' incorporates:
+         *  Constant: '<S536>/Constant1'
+         */
+        rtB.Merge_h1 = 2;
+      } else {
+        /* Merge: '<S508>/Merge' incorporates:
+         *  Constant: '<S525>/Constant1'
+         */
+        rtB.Merge_h1 = 4;
+      }
+
+      /* End of Switch: '<S525>/Switch' */
+      /* End of Outputs for SubSystem: '<S508>/Switch Case Action Subsystem1' */
+      break;
+
+     case 2:
+      /* Outputs for IfAction SubSystem: '<S508>/Switch Case Action Subsystem2' incorporates:
+       *  ActionPort: '<S526>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* RelationalOperator: '<S539>/Compare' */
+        rtb_Divide1 = rtb_Divide1_gdi[i];
+
+        /* Logic: '<S526>/Logical Operator3' incorporates:
+         *  Constant: '<S539>/Constant'
+         *  Constant: '<S540>/Constant'
+         *  DataStoreRead: '<S526>/Data Store Read'
+         *  Logic: '<S526>/Logical Operator1'
+         *  Logic: '<S526>/Logical Operator4'
+         *  RelationalOperator: '<S539>/Compare'
+         *  RelationalOperator: '<S540>/Compare'
+         */
+        rtb_LogicalOperator1 = (((rtb_Divide1 < 0.97) || (rtb_Divide1 > 1.03)) &&
+          (rtDW.ErrorCalibration_private[i] != 0));
+        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S526>/Data Type Conversion' incorporates:
+         *  DataStoreWrite: '<S526>/Data Store Write1'
+         */
+        rtDW.ErrorCalibration_private[i] = rtb_LogicalOperator1;
+      }
+
+      /* MATLAB Function: '<S526>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S526>/Data Store Read5'
+       *  DataStoreRead: '<S526>/MIN ACT1T 1'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 1] Homing 3. Callibration \n"); */
+        printf("[LIN 1] Homing 3. Callibration \n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 9; i++) {
+          /* :  if(ERRORS(i)==1) */
+          if (rtb_LogicalOperator3_a0[i]) {
+            /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+            printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                   (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
+                   rtb_Divide1_gdi[i], 1);
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S526>/MAX POSITION' */
+
+      /* Logic: '<S526>/Logical Operator2' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* Switch: '<S526>/Switch' incorporates:
+       *  Logic: '<S526>/Logical Operator2'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S508>/Merge' incorporates:
+         *  Constant: '<S526>/Constant3'
+         */
+        rtB.Merge_h1 = 3;
+      } else {
+        /* Merge: '<S508>/Merge' incorporates:
+         *  Constant: '<S526>/Constant1'
+         */
+        rtB.Merge_h1 = 4;
+      }
+
+      /* End of Switch: '<S526>/Switch' */
+      /* End of Outputs for SubSystem: '<S508>/Switch Case Action Subsystem2' */
+      break;
+
+     case 3:
+      /* Outputs for IfAction SubSystem: '<S508>/Switch Case Action Subsystem3' incorporates:
+       *  ActionPort: '<S527>/Action Port'
+       */
+      /* MATLAB Function: '<S527>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S527>/Data Store Read1'
+       *  DataStoreRead: '<S527>/Data Store Read5'
+       */
+      /* :  if(LOGGER>1) */
+      if (rtDW.LOGGER_LIN > 1.0) {
+        /* :  fprintf("[LIN 1] Homing 3. Start Time on step %d\n",int16(step)); */
+        rtb_Divide1 = rt_roundd(rtDW.ErrorHomming_private);
+        if (rtb_Divide1 < 32768.0) {
+          if (rtb_Divide1 >= -32768.0) {
+            AMB = (int16_t)rtb_Divide1;
+          } else {
+            AMB = INT16_MIN;
+          }
+        } else {
+          AMB = INT16_MAX;
+        }
+
+        printf("[LIN 1] Homing 3. Start Time on step %d\n", AMB);
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S527>/MAX POSITION' */
+
+      /* If: '<S527>/If' incorporates:
+       *  DataStoreRead: '<S527>/Data Store Read1'
+       */
+      if (rtDW.ErrorHomming_private < 10.0) {
+        /* Outputs for IfAction SubSystem: '<S527>/If Action Subsystem' incorporates:
+         *  ActionPort: '<S542>/Action Port'
+         */
+        /* MATLAB Function: '<S542>/MATLAB Function' incorporates:
+         *  DataStoreRead: '<S542>/Data Store Read'
+         *  DataStoreRead: '<S542>/Data Store Read1'
+         */
+        MATLABFunction(rtDW.Start_timer_i, rtDW.t_now, &rtb_dt_ih,
+                       &rtDW.sf_MATLABFunction);
+
+        /* MATLAB Function: '<S542>/MAX POSITION' incorporates:
+         *  DataStoreRead: '<S542>/Data Store Read5'
+         */
+        /* :  if(LOGGER>1) */
+        if (rtDW.LOGGER_LIN > 1.0) {
+          /* :  fprintf("[LIN 1] Homing 3. Start TIme dt = %d \n",int32(data)); */
+          rtb_dt_fa = rtb_dt_ih;
+          if (rtb_dt_ih > 2147483647U) {
+            rtb_dt_fa = 2147483647U;
+          }
+
+          printf("[LIN 1] Homing 3. Start TIme dt = %d \n", (int32_t)rtb_dt_fa);
+          fflush(stdout);
+        }
+
+        /* End of MATLAB Function: '<S542>/MAX POSITION' */
+
+        /* If: '<S542>/If' */
+        if (rtb_dt_ih > 30000U) {
+          /* Outputs for IfAction SubSystem: '<S542>/If Action Subsystem' incorporates:
+           *  ActionPort: '<S545>/Action Port'
+           */
+          /* Merge: '<S508>/Merge' */
+          IfActionSubsystem(&rtB.Merge_h1, &rtDW.ErrorHomming_private,
+                            &rtDW.Start_timer_i, &rtDW.stepSig_private);
+
+          /* End of Outputs for SubSystem: '<S542>/If Action Subsystem' */
+        } else {
+          /* Outputs for IfAction SubSystem: '<S542>/If Action Subsystem1' incorporates:
+           *  ActionPort: '<S546>/Action Port'
+           */
+          /* DataStoreWrite: '<S546>/Data Store Write2' incorporates:
+           *  Constant: '<S546>/Constant3'
+           */
+          rtDW.Start_timer_i = 1.0;
+
+          /* DataTypeConversion: '<S549>/Data Type Conversion2' incorporates:
+           *  DataStoreRead: '<S549>/valves target in percent'
+           */
+          for (i = 0; i < 9; i++) {
+            rtb_DataTypeConversion_md[i] = (uint8_t)
+              rtDW.valves_front_manual_target[i];
+          }
+
+          /* End of DataTypeConversion: '<S549>/Data Type Conversion2' */
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           */
+          rtDW.BUS_ADR_private[0] = rtb_DataTypeConversion_md[8];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           *  DataStoreWrite: '<S501>/Data Store Write2'
+           */
+          rtDW.BUS_ADR_private[1] = rtb_DataTypeConversion_ns[1];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           *  DataStoreWrite: '<S501>/Data Store Write2'
+           */
+          rtDW.BUS_ADR_private[2] = rtb_DataTypeConversion_ns[2];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           *  DataStoreWrite: '<S501>/Data Store Write2'
+           */
+          rtDW.BUS_ADR_private[3] = rtb_DataTypeConversion_ns[3];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           */
+          rtDW.BUS_ADR_private[4] = rtb_DataTypeConversion_md[1];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           */
+          rtDW.BUS_ADR_private[5] = rtb_DataTypeConversion_md[0];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           *  DataStoreWrite: '<S501>/Data Store Write2'
+           */
+          rtDW.BUS_ADR_private[6] = rtb_DataTypeConversion_ns[6];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           */
+          rtDW.BUS_ADR_private[7] = rtb_DataTypeConversion_md[6];
+
+          /* SignalConversion generated from: '<S549>/Vector Concatenate' incorporates:
+           *  Concatenate: '<S549>/Vector Concatenate'
+           */
+          rtDW.BUS_ADR_private[8] = rtb_DataTypeConversion_md[7];
+          for (i = 0; i < 9; i++) {
+            /* Product: '<S550>/Product' */
+            rtb_Gain_ge = rtDW.BUS_ADR_private[i];
+
+            /* DataTypeConversion: '<S550>/Data Type Conversion1' incorporates:
+             *  Constant: '<S550>/Constant1'
+             *  DataStoreRead: '<S550>/Data Store Read'
+             *  DataStoreWrite: '<S549>/Data Store Write'
+             *  Product: '<S550>/Divide1'
+             *  Product: '<S550>/Product'
+             */
+            rtDW.POS_private[i] = (uint16_t)((double)(rtb_Gain_ge *
+              rtDW.MaxPositionCh0_private[i]) / 100.0);
+
+            /* RelationalOperator: '<S549>/Relational Operator1' incorporates:
+             *  DataStoreWrite: '<S501>/Data Store Write2'
+             */
+            rtb_LogicalOperator3_a0[i] = (rtb_DataTypeConversion_ns[i] ==
+              rtb_Gain_ge);
+          }
+
+          /* Logic: '<S549>/Logical Operator' */
+          rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+          for (y = 0; y < 8; y++) {
+            rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
+              rtb_LogicalOperator3_a0[y + 1]);
+          }
+
+          for (i = 0; i < 9; i++) {
+            /* Switch: '<S549>/Switch' incorporates:
+             *  Constant: '<S549>/Constant4'
+             *  Constant: '<S549>/Constant9'
+             *  DataStoreWrite: '<S549>/Data Store Write1'
+             *  Logic: '<S549>/Logical Operator'
+             */
+            if (rtb_LogicalOperator1) {
+              rtDW.COM_private[i] = 0U;
+            } else {
+              rtDW.COM_private[i] = 3U;
+            }
+
+            /* End of Switch: '<S549>/Switch' */
+
+            /* DataTypeConversion: '<S549>/Data Type Conversion1' incorporates:
+             *  Concatenate: '<S549>/Vector Concatenate'
+             *  Constant: '<S549>/Constant5'
+             *  DataStoreWrite: '<S501>/Data Store Write2'
+             *  DataStoreWrite: '<S549>/Data Store Write7'
+             *  Product: '<S549>/Product'
+             *  RelationalOperator: '<S549>/Relational Operator'
+             */
+            rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
+              (rtb_DataTypeConversion_ns[i] != rtDW.BUS_ADR_private[i]) *
+              rtConstP.pooled76[i]);
+
+            /* DataStoreWrite: '<S549>/Data Store Write4' incorporates:
+             *  Constant: '<S549>/Constant1'
+             */
+            rtDW.Autos_private[i] = 1U;
+
+            /* DataStoreWrite: '<S549>/Data Store Write2' incorporates:
+             *  Constant: '<S549>/Constant10'
+             */
+            rtDW.Stall_private[i] = 1U;
+
+            /* DataStoreWrite: '<S549>/Data Store Write3' incorporates:
+             *  Constant: '<S549>/Constant11'
+             */
+            rtDW.Lnoise_private[i] = 0U;
+
+            /* DataStoreWrite: '<S549>/Data Store Write5' incorporates:
+             *  Constant: '<S549>/Constant2'
+             */
+            rtDW.Speed_private[i] = 3U;
+
+            /* DataStoreWrite: '<S549>/Data Store Write6' incorporates:
+             *  Constant: '<S549>/Constant3'
+             */
+            rtDW.Coils_private[i] = 3U;
+          }
+
+          /* Merge: '<S508>/Merge' incorporates:
+           *  Constant: '<S546>/Constant1'
+           *  Merge: '<S542>/Merge'
+           *  SignalConversion generated from: '<S546>/Out1'
+           */
+          rtB.Merge_h1 = 3;
+
+          /* End of Outputs for SubSystem: '<S542>/If Action Subsystem1' */
+        }
+
+        /* End of If: '<S542>/If' */
+        /* End of Outputs for SubSystem: '<S527>/If Action Subsystem' */
+      } else {
+        /* Outputs for IfAction SubSystem: '<S527>/If Action Subsystem1' incorporates:
+         *  ActionPort: '<S543>/Action Port'
+         */
+        IfActionSubsystem1(&rtB.Merge_h1, &rtDW.CCU_ActuatorErrF_Stat_private,
+                           rtDW.COM_private, rtDW.ErrorActuator,
+                           rtDW.ErrorCalibration_private, &rtDW.LOGGER_LIN,
+                           rtDW.MODE_private, rtDW.dtc_state_error_model);
+
+        /* End of Outputs for SubSystem: '<S527>/If Action Subsystem1' */
+      }
+
+      /* End of If: '<S527>/If' */
+      /* End of Outputs for SubSystem: '<S508>/Switch Case Action Subsystem3' */
+      break;
+
+     case 4:
+      /* Outputs for IfAction SubSystem: '<S508>/Switch Case Action Subsystem4' incorporates:
+       *  ActionPort: '<S528>/Action Port'
+       */
+      /* DataTypeConversion: '<S554>/Data Type Conversion2' incorporates:
+       *  DataStoreRead: '<S554>/valves target in percent'
+       */
+      for (i = 0; i < 9; i++) {
+        rtb_DataTypeConversion_md[i] = (uint8_t)
+          rtDW.valves_front_manual_target[i];
+      }
+
+      /* End of DataTypeConversion: '<S554>/Data Type Conversion2' */
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       */
+      rtDW.BUS_ADR_private[0] = rtb_DataTypeConversion_md[8];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       *  DataStoreWrite: '<S501>/Data Store Write2'
+       */
+      rtDW.BUS_ADR_private[1] = rtb_DataTypeConversion_ns[1];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       *  DataStoreWrite: '<S501>/Data Store Write2'
+       */
+      rtDW.BUS_ADR_private[2] = rtb_DataTypeConversion_ns[2];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       *  DataStoreWrite: '<S501>/Data Store Write2'
+       */
+      rtDW.BUS_ADR_private[3] = rtb_DataTypeConversion_ns[3];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       */
+      rtDW.BUS_ADR_private[4] = rtb_DataTypeConversion_md[1];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       */
+      rtDW.BUS_ADR_private[5] = rtb_DataTypeConversion_md[0];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       *  DataStoreWrite: '<S501>/Data Store Write2'
+       */
+      rtDW.BUS_ADR_private[6] = rtb_DataTypeConversion_ns[6];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       */
+      rtDW.BUS_ADR_private[7] = rtb_DataTypeConversion_md[6];
+
+      /* SignalConversion generated from: '<S554>/Vector Concatenate' incorporates:
+       *  Concatenate: '<S549>/Vector Concatenate'
+       */
+      rtDW.BUS_ADR_private[8] = rtb_DataTypeConversion_md[7];
+      for (i = 0; i < 9; i++) {
+        /* Product: '<S555>/Product' */
+        rtb_Gain_ge = rtDW.BUS_ADR_private[i];
+
+        /* DataTypeConversion: '<S555>/Data Type Conversion1' incorporates:
+         *  Constant: '<S555>/Constant1'
+         *  DataStoreRead: '<S555>/Data Store Read'
+         *  DataStoreWrite: '<S554>/Data Store Write'
+         *  Product: '<S555>/Divide1'
+         *  Product: '<S555>/Product'
+         */
+        rtDW.POS_private[i] = (uint16_t)((double)(rtb_Gain_ge *
+          rtDW.MaxPositionCh0_private[i]) / 100.0);
+
+        /* RelationalOperator: '<S554>/Relational Operator1' incorporates:
+         *  DataStoreWrite: '<S501>/Data Store Write2'
+         */
+        rtb_LogicalOperator3_a0[i] = (rtb_DataTypeConversion_ns[i] ==
+          rtb_Gain_ge);
+      }
+
+      /* Logic: '<S554>/Logical Operator' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      for (i = 0; i < 9; i++) {
+        /* Switch: '<S554>/Switch' incorporates:
+         *  Constant: '<S554>/Constant4'
+         *  Constant: '<S554>/Constant9'
+         *  DataStoreWrite: '<S554>/Data Store Write1'
+         *  Logic: '<S554>/Logical Operator'
+         */
+        if (rtb_LogicalOperator1) {
+          rtDW.COM_private[i] = 0U;
+        } else {
+          rtDW.COM_private[i] = 3U;
+        }
+
+        /* End of Switch: '<S554>/Switch' */
+
+        /* DataTypeConversion: '<S554>/Data Type Conversion1' incorporates:
+         *  Concatenate: '<S549>/Vector Concatenate'
+         *  Constant: '<S554>/Constant5'
+         *  DataStoreWrite: '<S501>/Data Store Write2'
+         *  DataStoreWrite: '<S554>/Data Store Write7'
+         *  Product: '<S554>/Product'
+         *  RelationalOperator: '<S554>/Relational Operator'
+         */
+        rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
+          (rtb_DataTypeConversion_ns[i] != rtDW.BUS_ADR_private[i]) *
+          rtConstP.pooled76[i]);
+
+        /* DataStoreWrite: '<S554>/Data Store Write4' incorporates:
+         *  Constant: '<S554>/Constant1'
+         */
+        rtDW.Autos_private[i] = 1U;
+
+        /* DataStoreWrite: '<S554>/Data Store Write2' incorporates:
+         *  Constant: '<S554>/Constant10'
+         */
+        rtDW.Stall_private[i] = 1U;
+
+        /* DataStoreWrite: '<S554>/Data Store Write3' incorporates:
+         *  Constant: '<S554>/Constant11'
+         */
+        rtDW.Lnoise_private[i] = 0U;
+
+        /* DataStoreWrite: '<S554>/Data Store Write5' incorporates:
+         *  Constant: '<S554>/Constant2'
+         */
+        rtDW.Speed_private[i] = 3U;
+
+        /* DataStoreWrite: '<S554>/Data Store Write6' incorporates:
+         *  Constant: '<S554>/Constant3'
+         */
+        rtDW.Coils_private[i] = 3U;
+      }
+
+      /* Merge: '<S508>/Merge' incorporates:
+       *  Constant: '<S528>/Constant1'
+       *  SignalConversion generated from: '<S528>/step'
+       */
+      rtB.Merge_h1 = 4;
+
+      /* End of Outputs for SubSystem: '<S508>/Switch Case Action Subsystem4' */
+      break;
+    }
+
+    /* End of SwitchCase: '<S508>/Switch Case' */
+
+    /* DataStoreWrite: '<S508>/Data Store Write2' */
+    rtDW.stepHoming_private = rtB.Merge_h1;
+
+    /* Merge: '<S501>/Merge' incorporates:
+     *  DataStoreRead: '<S508>/Data Store Read7'
+     */
+    rtB.Merge_l = rtDW.stepSig_private;
+
+    /* End of Outputs for SubSystem: '<S501>/Homing' */
     break;
   }
 
-  /* End of MultiPortSwitch: '<S688>/Multiport Switch' */
+  /* End of SwitchCase: '<S501>/Switch Case' */
 
-  /* MATLAB Function: '<S689>/AF for Vent mode' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
+  /* DataStoreWrite: '<S501>/Finish write stepSig' */
+  rtDW.stepSig_private = rtB.Merge_l;
+  for (i = 0; i < 9; i++) {
+    /* BusCreator: '<S504>/Bus Creator' incorporates:
+     *  DataStoreRead: '<S504>/Data Store Read'
+     *  DataStoreRead: '<S504>/Data Store Read1'
+     *  DataStoreRead: '<S504>/Data Store Read2'
+     *  DataStoreRead: '<S504>/Data Store Read3'
+     *  DataStoreRead: '<S504>/Data Store Read4'
+     *  DataStoreRead: '<S504>/Data Store Read5'
+     *  DataStoreRead: '<S504>/Data Store Read6'
+     *  DataStoreRead: '<S504>/Data Store Read7'
+     *  DataStoreRead: '<S504>/Data Store Read8'
+     *  DataStoreWrite: '<S504>/Data Store Write'
+     */
+    Actuator_Ch0_Command_Model.POS[i] = rtDW.POS_private[i];
+    Actuator_Ch0_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private[i];
+    Actuator_Ch0_Command_Model.MODE[i] = rtDW.MODE_private[i];
+    Actuator_Ch0_Command_Model.COM[i] = rtDW.COM_private[i];
+    Actuator_Ch0_Command_Model.Stall_SET[i] = rtDW.Stall_private[i];
+    Actuator_Ch0_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private[i];
+    Actuator_Ch0_Command_Model.Autos_SET[i] = rtDW.Autos_private[i];
+    Actuator_Ch0_Command_Model.Speed_SET[i] = rtDW.Speed_private[i];
+    Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private[i];
+
+    /* RelationalOperator: '<S516>/Compare' incorporates:
+     *  Constant: '<S516>/Constant'
+     *  DataStoreRead: '<S505>/Data Store Read2'
+     */
+    rtb_LogicalOperator3_a0[i] = (rtDW.ErrorCalibration_private[i] == 0);
+  }
+
+  /* Logic: '<S505>/Logical Operator' */
+  rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+  for (y = 0; y < 8; y++) {
+    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_LogicalOperator3_a0[y +
+      1]);
+  }
+
+  for (i = 0; i < 9; i++) {
+    /* Switch: '<S505>/Switch1' incorporates:
+     *  Concatenate: '<S549>/Vector Concatenate'
+     *  Constant: '<S505>/Constant'
+     *  Constant: '<S505>/Constant3'
+     *  DataStoreRead: '<S505>/Data Store Read2'
+     *  DataStoreWrite: '<S505>/Data Store Write7'
+     *  Logic: '<S505>/Logical Operator'
+     *  Product: '<S505>/Product'
+     */
+    if (rtb_LogicalOperator1) {
+      rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
+        rtDW.ErrorCalibration_private[i] * rtConstP.pooled76[i]);
+    } else {
+      rtDW.BUS_ADR_private[i] = 0U;
+    }
+
+    /* End of Switch: '<S505>/Switch1' */
+
+    /* DataStoreWrite: '<S505>/Data Store Write' */
+    rtDW.COM_private[i] = 0U;
+
+    /* Switch: '<S585>/Switch' incorporates:
+     *  Constant: '<S585>/Constant'
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreRead: '<S585>/Data Store Read'
+     *  Gain: '<S585>/Gain'
+     *  Product: '<S585>/Divide'
+     */
+    if (rtDW.MaxPositionCh1_private[i] != 0) {
+      y = 100 * (int16_t)div_nde_s32_floor
+        (Actuator_Ch1_Status_Model.in_CPOS_ALL[i], rtDW.MaxPositionCh1_private[i]);
+    } else {
+      y = 0;
+    }
+
+    /* End of Switch: '<S585>/Switch' */
+
+    /* Saturate: '<S585>/Saturation' */
+    if (y > 100) {
+      /* DataStoreWrite: '<S502>/Data Store Write2' */
+      rtb_DataTypeConversion_md[i] = 100U;
+    } else if (y < 0) {
+      /* DataStoreWrite: '<S502>/Data Store Write2' */
+      rtb_DataTypeConversion_md[i] = 0U;
+    } else {
+      /* DataStoreWrite: '<S502>/Data Store Write2' */
+      rtb_DataTypeConversion_md[i] = (uint8_t)y;
+    }
+
+    /* End of Saturate: '<S585>/Saturation' */
+  }
+
+  /* Switch: '<S502>/Switch' incorporates:
+   *  Constant: '<S502>/Constant1'
+   *  DataStoreRead: '<S502>/Data Store Read'
+   *  DataStoreRead: '<S502>/Data Store Read2'
    */
-  AFforVentmode(rtDW.FIU_BLOWERS_FL, &rtb_out_hi);
+  if (rtDW.stepSig_private_j > 0) {
+    rtb_Switch_hx = rtDW.stepSig_private_j;
+  } else {
+    rtb_Switch_hx = 1;
+  }
 
-  /* MATLAB Function: '<S689>/AF for Bi Level' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
-   */
-  AFforBiLevel(rtDW.FIU_BLOWERS_FL, &rtb_out_cb);
-
-  /* MATLAB Function: '<S689>/AF for Foot' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
-   */
-  AFforFoot(rtDW.FIU_BLOWERS_FL, &rtb_out_hz);
-
-  /* MATLAB Function: '<S689>/AF for Foor + Def' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
-   */
-  AFforFoorDef(rtDW.FIU_BLOWERS_FL, &rtb_out_i4);
-
-  /* MATLAB Function: '<S689>/AF for Def' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
-   */
-  AFforDef(rtDW.FIU_BLOWERS_FL, &rtb_out_fm);
-
-  /* MATLAB Function: '<S689>/AF for Hi_Level' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
-   */
-  AFforHi_Level(rtDW.FIU_BLOWERS_FL, &rtb_out_d);
-
-  /* MATLAB Function: '<S689>/AF for Tri-Level' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read7'
-   */
-  AFforTriLevel(rtDW.FIU_BLOWERS_FL, &rtb_out_bc);
-
-  /* MultiPortSwitch: '<S689>/Multiport Switch' incorporates:
-   *  Constant: '<S689>/Constant'
-   *  Constant: '<S689>/Constant1'
-   *  Constant: '<S689>/Constant2'
-   *  Constant: '<S689>/Constant3'
-   *  DataStoreRead: '<S6>/Data Store Read12'
-   *  DataStoreRead: '<S6>/Data Store Read13'
-   *  DataStoreRead: '<S6>/Data Store Read14'
-   *  Gain: '<S689>/Gain1'
-   *  Gain: '<S689>/Gain2'
-   *  RelationalOperator: '<S689>/Relational Operator'
-   *  RelationalOperator: '<S689>/Relational Operator1'
-   *  RelationalOperator: '<S689>/Relational Operator2'
-   *  Sum: '<S689>/Add'
-   */
-  switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FR == 1) << 1) + (uint32_t)
-                     (rtDW.FIU_DEF_FR == 1)) + (uint32_t)((rtDW.FIU_FOOT_FR == 1)
-            << 2))) {
-   case 0:
-    rtb_out_bc = 0U;
-    break;
+  /* End of Switch: '<S502>/Switch' */
 
+  /* SwitchCase: '<S502>/Switch Case' */
+  switch (rtb_Switch_hx) {
    case 1:
-    rtb_out_bc = rtb_out_hi;
+    /* Outputs for IfAction SubSystem: '<S502>/Stop Mode' incorporates:
+     *  ActionPort: '<S584>/Action Port'
+     */
+    /* If: '<S584>/If1' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S584>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S638>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S638>/Data Store Write1' */
+        rtDW.COM_private_n[i] = 1U;
+
+        /* DataStoreWrite: '<S638>/Data Store Write' */
+        rtDW.MODE_private_a[i] = 2U;
+      }
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S638>/Constant'
+       *  Sum: '<S638>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S638>/Write' incorporates:
+       *  DataStoreRead: '<S638>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Stop Mode\n'); */
+        printf("[LIN 2] Stop Mode\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S638>/Write' */
+      /* End of Outputs for SubSystem: '<S584>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S584>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S639>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S639>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S584>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S584>/If1' */
+    /* End of Outputs for SubSystem: '<S502>/Stop Mode' */
     break;
 
    case 2:
-    rtb_out_bc = rtb_out_cb;
+    /* Outputs for IfAction SubSystem: '<S502>/Initial CPOS Min' incorporates:
+     *  ActionPort: '<S580>/Action Port'
+     */
+    /* If: '<S580>/If' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S580>/If Action Subsystem' incorporates:
+       *  ActionPort: '<S626>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S626>/Data Store Write' */
+        rtDW.POS_private_o[i] = 6000U;
+
+        /* DataStoreWrite: '<S626>/Data Store Write1' */
+        rtDW.COM_private_n[i] = 2U;
+      }
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S626>/Constant'
+       *  Merge: '<S580>/Merge'
+       *  Sum: '<S626>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S626>/Write' incorporates:
+       *  DataStoreRead: '<S626>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Initial CPOS Min\n'); */
+        printf("[LIN 2] Initial CPOS Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S626>/Write' */
+      /* End of Outputs for SubSystem: '<S580>/If Action Subsystem' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S580>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S627>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Merge: '<S580>/Merge'
+       *  SignalConversion generated from: '<S627>/stepIn1'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S580>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S580>/If' */
+    /* End of Outputs for SubSystem: '<S502>/Initial CPOS Min' */
     break;
 
    case 3:
-    rtb_out_bc = rtb_out_hz;
+    /* Outputs for IfAction SubSystem: '<S502>/Normal Mode' incorporates:
+     *  ActionPort: '<S583>/Action Port'
+     */
+    /* If: '<S583>/If1' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S583>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S635>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S635>/Data Store Write' */
+        rtDW.MODE_private_a[i] = 0U;
+
+        /* DataStoreWrite: '<S635>/Data Store Write1' */
+        rtDW.COM_private_n[i] = 1U;
+      }
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S635>/Constant'
+       *  Sum: '<S635>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S635>/Write' incorporates:
+       *  DataStoreRead: '<S635>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('LIN 2] Normal Mode\n'); */
+        printf("LIN 2] Normal Mode\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S635>/Write' */
+      /* End of Outputs for SubSystem: '<S583>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S583>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S636>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S636>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S583>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S583>/If1' */
+    /* End of Outputs for SubSystem: '<S502>/Normal Mode' */
     break;
 
    case 4:
-    rtb_out_bc = rtb_out_i4;
+    /* Outputs for IfAction SubSystem: '<S502>/Move to position Min' incorporates:
+     *  ActionPort: '<S582>/Action Port'
+     */
+    /* If: '<S582>/If1' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S582>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S632>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S632>/Data Store Write4' incorporates:
+         *  Constant: '<S632>/Constant1'
+         */
+        rtDW.Autos_private_a[i] = 1U;
+
+        /* DataStoreWrite: '<S632>/Data Store Write2' incorporates:
+         *  Constant: '<S632>/Constant10'
+         */
+        rtDW.Stall_private_h[i] = 1U;
+
+        /* DataStoreWrite: '<S632>/Data Store Write3' */
+        rtDW.Lnoise_private_p[i] = 0U;
+
+        /* DataStoreWrite: '<S632>/Data Store Write5' incorporates:
+         *  Constant: '<S632>/Constant2'
+         */
+        rtDW.Speed_private_e[i] = 3U;
+
+        /* DataStoreWrite: '<S632>/Data Store Write6' incorporates:
+         *  Constant: '<S632>/Constant3'
+         */
+        rtDW.Coils_private_e[i] = 3U;
+
+        /* DataStoreWrite: '<S632>/Data Store Write' */
+        rtDW.POS_private_o[i] = 0U;
+
+        /* DataStoreWrite: '<S632>/Data Store Write1' incorporates:
+         *  Constant: '<S632>/Constant9'
+         */
+        rtDW.COM_private_n[i] = 3U;
+      }
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S632>/Constant'
+       *  Sum: '<S632>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S632>/Write' incorporates:
+       *  DataStoreRead: '<S632>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Move to position Min\n'); */
+        printf("[LIN 2] Move to position Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S632>/Write' */
+      /* End of Outputs for SubSystem: '<S582>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S582>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S633>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S633>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S582>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S582>/If1' */
+    /* End of Outputs for SubSystem: '<S502>/Move to position Min' */
     break;
 
    case 5:
-    rtb_out_bc = rtb_out_fm;
+    /* Outputs for IfAction SubSystem: '<S502>/Check Stall Min' incorporates:
+     *  ActionPort: '<S577>/Action Port'
+     */
+    /* Logic: '<S577>/Logical Operator3' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreRead: '<S577>/Data Store Read'
+     *  Logic: '<S577>/Logical Operator1'
+     *  Logic: '<S577>/Logical Operator2'
+     *  RelationalOperator: '<S577>/Relational Operator'
+     *  RelationalOperator: '<S577>/Relational Operator1'
+     */
+    for (i = 0; i < 6; i++) {
+      rtb_LogicalOperator3_ev[i] =
+        ((Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1) ||
+         (Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 0) ||
+         (rtDW.ErrorCalibration_private_b[i] == 0));
+    }
+
+    /* End of Logic: '<S577>/Logical Operator3' */
+
+    /* Logic: '<S577>/Logical Operator' incorporates:
+     *  Logic: '<S577>/Logical Operator3'
+     */
+    rtb_LogicalOperator1 = rtb_LogicalOperator3_ev[0];
+    for (y = 0; y < 5; y++) {
+      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_ev[y
+        + 1]);
+    }
+
+    /* If: '<S577>/If2' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  DataTypeConversion: '<S577>/Data Type Conversion'
+     *  DataTypeConversion: '<S577>/Data Type Conversion1'
+     *  Logic: '<S577>/Logical Operator'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
+    {
+      /* Outputs for IfAction SubSystem: '<S577>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S590>/Action Port'
+       */
+      /* DataStoreWrite: '<S590>/Data Store Write1' */
+      for (y = 0; y < 9; y++) {
+        /* Switch: '<S590>/Switch' incorporates:
+         *  DataStoreRead: '<S590>/Data Store Read1'
+         */
+        if (rtDW.ErrorCalibration_private_b[y] != 0) {
+          rtDW.MinPositionCh1_private[y] =
+            Actuator_Ch1_Status_Model.in_CPOS_ALL[y];
+        }
+
+        /* End of Switch: '<S590>/Switch' */
+      }
+
+      /* End of DataStoreWrite: '<S590>/Data Store Write1' */
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S590>/Constant'
+       *  Sum: '<S590>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S590>/Write' incorporates:
+       *  DataStoreRead: '<S590>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Check Stall Min\n'); */
+        printf("[LIN 2] Check Stall Min\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(data) */
+        for (i = 0; i < 9; i++) {
+          /* :  fprintf('[LIN 2] MIN = %d ', int16(data(i))); */
+          printf("[LIN 2] MIN = %d ", Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
+          fflush(stdout);
+        }
+
+        /* :  fprintf('\n'); */
+        printf("\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S590>/Write' */
+      /* End of Outputs for SubSystem: '<S577>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S577>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S591>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S591>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S577>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S577>/If2' */
+    /* End of Outputs for SubSystem: '<S502>/Check Stall Min' */
     break;
 
    case 6:
-    rtb_out_bc = rtb_out_d;
+    /* Outputs for IfAction SubSystem: '<S502>/Initial CPOS Max' incorporates:
+     *  ActionPort: '<S579>/Action Port'
+     */
+    /* If: '<S579>/If1' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S579>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S623>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S623>/Data Store Write1' */
+        rtDW.COM_private_n[i] = 2U;
+
+        /* DataStoreWrite: '<S623>/Data Store Write' */
+        rtDW.POS_private_o[i] = 0U;
+      }
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S623>/Constant'
+       *  Sum: '<S623>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S623>/Write' incorporates:
+       *  DataStoreRead: '<S623>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Initial CPOS Max\n'); */
+        printf("[LIN 2] Initial CPOS Max\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S623>/Write' */
+      /* End of Outputs for SubSystem: '<S579>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S579>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S624>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S624>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S579>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S579>/If1' */
+    /* End of Outputs for SubSystem: '<S502>/Initial CPOS Max' */
+    break;
+
+   case 7:
+    /* Outputs for IfAction SubSystem: '<S502>/Move to position Max' incorporates:
+     *  ActionPort: '<S581>/Action Port'
+     */
+    /* If: '<S581>/If1' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S581>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S629>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S629>/Data Store Write4' incorporates:
+         *  Constant: '<S629>/Constant1'
+         */
+        rtDW.Autos_private_a[i] = 1U;
+
+        /* DataStoreWrite: '<S629>/Data Store Write2' incorporates:
+         *  Constant: '<S629>/Constant10'
+         */
+        rtDW.Stall_private_h[i] = 1U;
+
+        /* DataStoreWrite: '<S629>/Data Store Write3' */
+        rtDW.Lnoise_private_p[i] = 0U;
+
+        /* DataStoreWrite: '<S629>/Data Store Write5' incorporates:
+         *  Constant: '<S629>/Constant2'
+         */
+        rtDW.Speed_private_e[i] = 3U;
+
+        /* DataStoreWrite: '<S629>/Data Store Write6' incorporates:
+         *  Constant: '<S629>/Constant3'
+         */
+        rtDW.Coils_private_e[i] = 3U;
+
+        /* DataStoreWrite: '<S629>/Data Store Write' */
+        rtDW.POS_private_o[i] = 6000U;
+
+        /* DataStoreWrite: '<S629>/Data Store Write1' incorporates:
+         *  Constant: '<S629>/Constant9'
+         */
+        rtDW.COM_private_n[i] = 3U;
+      }
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S629>/Constant'
+       *  Sum: '<S629>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S629>/Write' incorporates:
+       *  DataStoreRead: '<S629>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Move to position Max\n'); */
+        printf("[LIN 2] Move to position Max\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S629>/Write' */
+      /* End of Outputs for SubSystem: '<S581>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S581>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S630>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S630>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S581>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S581>/If1' */
+    /* End of Outputs for SubSystem: '<S502>/Move to position Max' */
+    break;
+
+   case 8:
+    /* Outputs for IfAction SubSystem: '<S502>/Check Stall Max' incorporates:
+     *  ActionPort: '<S576>/Action Port'
+     */
+    /* Logic: '<S576>/Logical Operator3' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreRead: '<S576>/Data Store Read'
+     *  Logic: '<S576>/Logical Operator'
+     *  Logic: '<S576>/Logical Operator2'
+     *  RelationalOperator: '<S576>/Relational Operator'
+     *  RelationalOperator: '<S576>/Relational Operator1'
+     */
+    for (i = 0; i < 6; i++) {
+      rtb_LogicalOperator3_ev[i] =
+        ((Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1) ||
+         (Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 6000) ||
+         (rtDW.ErrorCalibration_private_b[i] == 0));
+    }
+
+    /* End of Logic: '<S576>/Logical Operator3' */
+
+    /* Logic: '<S576>/Logical Operator1' incorporates:
+     *  Logic: '<S576>/Logical Operator3'
+     */
+    rtb_LogicalOperator1 = rtb_LogicalOperator3_ev[0];
+    for (y = 0; y < 5; y++) {
+      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_ev[y
+        + 1]);
+    }
+
+    /* If: '<S576>/If2' incorporates:
+     *  DataStoreRead: '<S502>/Data Store Read1'
+     *  DataStoreWrite: '<S502>/Data Store Write1'
+     *  DataTypeConversion: '<S576>/Data Type Conversion'
+     *  DataTypeConversion: '<S576>/Data Type Conversion1'
+     *  Logic: '<S576>/Logical Operator1'
+     *  SignalConversion generated from: '<S502>/Bus Selector'
+     */
+    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
+        (Actuator_Ch1_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
+    {
+      /* Outputs for IfAction SubSystem: '<S576>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S587>/Action Port'
+       */
+      /* DataStoreWrite: '<S587>/Data Store Write1' */
+      for (i = 0; i < 9; i++) {
+        /* Switch: '<S587>/Switch' incorporates:
+         *  DataStoreRead: '<S587>/Data Store Read1'
+         */
+        if (rtDW.ErrorCalibration_private_b[i] != 0) {
+          rtDW.MaxPositionCh1_private[i] =
+            Actuator_Ch1_Status_Model.in_CPOS_ALL[i];
+        } else {
+          rtDW.MaxPositionCh1_private[i] = 0;
+        }
+
+        /* End of Switch: '<S587>/Switch' */
+      }
+
+      /* End of DataStoreWrite: '<S587>/Data Store Write1' */
+
+      /* Merge: '<S502>/Merge' incorporates:
+       *  Constant: '<S587>/Constant'
+       *  Sum: '<S587>/step inc'
+       */
+      rtB.Merge_h = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S587>/Write' incorporates:
+       *  DataStoreRead: '<S587>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 2] Check Stall MAX\n'); */
+        printf("[LIN 2] Check Stall MAX\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(data) */
+        for (i = 0; i < 9; i++) {
+          /* :  fprintf('[LIN 2] MAX = %d ', int16(data(i))); */
+          printf("[LIN 2] MAX = %d ", Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
+          fflush(stdout);
+        }
+
+        /* :  fprintf('\n'); */
+        printf("\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S587>/Write' */
+      /* End of Outputs for SubSystem: '<S576>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S576>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S588>/Action Port'
+       */
+      /* Merge: '<S502>/Merge' incorporates:
+       *  SignalConversion generated from: '<S588>/stepIn'
+       */
+      rtB.Merge_h = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S576>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S576>/If2' */
+    /* End of Outputs for SubSystem: '<S502>/Check Stall Max' */
+    break;
+
+   case 9:
+    /* Outputs for IfAction SubSystem: '<S502>/Homing' incorporates:
+     *  ActionPort: '<S578>/Action Port'
+     */
+    /* Product: '<S593>/Divide1' incorporates:
+     *  Constant: '<S593>/ACT1'
+     *  DataStoreRead: '<S593>/MAX ACT1T '
+     */
+    for (i = 0; i < 6; i++) {
+      rtb_Divide1_gdi[i] = (double)rtDW.MaxPositionCh1_private[i] / (double)
+        rtConstP.ACT1_Value_d[i];
+    }
+
+    /* End of Product: '<S593>/Divide1' */
+
+    /* SignalConversion generated from: '<S593>/Vector Concatenate' incorporates:
+     *  Constant: '<S593>/Constant'
+     */
+    rtb_Divide1_gdi[6] = 1.0;
+    rtb_Divide1_gdi[7] = 1.0;
+    rtb_Divide1_gdi[8] = 1.0;
+
+    /* SwitchCase: '<S578>/Switch Case' incorporates:
+     *  DataStoreRead: '<S578>/Data Store Read4'
+     */
+    switch (rtDW.stepHoming_private_p) {
+     case 0:
+      /* Outputs for IfAction SubSystem: '<S578>/Switch Case Action Subsystem' incorporates:
+       *  ActionPort: '<S594>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* RelationalOperator: '<S599>/Compare' */
+        rtb_Divide1 = rtb_Divide1_gdi[i];
+
+        /* Logic: '<S594>/Logical Operator' incorporates:
+         *  Constant: '<S599>/Constant'
+         *  Constant: '<S600>/Constant'
+         *  RelationalOperator: '<S599>/Compare'
+         *  RelationalOperator: '<S600>/Compare'
+         */
+        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
+        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S602>/Data Type Conversion' incorporates:
+         *  DataStoreRead: '<S602>/Data Store Read'
+         *  DataStoreWrite: '<S602>/Data Store Write'
+         *  Logic: '<S602>/Logical Operator'
+         *  Logic: '<S602>/Logical Operator1'
+         */
+        rtDW.ErrorCalibration_private_b[i] = (uint8_t)((!rtb_LogicalOperator1) &&
+          (rtDW.ErrorCalibration_private_b[i] != 0));
+      }
+
+      /* MATLAB Function: '<S594>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S594>/Data Store Read5'
+       *  DataStoreRead: '<S594>/MIN ACT1T 1'
+       *  Logic: '<S594>/Logical Operator2'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 2] Homing 0\n"); */
+        printf("[LIN 2] Homing 0\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 6; i++) {
+          /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+          printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                 (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
+                 rtb_Divide1_gdi[i], (int16_t)!rtb_LogicalOperator3_a0[i]);
+          fflush(stdout);
+        }
+      }
+
+      /* End of MATLAB Function: '<S594>/MAX POSITION' */
+
+      /* Logic: '<S594>/Logical Operator1' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* Switch: '<S594>/Switch' incorporates:
+       *  Logic: '<S594>/Logical Operator1'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S578>/Merge' incorporates:
+         *  Constant: '<S594>/Constant1'
+         */
+        rtB.Merge_hu = 4;
+      } else {
+        /* Merge: '<S578>/Merge' incorporates:
+         *  Constant: '<S594>/Constant'
+         */
+        rtB.Merge_hu = 1;
+      }
+
+      /* End of Switch: '<S594>/Switch' */
+      /* End of Outputs for SubSystem: '<S578>/Switch Case Action Subsystem' */
+      break;
+
+     case 1:
+      /* Outputs for IfAction SubSystem: '<S578>/Switch Case Action Subsystem1' incorporates:
+       *  ActionPort: '<S595>/Action Port'
+       */
+      /* RelationalOperator: '<S604>/Compare' incorporates:
+       *  Constant: '<S604>/Constant'
+       */
+      for (i = 0; i < 9; i++) {
+        rtb_LogicalOperator3_a0[i] = (rtb_Divide1_gdi[i] > 1.5);
+      }
+
+      /* End of RelationalOperator: '<S604>/Compare' */
+
+      /* Logic: '<S603>/Logical Operator' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* DataTypeConversion: '<S603>/Data Type Conversion' incorporates:
+       *  DataStoreWrite: '<S603>/Data Store Write1'
+       *  Logic: '<S603>/Logical Operator'
+       */
+      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
+      for (i = 0; i < 9; i++) {
+        /* DataTypeConversion: '<S603>/Data Type Conversion1' incorporates:
+         *  DataStoreWrite: '<S603>/Data Store Write2'
+         */
+        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
+        rtDW.COM_private_n[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S603>/Data Type Conversion2' incorporates:
+         *  DataStoreRead: '<S603>/Data Store Read'
+         *  DataStoreWrite: '<S603>/Data Store Write3'
+         *  Logic: '<S603>/Logical Operator1'
+         */
+        rtDW.ErrorActuator_c[i] = (uint8_t)(rtb_LogicalOperator1 ||
+          (rtDW.ErrorActuator_c[i] != 0));
+
+        /* DataStoreWrite: '<S603>/Data Store Write' */
+        rtDW.MODE_private_a[i] = 2U;
+      }
+
+      /* MATLAB Function: '<S603>/Write ERROR' incorporates:
+       *  DataStoreRead: '<S603>/Data Store Read6'
+       */
+      /* :  if(LOGGER>=0) */
+      if (rtDW.LOGGER_LIN >= 0.0) {
+        /* :  for i = 1:numel(ErrCallibration) */
+        for (i = 0; i < 9; i++) {
+          /* :  if ErrCallibration(i) == 1 */
+          if (rtb_LogicalOperator3_a0[i]) {
+            /* :  fprintf('[LIN 2] Failure with actuator #%d\n', int16(i)); */
+            printf("[LIN 2] Failure with actuator #%d\n", (int16_t)(i + 1));
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S603>/Write ERROR' */
+      for (i = 0; i < 9; i++) {
+        /* Logic: '<S595>/Logical Operator1' */
+        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
+
+        /* DataTypeConversion: '<S595>/Data Type Conversion' incorporates:
+         *  DataStoreRead: '<S595>/Data Store Read'
+         *  DataStoreWrite: '<S595>/Data Store Write'
+         *  Logic: '<S595>/Logical Operator'
+         *  Logic: '<S595>/Logical Operator1'
+         */
+        rtDW.ErrorCalibration_private_b[i] = (uint8_t)((!rtb_LogicalOperator1) &&
+          (rtDW.ErrorCalibration_private_b[i] != 0));
+
+        /* DataStoreWrite: '<S607>/Data Store Write' incorporates:
+         *  DataTypeConversion: '<S607>/Data Type Conversion'
+         */
+        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
+      }
+
+      /* DataStoreWrite: '<S606>/Data Store Write' incorporates:
+       *  Constant: '<S606>/Constant'
+       */
+      rtDW.stepSig_private_j = 1;
+
+      /* MATLAB Function: '<S595>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S595>/Data Store Read5'
+       *  DataStoreRead: '<S595>/MIN ACT1T 1'
+       *  DataStoreWrite: '<S595>/Data Store Write'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 2] Homing 1. Start Callibration \n"); */
+        printf("[LIN 2] Homing 1. Start Callibration \n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 6; i++) {
+          /* :  if(ERRORS(i)==1) */
+          if (rtDW.ErrorCalibration_private_b[i] == 1) {
+            /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+            printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                   (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
+                   rtb_Divide1_gdi[i], (int16_t)
+                   rtDW.ErrorCalibration_private_b[i]);
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S595>/MAX POSITION' */
+
+      /* Logic: '<S595>/Logical Operator2' incorporates:
+       *  DataStoreWrite: '<S595>/Data Store Write'
+       */
+      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private_b[0] != 0);
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          (rtDW.ErrorCalibration_private_b[y + 1] != 0));
+      }
+
+      /* Switch: '<S595>/Switch' incorporates:
+       *  Logic: '<S595>/Logical Operator2'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S578>/Merge' incorporates:
+         *  Constant: '<S606>/Constant1'
+         */
+        rtB.Merge_hu = 2;
+      } else {
+        /* Merge: '<S578>/Merge' incorporates:
+         *  Constant: '<S595>/Constant1'
+         */
+        rtB.Merge_hu = 4;
+      }
+
+      /* End of Switch: '<S595>/Switch' */
+      /* End of Outputs for SubSystem: '<S578>/Switch Case Action Subsystem1' */
+      break;
+
+     case 2:
+      /* Outputs for IfAction SubSystem: '<S578>/Switch Case Action Subsystem2' incorporates:
+       *  ActionPort: '<S596>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* RelationalOperator: '<S609>/Compare' */
+        rtb_Divide1 = rtb_Divide1_gdi[i];
+
+        /* Logic: '<S596>/Logical Operator3' incorporates:
+         *  Constant: '<S609>/Constant'
+         *  Constant: '<S610>/Constant'
+         *  DataStoreRead: '<S596>/Data Store Read'
+         *  Logic: '<S596>/Logical Operator1'
+         *  Logic: '<S596>/Logical Operator4'
+         *  RelationalOperator: '<S609>/Compare'
+         *  RelationalOperator: '<S610>/Compare'
+         */
+        rtb_LogicalOperator1 = (((rtb_Divide1 < 0.97) || (rtb_Divide1 > 1.03)) &&
+          (rtDW.ErrorCalibration_private_b[i] != 0));
+        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S596>/Data Type Conversion' incorporates:
+         *  DataStoreWrite: '<S596>/Data Store Write1'
+         */
+        rtDW.ErrorCalibration_private_b[i] = rtb_LogicalOperator1;
+      }
+
+      /* MATLAB Function: '<S596>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S596>/Data Store Read5'
+       *  DataStoreRead: '<S596>/MIN ACT1T 1'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 2] Homing 3. Callibration \n"); */
+        printf("[LIN 2] Homing 3. Callibration \n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 6; i++) {
+          /* :  if(ERRORS(i)==1) */
+          if (rtb_LogicalOperator3_a0[i]) {
+            /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+            printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                   (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
+                   rtb_Divide1_gdi[i], 1);
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S596>/MAX POSITION' */
+
+      /* Logic: '<S596>/Logical Operator2' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* Switch: '<S596>/Switch' incorporates:
+       *  Logic: '<S596>/Logical Operator2'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S578>/Merge' incorporates:
+         *  Constant: '<S596>/Constant3'
+         */
+        rtB.Merge_hu = 3;
+      } else {
+        /* Merge: '<S578>/Merge' incorporates:
+         *  Constant: '<S596>/Constant1'
+         */
+        rtB.Merge_hu = 4;
+      }
+
+      /* End of Switch: '<S596>/Switch' */
+      /* End of Outputs for SubSystem: '<S578>/Switch Case Action Subsystem2' */
+      break;
+
+     case 3:
+      /* Outputs for IfAction SubSystem: '<S578>/Switch Case Action Subsystem3' incorporates:
+       *  ActionPort: '<S597>/Action Port'
+       */
+      /* MATLAB Function: '<S597>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S597>/Data Store Read1'
+       *  DataStoreRead: '<S597>/Data Store Read5'
+       */
+      /* :  if(LOGGER>1) */
+      if (rtDW.LOGGER_LIN > 1.0) {
+        /* :  fprintf("[LIN 2] Homing 3. Start Time on step %d\n",int16(step)); */
+        rtb_Divide1 = rt_roundd(rtDW.ErrorHomming_private_j);
+        if (rtb_Divide1 < 32768.0) {
+          if (rtb_Divide1 >= -32768.0) {
+            AMB = (int16_t)rtb_Divide1;
+          } else {
+            AMB = INT16_MIN;
+          }
+        } else {
+          AMB = INT16_MAX;
+        }
+
+        printf("[LIN 2] Homing 3. Start Time on step %d\n", AMB);
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S597>/MAX POSITION' */
+
+      /* If: '<S597>/If' incorporates:
+       *  DataStoreRead: '<S597>/Data Store Read1'
+       */
+      if (rtDW.ErrorHomming_private_j < 10.0) {
+        /* Outputs for IfAction SubSystem: '<S597>/If Action Subsystem' incorporates:
+         *  ActionPort: '<S612>/Action Port'
+         */
+        /* MATLAB Function: '<S612>/MATLAB Function' incorporates:
+         *  DataStoreRead: '<S612>/Data Store Read'
+         *  DataStoreRead: '<S612>/Data Store Read1'
+         */
+        MATLABFunction(rtDW.Start_timer_l, rtDW.t_now, &rtb_dt_ih,
+                       &rtDW.sf_MATLABFunction_i);
+
+        /* MATLAB Function: '<S612>/MAX POSITION' incorporates:
+         *  DataStoreRead: '<S612>/Data Store Read5'
+         */
+        /* :  if(LOGGER>1) */
+        if (rtDW.LOGGER_LIN > 1.0) {
+          /* :  fprintf("[LIN 2] Homing 3. Start TIme dt = %d \n",int32(data)); */
+          rtb_dt_fa = rtb_dt_ih;
+          if (rtb_dt_ih > 2147483647U) {
+            rtb_dt_fa = 2147483647U;
+          }
+
+          printf("[LIN 2] Homing 3. Start TIme dt = %d \n", (int32_t)rtb_dt_fa);
+          fflush(stdout);
+        }
+
+        /* End of MATLAB Function: '<S612>/MAX POSITION' */
+
+        /* If: '<S612>/If' */
+        if (rtb_dt_ih > 30000U) {
+          /* Outputs for IfAction SubSystem: '<S612>/If Action Subsystem' incorporates:
+           *  ActionPort: '<S615>/Action Port'
+           */
+          /* Merge: '<S578>/Merge' */
+          IfActionSubsystem(&rtB.Merge_hu, &rtDW.ErrorHomming_private_j,
+                            &rtDW.Start_timer_l, &rtDW.stepSig_private_j);
+
+          /* End of Outputs for SubSystem: '<S612>/If Action Subsystem' */
+        } else {
+          /* Outputs for IfAction SubSystem: '<S612>/If Action Subsystem1' incorporates:
+           *  ActionPort: '<S616>/Action Port'
+           */
+          /* Merge: '<S578>/Merge' */
+          IfActionSubsystem1_l(&rtB.Merge_hu, &rtDW.Start_timer_l);
+
+          /* End of Outputs for SubSystem: '<S612>/If Action Subsystem1' */
+        }
+
+        /* End of If: '<S612>/If' */
+        /* End of Outputs for SubSystem: '<S597>/If Action Subsystem' */
+      } else {
+        /* Outputs for IfAction SubSystem: '<S597>/If Action Subsystem1' incorporates:
+         *  ActionPort: '<S613>/Action Port'
+         */
+        IfActionSubsystem1(&rtB.Merge_hu, &rtDW.CCU_ActuatorErrF_Stat_private,
+                           rtDW.COM_private_n, rtDW.ErrorActuator_c,
+                           rtDW.ErrorCalibration_private_b, &rtDW.LOGGER_LIN,
+                           rtDW.MODE_private_a, rtDW.dtc_state_error_model);
+
+        /* End of Outputs for SubSystem: '<S597>/If Action Subsystem1' */
+      }
+
+      /* End of If: '<S597>/If' */
+      /* End of Outputs for SubSystem: '<S578>/Switch Case Action Subsystem3' */
+      break;
+
+     case 4:
+      /* Outputs for IfAction SubSystem: '<S578>/Switch Case Action Subsystem4' incorporates:
+       *  ActionPort: '<S598>/Action Port'
+       */
+      /* DataStoreWrite: '<S598>/Data Store Write' incorporates:
+       *  Constant: '<S598>/Constant'
+       */
+      rtDW.stepSig_private_j = 10;
+
+      /* Merge: '<S578>/Merge' incorporates:
+       *  Constant: '<S598>/Constant1'
+       *  SignalConversion generated from: '<S598>/step'
+       */
+      rtB.Merge_hu = 5;
+
+      /* MATLAB Function: '<S598>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S598>/Data Store Read5'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 2] Homing. Callibration successful \n"); */
+        printf("[LIN 2] Homing. Callibration successful \n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S598>/MAX POSITION' */
+      /* End of Outputs for SubSystem: '<S578>/Switch Case Action Subsystem4' */
+      break;
+    }
+
+    /* End of SwitchCase: '<S578>/Switch Case' */
+
+    /* DataStoreWrite: '<S578>/Data Store Write2' */
+    rtDW.stepHoming_private_p = rtB.Merge_hu;
+
+    /* Merge: '<S502>/Merge' incorporates:
+     *  DataStoreRead: '<S578>/Data Store Read7'
+     */
+    rtB.Merge_h = rtDW.stepSig_private_j;
+
+    /* End of Outputs for SubSystem: '<S502>/Homing' */
     break;
   }
 
-  /* End of MultiPortSwitch: '<S689>/Multiport Switch' */
+  /* End of SwitchCase: '<S502>/Switch Case' */
 
-  /* DataTypeConversion: '<S687>/Data Type Conversion1' incorporates:
-   *  Constant: '<S687>/Constant'
-   *  DataStoreWrite: '<S687>/Data Store Write'
-   *  Product: '<S687>/Divide'
-   *  Sum: '<S687>/Add'
+  /* DataStoreWrite: '<S502>/Finish write stepSig' */
+  rtDW.stepSig_private_j = rtB.Merge_h;
+
+  /* BusCreator: '<S574>/Bus Creator' incorporates:
+   *  DataStoreRead: '<S574>/Data Store Read'
+   *  DataStoreRead: '<S574>/Data Store Read1'
+   *  DataStoreRead: '<S574>/Data Store Read2'
+   *  DataStoreRead: '<S574>/Data Store Read3'
+   *  DataStoreRead: '<S574>/Data Store Read4'
+   *  DataStoreRead: '<S574>/Data Store Read5'
+   *  DataStoreRead: '<S574>/Data Store Read6'
+   *  DataStoreRead: '<S574>/Data Store Read7'
+   *  DataStoreRead: '<S574>/Data Store Read8'
+   *  DataStoreWrite: '<S574>/Data Store Write'
    */
-  rtDW.PWM_front = (uint8_t)((double)(uint16_t)((uint32_t)rtb_out_ee +
-    rtb_out_bc) / 4.0);
+  for (i = 0; i < 9; i++) {
+    Actuator_Ch1_Command_Model.POS[i] = rtDW.POS_private_o[i];
+    Actuator_Ch1_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_m[i];
+    Actuator_Ch1_Command_Model.MODE[i] = rtDW.MODE_private_a[i];
+    Actuator_Ch1_Command_Model.COM[i] = rtDW.COM_private_n[i];
+    Actuator_Ch1_Command_Model.Stall_SET[i] = rtDW.Stall_private_h[i];
+    Actuator_Ch1_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_p[i];
+    Actuator_Ch1_Command_Model.Autos_SET[i] = rtDW.Autos_private_a[i];
+    Actuator_Ch1_Command_Model.Speed_SET[i] = rtDW.Speed_private_e[i];
+    Actuator_Ch1_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_e[i];
+  }
 
-  /* MATLAB Function: '<S690>/AF for Vent mode R' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read18'
+  /* End of BusCreator: '<S574>/Bus Creator' */
+
+  /* RelationalOperator: '<S586>/Compare' incorporates:
+   *  Constant: '<S586>/Constant'
+   *  DataStoreRead: '<S575>/Data Store Read2'
    */
-  AFforVentmodeR(rtDW.FIU_FACE_RL, &rtb_out_ee);
+  for (i = 0; i < 6; i++) {
+    rtb_Compare_l2[i] = (rtDW.ErrorCalibration_private_b[i] == 0);
+  }
 
-  /* MATLAB Function: '<S690>/AF for Bi Level R' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read18'
+  /* End of RelationalOperator: '<S586>/Compare' */
+
+  /* Logic: '<S575>/Logical Operator' */
+  rtb_LogicalOperator1 = rtb_Compare_l2[0];
+  for (y = 0; y < 5; y++) {
+    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_Compare_l2[y + 1]);
+  }
+
+  /* Switch: '<S575>/Switch1' incorporates:
+   *  Constant: '<S575>/Constant'
+   *  Constant: '<S575>/Constant3'
+   *  DataStoreRead: '<S575>/Data Store Read2'
+   *  Logic: '<S575>/Logical Operator'
+   *  Product: '<S575>/Product'
    */
-  AFforBiLevelR(rtDW.FIU_FACE_RL, &rtb_out_hi);
+  for (i = 0; i < 6; i++) {
+    if (rtb_LogicalOperator1) {
+      rtb_VectorConcatenate_c[i] = (uint8_t)((uint32_t)
+        rtDW.ErrorCalibration_private_b[i] * rtConstP.Constant3_Value[i]);
+    } else {
+      rtb_VectorConcatenate_c[i] = 0U;
+    }
+  }
 
-  /* MATLAB Function: '<S690>/AF for Foot R' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read18'
+  /* End of Switch: '<S575>/Switch1' */
+
+  /* SignalConversion generated from: '<S575>/Vector Concatenate' incorporates:
+   *  Constant: '<S575>/Constant1'
    */
-  AFforFootR(rtDW.FIU_FACE_RL, &rtb_out_bc);
+  rtb_VectorConcatenate_c[6] = 0U;
+  rtb_VectorConcatenate_c[7] = 0U;
+  rtb_VectorConcatenate_c[8] = 0U;
+  for (i = 0; i < 9; i++) {
+    /* DataStoreWrite: '<S575>/Data Store Write7' */
+    rtDW.BUS_ADR_private_m[i] = rtb_VectorConcatenate_c[i];
 
-  /* MultiPortSwitch: '<S690>/Multiport Switch' incorporates:
-   *  Constant: '<S690>/Constant1'
-   *  Constant: '<S690>/Constant2'
-   *  Constant: '<S690>/Constant3'
-   *  DataStoreRead: '<S6>/Data Store Read19'
-   *  DataStoreRead: '<S6>/Data Store Read20'
-   *  Gain: '<S690>/Gain2'
-   *  RelationalOperator: '<S690>/Relational Operator1'
-   *  RelationalOperator: '<S690>/Relational Operator2'
-   *  Sum: '<S690>/Add'
+    /* DataStoreWrite: '<S575>/Data Store Write' */
+    rtDW.COM_private_n[i] = 0U;
+
+    /* Switch: '<S652>/Switch' incorporates:
+     *  Constant: '<S652>/Constant'
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreRead: '<S652>/Data Store Read'
+     *  Gain: '<S652>/Gain'
+     *  Product: '<S652>/Divide'
+     */
+    if (rtDW.MaxPositionCh2_private[i] != 0) {
+      y = 100 * (int16_t)div_nde_s32_floor
+        (Actuator_Ch2_Status_Model.in_CPOS_ALL[i], rtDW.MaxPositionCh2_private[i]);
+    } else {
+      y = 0;
+    }
+
+    /* End of Switch: '<S652>/Switch' */
+
+    /* Saturate: '<S652>/Saturation' */
+    if (y > 100) {
+      /* DataTypeConversion: '<S652>/Data Type Conversion' */
+      rtb_DataTypeConversion_ns[i] = 100U;
+    } else if (y < 0) {
+      /* DataTypeConversion: '<S652>/Data Type Conversion' */
+      rtb_DataTypeConversion_ns[i] = 0U;
+    } else {
+      /* DataTypeConversion: '<S652>/Data Type Conversion' */
+      rtb_DataTypeConversion_ns[i] = (uint8_t)y;
+    }
+
+    /* End of Saturate: '<S652>/Saturation' */
+  }
+
+  /* Switch: '<S503>/Switch' incorporates:
+   *  Constant: '<S503>/Constant1'
+   *  DataStoreRead: '<S503>/Data Store Read'
+   *  DataStoreRead: '<S503>/Data Store Read2'
    */
-  switch ((int32_t)((uint32_t)((rtDW.FIU_BLOWERS_RL == 1) << 1) + (uint32_t)
-                    (rtDW.FIU_FOOT_RL == 1))) {
-   case 0:
-    rtb_out_bc = 0U;
-    break;
+  if (rtDW.stepSig_private_o > 0) {
+    rtb_Switch_hx = rtDW.stepSig_private_o;
+  } else {
+    rtb_Switch_hx = 1;
+  }
 
+  /* End of Switch: '<S503>/Switch' */
+
+  /* SwitchCase: '<S503>/Switch Case' */
+  switch (rtb_Switch_hx) {
    case 1:
-    rtb_out_bc = rtb_out_ee;
+    /* Outputs for IfAction SubSystem: '<S503>/Stop Mode' incorporates:
+     *  ActionPort: '<S651>/Action Port'
+     */
+    /* If: '<S651>/If1' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S651>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S705>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S705>/Data Store Write1' */
+        rtDW.COM_private_b[i] = 1U;
+
+        /* DataStoreWrite: '<S705>/Data Store Write' */
+        rtDW.MODE_private_p[i] = 2U;
+      }
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S705>/Constant'
+       *  Sum: '<S705>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S705>/Write' incorporates:
+       *  DataStoreRead: '<S705>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Stop Mode\n'); */
+        printf("[LIN 3] Stop Mode\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S705>/Write' */
+      /* End of Outputs for SubSystem: '<S651>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S651>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S706>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S706>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S651>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S651>/If1' */
+    /* End of Outputs for SubSystem: '<S503>/Stop Mode' */
     break;
 
    case 2:
-    rtb_out_bc = rtb_out_hi;
+    /* Outputs for IfAction SubSystem: '<S503>/Initial CPOS Min' incorporates:
+     *  ActionPort: '<S647>/Action Port'
+     */
+    /* If: '<S647>/If' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S647>/If Action Subsystem' incorporates:
+       *  ActionPort: '<S693>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S693>/Data Store Write' */
+        rtDW.POS_private_g[i] = 6000U;
+
+        /* DataStoreWrite: '<S693>/Data Store Write1' */
+        rtDW.COM_private_b[i] = 2U;
+      }
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S693>/Constant'
+       *  Merge: '<S647>/Merge'
+       *  Sum: '<S693>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S693>/Write' incorporates:
+       *  DataStoreRead: '<S693>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Initial CPOS Min\n'); */
+        printf("[LIN 3] Initial CPOS Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S693>/Write' */
+      /* End of Outputs for SubSystem: '<S647>/If Action Subsystem' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S647>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S694>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Merge: '<S647>/Merge'
+       *  SignalConversion generated from: '<S694>/stepIn1'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S647>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S647>/If' */
+    /* End of Outputs for SubSystem: '<S503>/Initial CPOS Min' */
+    break;
+
+   case 3:
+    /* Outputs for IfAction SubSystem: '<S503>/Normal Mode' incorporates:
+     *  ActionPort: '<S650>/Action Port'
+     */
+    /* If: '<S650>/If1' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S650>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S702>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S702>/Data Store Write' */
+        rtDW.MODE_private_p[i] = 0U;
+
+        /* DataStoreWrite: '<S702>/Data Store Write1' */
+        rtDW.COM_private_b[i] = 1U;
+      }
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S702>/Constant'
+       *  Sum: '<S702>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S702>/Write' incorporates:
+       *  DataStoreRead: '<S702>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Normal Mode\n'); */
+        printf("[LIN 3] Normal Mode\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S702>/Write' */
+      /* End of Outputs for SubSystem: '<S650>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S650>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S703>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S703>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S650>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S650>/If1' */
+    /* End of Outputs for SubSystem: '<S503>/Normal Mode' */
+    break;
+
+   case 4:
+    /* Outputs for IfAction SubSystem: '<S503>/Move to position Min' incorporates:
+     *  ActionPort: '<S649>/Action Port'
+     */
+    /* If: '<S649>/If1' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S649>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S699>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S699>/Data Store Write4' incorporates:
+         *  Constant: '<S699>/Constant1'
+         */
+        rtDW.Autos_private_k[i] = 1U;
+
+        /* DataStoreWrite: '<S699>/Data Store Write2' incorporates:
+         *  Constant: '<S699>/Constant10'
+         */
+        rtDW.Stall_private_h3[i] = 1U;
+
+        /* DataStoreWrite: '<S699>/Data Store Write3' */
+        rtDW.Lnoise_private_k[i] = 0U;
+
+        /* DataStoreWrite: '<S699>/Data Store Write5' incorporates:
+         *  Constant: '<S699>/Constant2'
+         */
+        rtDW.Speed_private_o[i] = 3U;
+
+        /* DataStoreWrite: '<S699>/Data Store Write6' incorporates:
+         *  Constant: '<S699>/Constant3'
+         */
+        rtDW.Coils_private_m[i] = 3U;
+
+        /* DataStoreWrite: '<S699>/Data Store Write' */
+        rtDW.POS_private_g[i] = 0U;
+
+        /* DataStoreWrite: '<S699>/Data Store Write1' incorporates:
+         *  Constant: '<S699>/Constant9'
+         */
+        rtDW.COM_private_b[i] = 3U;
+      }
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S699>/Constant'
+       *  Sum: '<S699>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S699>/Write' incorporates:
+       *  DataStoreRead: '<S699>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Move to position Min\n'); */
+        printf("[LIN 3] Move to position Min\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S699>/Write' */
+      /* End of Outputs for SubSystem: '<S649>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S649>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S700>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S700>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S649>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S649>/If1' */
+    /* End of Outputs for SubSystem: '<S503>/Move to position Min' */
+    break;
+
+   case 5:
+    /* Outputs for IfAction SubSystem: '<S503>/Check Stall Min' incorporates:
+     *  ActionPort: '<S644>/Action Port'
+     */
+    /* Logic: '<S644>/Logical Operator3' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreRead: '<S644>/Data Store Read'
+     *  Logic: '<S644>/Logical Operator1'
+     *  Logic: '<S644>/Logical Operator2'
+     *  RelationalOperator: '<S644>/Relational Operator'
+     *  RelationalOperator: '<S644>/Relational Operator1'
+     */
+    for (i = 0; i < 8; i++) {
+      rtb_Compare_l2[i] = ((Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1)
+                           || (Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 0) ||
+                           (rtDW.ErrorCalibration_private_h[i] == 0));
+    }
+
+    /* End of Logic: '<S644>/Logical Operator3' */
+
+    /* Logic: '<S644>/Logical Operator' incorporates:
+     *  Logic: '<S644>/Logical Operator3'
+     */
+    rtb_LogicalOperator1 = rtb_Compare_l2[0];
+    for (y = 0; y < 7; y++) {
+      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_Compare_l2[y + 1]);
+    }
+
+    /* If: '<S644>/If2' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  DataTypeConversion: '<S644>/Data Type Conversion'
+     *  DataTypeConversion: '<S644>/Data Type Conversion1'
+     *  Logic: '<S644>/Logical Operator'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
+    {
+      /* Outputs for IfAction SubSystem: '<S644>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S657>/Action Port'
+       */
+      /* DataStoreWrite: '<S657>/Data Store Write1' */
+      for (y = 0; y < 9; y++) {
+        /* Switch: '<S657>/Switch' incorporates:
+         *  DataStoreRead: '<S657>/Data Store Read1'
+         */
+        if (rtDW.ErrorCalibration_private_h[y] != 0) {
+          rtDW.MinPositionCh2_private[y] =
+            Actuator_Ch2_Status_Model.in_CPOS_ALL[y];
+        }
+
+        /* End of Switch: '<S657>/Switch' */
+      }
+
+      /* End of DataStoreWrite: '<S657>/Data Store Write1' */
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S657>/Constant'
+       *  Sum: '<S657>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S657>/Write' incorporates:
+       *  DataStoreRead: '<S657>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Check Stall Min\n'); */
+        printf("[LIN 3] Check Stall Min\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(data) */
+        for (i = 0; i < 9; i++) {
+          /* :  fprintf('[LIN 3] MIN = %d ', int16(data(i))); */
+          printf("[LIN 3] MIN = %d ", Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
+          fflush(stdout);
+        }
+
+        /* :  fprintf('\n'); */
+        printf("\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S657>/Write' */
+      /* End of Outputs for SubSystem: '<S644>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S644>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S658>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S658>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S644>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S644>/If2' */
+    /* End of Outputs for SubSystem: '<S503>/Check Stall Min' */
+    break;
+
+   case 6:
+    /* Outputs for IfAction SubSystem: '<S503>/Initial CPOS Max' incorporates:
+     *  ActionPort: '<S646>/Action Port'
+     */
+    /* If: '<S646>/If1' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S646>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S690>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S690>/Data Store Write1' */
+        rtDW.COM_private_b[i] = 2U;
+
+        /* DataStoreWrite: '<S690>/Data Store Write' */
+        rtDW.POS_private_g[i] = 0U;
+      }
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S690>/Constant'
+       *  Sum: '<S690>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S690>/Write' incorporates:
+       *  DataStoreRead: '<S690>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Initial CPOS Max\n'); */
+        printf("[LIN 3] Initial CPOS Max\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S690>/Write' */
+      /* End of Outputs for SubSystem: '<S646>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S646>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S691>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S691>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S646>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S646>/If1' */
+    /* End of Outputs for SubSystem: '<S503>/Initial CPOS Max' */
+    break;
+
+   case 7:
+    /* Outputs for IfAction SubSystem: '<S503>/Move to position Max' incorporates:
+     *  ActionPort: '<S648>/Action Port'
+     */
+    /* If: '<S648>/If1' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
+      /* Outputs for IfAction SubSystem: '<S648>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S696>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* DataStoreWrite: '<S696>/Data Store Write4' incorporates:
+         *  Constant: '<S696>/Constant1'
+         */
+        rtDW.Autos_private_k[i] = 1U;
+
+        /* DataStoreWrite: '<S696>/Data Store Write2' incorporates:
+         *  Constant: '<S696>/Constant10'
+         */
+        rtDW.Stall_private_h3[i] = 1U;
+
+        /* DataStoreWrite: '<S696>/Data Store Write3' */
+        rtDW.Lnoise_private_k[i] = 0U;
+
+        /* DataStoreWrite: '<S696>/Data Store Write5' incorporates:
+         *  Constant: '<S696>/Constant2'
+         */
+        rtDW.Speed_private_o[i] = 3U;
+
+        /* DataStoreWrite: '<S696>/Data Store Write6' incorporates:
+         *  Constant: '<S696>/Constant3'
+         */
+        rtDW.Coils_private_m[i] = 3U;
+
+        /* DataStoreWrite: '<S696>/Data Store Write' */
+        rtDW.POS_private_g[i] = 6000U;
+
+        /* DataStoreWrite: '<S696>/Data Store Write1' incorporates:
+         *  Constant: '<S696>/Constant9'
+         */
+        rtDW.COM_private_b[i] = 3U;
+      }
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S696>/Constant'
+       *  Sum: '<S696>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S696>/Write' incorporates:
+       *  DataStoreRead: '<S696>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Move to position Max\n'); */
+        printf("[LIN 3] Move to position Max\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S696>/Write' */
+      /* End of Outputs for SubSystem: '<S648>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S648>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S697>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S697>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S648>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S648>/If1' */
+    /* End of Outputs for SubSystem: '<S503>/Move to position Max' */
+    break;
+
+   case 8:
+    /* Outputs for IfAction SubSystem: '<S503>/Check Stall Max' incorporates:
+     *  ActionPort: '<S643>/Action Port'
+     */
+    /* Logic: '<S643>/Logical Operator3' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreRead: '<S643>/Data Store Read'
+     *  Logic: '<S643>/Logical Operator'
+     *  Logic: '<S643>/Logical Operator2'
+     *  RelationalOperator: '<S643>/Relational Operator'
+     *  RelationalOperator: '<S643>/Relational Operator1'
+     */
+    for (i = 0; i < 8; i++) {
+      rtb_Compare_l2[i] = ((Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1)
+                           || (Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 6000)
+                           || (rtDW.ErrorCalibration_private_h[i] == 0));
+    }
+
+    /* End of Logic: '<S643>/Logical Operator3' */
+
+    /* Logic: '<S643>/Logical Operator1' incorporates:
+     *  Logic: '<S643>/Logical Operator3'
+     */
+    rtb_LogicalOperator1 = rtb_Compare_l2[0];
+    for (y = 0; y < 7; y++) {
+      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_Compare_l2[y + 1]);
+    }
+
+    /* If: '<S643>/If2' incorporates:
+     *  DataStoreRead: '<S503>/Data Store Read1'
+     *  DataStoreWrite: '<S503>/Data Store Write1'
+     *  DataTypeConversion: '<S643>/Data Type Conversion'
+     *  DataTypeConversion: '<S643>/Data Type Conversion1'
+     *  Logic: '<S643>/Logical Operator1'
+     *  SignalConversion generated from: '<S503>/Bus Selector'
+     */
+    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
+        (Actuator_Ch2_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
+    {
+      /* Outputs for IfAction SubSystem: '<S643>/If Action Subsystem2' incorporates:
+       *  ActionPort: '<S654>/Action Port'
+       */
+      /* DataStoreWrite: '<S654>/Data Store Write1' */
+      for (i = 0; i < 9; i++) {
+        /* Switch: '<S654>/Switch' incorporates:
+         *  DataStoreRead: '<S654>/Data Store Read1'
+         */
+        if (rtDW.ErrorCalibration_private_h[i] != 0) {
+          rtDW.MaxPositionCh2_private[i] =
+            Actuator_Ch2_Status_Model.in_CPOS_ALL[i];
+        } else {
+          rtDW.MaxPositionCh2_private[i] = 0;
+        }
+
+        /* End of Switch: '<S654>/Switch' */
+      }
+
+      /* End of DataStoreWrite: '<S654>/Data Store Write1' */
+
+      /* Merge: '<S503>/Merge' incorporates:
+       *  Constant: '<S654>/Constant'
+       *  Sum: '<S654>/step inc'
+       */
+      rtB.Merge_bj = (int8_t)(rtb_Switch_hx + 1);
+
+      /* MATLAB Function: '<S654>/Write' incorporates:
+       *  DataStoreRead: '<S654>/Data Store Read3'
+       */
+      /* :  if(LOGGER == 2) */
+      if (rtDW.LOGGER_LIN == 2.0) {
+        /* :  fprintf('[LIN 3] Check Stall MAX\n'); */
+        printf("[LIN 3] Check Stall MAX\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(data) */
+        for (i = 0; i < 9; i++) {
+          /* :  fprintf('[LIN 3] MAX = %d ', int16(data(i))); */
+          printf("[LIN 3] MAX = %d ", Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
+          fflush(stdout);
+        }
+
+        /* :  fprintf('\n'); */
+        printf("\n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S654>/Write' */
+      /* End of Outputs for SubSystem: '<S643>/If Action Subsystem2' */
+    } else {
+      /* Outputs for IfAction SubSystem: '<S643>/If Action Subsystem3' incorporates:
+       *  ActionPort: '<S655>/Action Port'
+       */
+      /* Merge: '<S503>/Merge' incorporates:
+       *  SignalConversion generated from: '<S655>/stepIn'
+       */
+      rtB.Merge_bj = rtb_Switch_hx;
+
+      /* End of Outputs for SubSystem: '<S643>/If Action Subsystem3' */
+    }
+
+    /* End of If: '<S643>/If2' */
+    /* End of Outputs for SubSystem: '<S503>/Check Stall Max' */
+    break;
+
+   case 9:
+    /* Outputs for IfAction SubSystem: '<S503>/Homing' incorporates:
+     *  ActionPort: '<S645>/Action Port'
+     */
+    /* Product: '<S660>/Divide1' incorporates:
+     *  Constant: '<S660>/ACT1'
+     *  DataStoreRead: '<S660>/MAX ACT1T '
+     */
+    for (i = 0; i < 8; i++) {
+      rtb_Divide1_gdi[i] = (double)rtDW.MaxPositionCh2_private[i] / (double)
+        rtConstP.ACT1_Value_o[i];
+    }
+
+    /* End of Product: '<S660>/Divide1' */
+
+    /* SignalConversion generated from: '<S660>/Vector Concatenate' incorporates:
+     *  Constant: '<S660>/Constant'
+     */
+    rtb_Divide1_gdi[8] = 1.0;
+
+    /* SwitchCase: '<S645>/Switch Case' incorporates:
+     *  DataStoreRead: '<S645>/Data Store Read4'
+     */
+    switch (rtDW.stepHoming_private_f) {
+     case 0:
+      /* Outputs for IfAction SubSystem: '<S645>/Switch Case Action Subsystem' incorporates:
+       *  ActionPort: '<S661>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* RelationalOperator: '<S666>/Compare' */
+        rtb_Divide1 = rtb_Divide1_gdi[i];
+
+        /* Logic: '<S661>/Logical Operator' incorporates:
+         *  Constant: '<S666>/Constant'
+         *  Constant: '<S667>/Constant'
+         *  RelationalOperator: '<S666>/Compare'
+         *  RelationalOperator: '<S667>/Compare'
+         */
+        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
+        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S669>/Data Type Conversion' incorporates:
+         *  DataStoreRead: '<S669>/Data Store Read'
+         *  DataStoreWrite: '<S669>/Data Store Write'
+         *  Logic: '<S669>/Logical Operator'
+         *  Logic: '<S669>/Logical Operator1'
+         */
+        rtDW.ErrorCalibration_private_h[i] = (uint8_t)((!rtb_LogicalOperator1) &&
+          (rtDW.ErrorCalibration_private_h[i] != 0));
+      }
+
+      /* MATLAB Function: '<S661>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S661>/Data Store Read5'
+       *  DataStoreRead: '<S661>/MIN ACT1T 1'
+       *  Logic: '<S661>/Logical Operator2'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 3] Homing 0\n"); */
+        printf("[LIN 3] Homing 0\n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 6; i++) {
+          /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+          printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                 (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
+                 rtb_Divide1_gdi[i], (int16_t)!rtb_LogicalOperator3_a0[i]);
+          fflush(stdout);
+        }
+      }
+
+      /* End of MATLAB Function: '<S661>/MAX POSITION' */
+
+      /* Logic: '<S661>/Logical Operator1' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* Switch: '<S661>/Switch' incorporates:
+       *  Logic: '<S661>/Logical Operator1'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S645>/Merge' incorporates:
+         *  Constant: '<S661>/Constant1'
+         */
+        rtB.Merge_j = 4;
+      } else {
+        /* Merge: '<S645>/Merge' incorporates:
+         *  Constant: '<S661>/Constant'
+         */
+        rtB.Merge_j = 1;
+      }
+
+      /* End of Switch: '<S661>/Switch' */
+      /* End of Outputs for SubSystem: '<S645>/Switch Case Action Subsystem' */
+      break;
+
+     case 1:
+      /* Outputs for IfAction SubSystem: '<S645>/Switch Case Action Subsystem1' incorporates:
+       *  ActionPort: '<S662>/Action Port'
+       */
+      /* RelationalOperator: '<S671>/Compare' incorporates:
+       *  Constant: '<S671>/Constant'
+       */
+      for (i = 0; i < 9; i++) {
+        rtb_LogicalOperator3_a0[i] = (rtb_Divide1_gdi[i] > 1.5);
+      }
+
+      /* End of RelationalOperator: '<S671>/Compare' */
+
+      /* Logic: '<S670>/Logical Operator' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* DataTypeConversion: '<S670>/Data Type Conversion' incorporates:
+       *  DataStoreWrite: '<S670>/Data Store Write1'
+       *  Logic: '<S670>/Logical Operator'
+       */
+      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
+      for (i = 0; i < 9; i++) {
+        /* DataTypeConversion: '<S670>/Data Type Conversion1' incorporates:
+         *  DataStoreWrite: '<S670>/Data Store Write2'
+         */
+        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
+        rtDW.COM_private_b[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S670>/Data Type Conversion2' incorporates:
+         *  DataStoreRead: '<S670>/Data Store Read'
+         *  DataStoreWrite: '<S670>/Data Store Write3'
+         *  Logic: '<S670>/Logical Operator1'
+         */
+        rtDW.ErrorActuator_o[i] = (uint8_t)(rtb_LogicalOperator1 ||
+          (rtDW.ErrorActuator_o[i] != 0));
+
+        /* DataStoreWrite: '<S670>/Data Store Write' */
+        rtDW.MODE_private_p[i] = 2U;
+      }
+
+      /* MATLAB Function: '<S670>/Write ERROR' incorporates:
+       *  DataStoreRead: '<S670>/Data Store Read6'
+       */
+      /* :  if(LOGGER>=0) */
+      if (rtDW.LOGGER_LIN >= 0.0) {
+        /* :  for i = 1:numel(ErrCallibration) */
+        for (i = 0; i < 9; i++) {
+          /* :  if ErrCallibration(i) == 1 */
+          if (rtb_LogicalOperator3_a0[i]) {
+            /* :  fprintf('[LIN 3] Failure with actuator #%d\n', int16(i)); */
+            printf("[LIN 3] Failure with actuator #%d\n", (int16_t)(i + 1));
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S670>/Write ERROR' */
+      for (i = 0; i < 9; i++) {
+        /* Logic: '<S662>/Logical Operator1' */
+        rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[i];
+
+        /* DataTypeConversion: '<S662>/Data Type Conversion' incorporates:
+         *  DataStoreRead: '<S662>/Data Store Read'
+         *  DataStoreWrite: '<S662>/Data Store Write'
+         *  Logic: '<S662>/Logical Operator'
+         *  Logic: '<S662>/Logical Operator1'
+         */
+        rtDW.ErrorCalibration_private_h[i] = (uint8_t)((!rtb_LogicalOperator1) &&
+          (rtDW.ErrorCalibration_private_h[i] != 0));
+
+        /* DataStoreWrite: '<S674>/Data Store Write' incorporates:
+         *  DataTypeConversion: '<S674>/Data Type Conversion'
+         */
+        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
+      }
+
+      /* DataStoreWrite: '<S673>/Data Store Write' incorporates:
+       *  Constant: '<S673>/Constant'
+       */
+      rtDW.stepSig_private_o = 1;
+
+      /* MATLAB Function: '<S662>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S662>/Data Store Read5'
+       *  DataStoreRead: '<S662>/MIN ACT1T 1'
+       *  DataStoreWrite: '<S662>/Data Store Write'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 3] Homing 1. Start Callibration \n"); */
+        printf("[LIN 3] Homing 1. Start Callibration \n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 6; i++) {
+          /* :  if(ERRORS(i)==1) */
+          if (rtDW.ErrorCalibration_private_h[i] == 1) {
+            /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+            printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                   (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
+                   rtb_Divide1_gdi[i], (int16_t)
+                   rtDW.ErrorCalibration_private_h[i]);
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S662>/MAX POSITION' */
+
+      /* Logic: '<S662>/Logical Operator2' incorporates:
+       *  DataStoreWrite: '<S662>/Data Store Write'
+       */
+      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private_h[0] != 0);
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          (rtDW.ErrorCalibration_private_h[y + 1] != 0));
+      }
+
+      /* Switch: '<S662>/Switch' incorporates:
+       *  Logic: '<S662>/Logical Operator2'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S645>/Merge' incorporates:
+         *  Constant: '<S673>/Constant1'
+         */
+        rtB.Merge_j = 2;
+      } else {
+        /* Merge: '<S645>/Merge' incorporates:
+         *  Constant: '<S662>/Constant1'
+         */
+        rtB.Merge_j = 4;
+      }
+
+      /* End of Switch: '<S662>/Switch' */
+      /* End of Outputs for SubSystem: '<S645>/Switch Case Action Subsystem1' */
+      break;
+
+     case 2:
+      /* Outputs for IfAction SubSystem: '<S645>/Switch Case Action Subsystem2' incorporates:
+       *  ActionPort: '<S663>/Action Port'
+       */
+      for (i = 0; i < 9; i++) {
+        /* RelationalOperator: '<S676>/Compare' */
+        rtb_Divide1 = rtb_Divide1_gdi[i];
+
+        /* Logic: '<S663>/Logical Operator3' incorporates:
+         *  Constant: '<S676>/Constant'
+         *  Constant: '<S677>/Constant'
+         *  DataStoreRead: '<S663>/Data Store Read'
+         *  Logic: '<S663>/Logical Operator1'
+         *  Logic: '<S663>/Logical Operator4'
+         *  RelationalOperator: '<S676>/Compare'
+         *  RelationalOperator: '<S677>/Compare'
+         */
+        rtb_LogicalOperator1 = (((rtb_Divide1 < 0.97) || (rtb_Divide1 > 1.03)) &&
+          (rtDW.ErrorCalibration_private_h[i] != 0));
+        rtb_LogicalOperator3_a0[i] = rtb_LogicalOperator1;
+
+        /* DataTypeConversion: '<S663>/Data Type Conversion' incorporates:
+         *  DataStoreWrite: '<S663>/Data Store Write1'
+         */
+        rtDW.ErrorCalibration_private_h[i] = rtb_LogicalOperator1;
+      }
+
+      /* MATLAB Function: '<S663>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S663>/Data Store Read5'
+       *  DataStoreRead: '<S663>/MIN ACT1T 1'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 3] Homing 3. Callibration \n"); */
+        printf("[LIN 3] Homing 3. Callibration \n");
+        fflush(stdout);
+
+        /* :  for i = 1:numel(MAX) */
+        for (i = 0; i < 6; i++) {
+          /* :  if(ERRORS(i)==1) */
+          if (rtb_LogicalOperator3_a0[i]) {
+            /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
+            printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
+                   (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
+                   rtb_Divide1_gdi[i], 1);
+            fflush(stdout);
+          }
+        }
+      }
+
+      /* End of MATLAB Function: '<S663>/MAX POSITION' */
+
+      /* Logic: '<S663>/Logical Operator2' */
+      rtb_LogicalOperator1 = rtb_LogicalOperator3_a0[0];
+      for (y = 0; y < 8; y++) {
+        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
+          rtb_LogicalOperator3_a0[y + 1]);
+      }
+
+      /* Switch: '<S663>/Switch' incorporates:
+       *  Logic: '<S663>/Logical Operator2'
+       */
+      if (rtb_LogicalOperator1) {
+        /* Merge: '<S645>/Merge' incorporates:
+         *  Constant: '<S663>/Constant3'
+         */
+        rtB.Merge_j = 3;
+      } else {
+        /* Merge: '<S645>/Merge' incorporates:
+         *  Constant: '<S663>/Constant1'
+         */
+        rtB.Merge_j = 4;
+      }
+
+      /* End of Switch: '<S663>/Switch' */
+      /* End of Outputs for SubSystem: '<S645>/Switch Case Action Subsystem2' */
+      break;
+
+     case 3:
+      /* Outputs for IfAction SubSystem: '<S645>/Switch Case Action Subsystem3' incorporates:
+       *  ActionPort: '<S664>/Action Port'
+       */
+      /* MATLAB Function: '<S664>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S664>/Data Store Read1'
+       *  DataStoreRead: '<S664>/Data Store Read5'
+       */
+      /* :  if(LOGGER>1) */
+      if (rtDW.LOGGER_LIN > 1.0) {
+        /* :  fprintf("[LIN 3] Homing 3. Start Time on step %d\n",int16(step)); */
+        rtb_Divide1 = rt_roundd(rtDW.ErrorHomming_private_m);
+        if (rtb_Divide1 < 32768.0) {
+          if (rtb_Divide1 >= -32768.0) {
+            AMB = (int16_t)rtb_Divide1;
+          } else {
+            AMB = INT16_MIN;
+          }
+        } else {
+          AMB = INT16_MAX;
+        }
+
+        printf("[LIN 3] Homing 3. Start Time on step %d\n", AMB);
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S664>/MAX POSITION' */
+
+      /* If: '<S664>/If' incorporates:
+       *  DataStoreRead: '<S664>/Data Store Read1'
+       */
+      if (rtDW.ErrorHomming_private_m < 10.0) {
+        /* Outputs for IfAction SubSystem: '<S664>/If Action Subsystem' incorporates:
+         *  ActionPort: '<S679>/Action Port'
+         */
+        /* MATLAB Function: '<S679>/MATLAB Function' incorporates:
+         *  DataStoreRead: '<S679>/Data Store Read'
+         *  DataStoreRead: '<S679>/Data Store Read1'
+         */
+        MATLABFunction(rtDW.Start_timer, rtDW.t_now, &rtb_dt_ih,
+                       &rtDW.sf_MATLABFunction_c);
+
+        /* MATLAB Function: '<S679>/MAX POSITION' incorporates:
+         *  DataStoreRead: '<S679>/Data Store Read5'
+         */
+        /* :  if(LOGGER>1) */
+        if (rtDW.LOGGER_LIN > 1.0) {
+          /* :  fprintf("[LIN 3] Homing 3. Start TIme dt = %d \n",int32(data)); */
+          rtb_dt_fa = rtb_dt_ih;
+          if (rtb_dt_ih > 2147483647U) {
+            rtb_dt_fa = 2147483647U;
+          }
+
+          printf("[LIN 3] Homing 3. Start TIme dt = %d \n", (int32_t)rtb_dt_fa);
+          fflush(stdout);
+        }
+
+        /* End of MATLAB Function: '<S679>/MAX POSITION' */
+
+        /* If: '<S679>/If' */
+        if (rtb_dt_ih > 30000U) {
+          /* Outputs for IfAction SubSystem: '<S679>/If Action Subsystem' incorporates:
+           *  ActionPort: '<S682>/Action Port'
+           */
+          /* Merge: '<S645>/Merge' */
+          IfActionSubsystem(&rtB.Merge_j, &rtDW.ErrorHomming_private_m,
+                            &rtDW.Start_timer, &rtDW.stepSig_private_o);
+
+          /* End of Outputs for SubSystem: '<S679>/If Action Subsystem' */
+        } else {
+          /* Outputs for IfAction SubSystem: '<S679>/If Action Subsystem1' incorporates:
+           *  ActionPort: '<S683>/Action Port'
+           */
+          /* Merge: '<S645>/Merge' */
+          IfActionSubsystem1_l(&rtB.Merge_j, &rtDW.Start_timer);
+
+          /* End of Outputs for SubSystem: '<S679>/If Action Subsystem1' */
+        }
+
+        /* End of If: '<S679>/If' */
+        /* End of Outputs for SubSystem: '<S664>/If Action Subsystem' */
+      } else {
+        /* Outputs for IfAction SubSystem: '<S664>/If Action Subsystem1' incorporates:
+         *  ActionPort: '<S680>/Action Port'
+         */
+        IfActionSubsystem1(&rtB.Merge_j, &rtDW.CCU_ActuatorErrF_Stat_private,
+                           rtDW.COM_private_b, rtDW.ErrorActuator_o,
+                           rtDW.ErrorCalibration_private_h, &rtDW.LOGGER_LIN,
+                           rtDW.MODE_private_p, rtDW.dtc_state_error_model);
+
+        /* End of Outputs for SubSystem: '<S664>/If Action Subsystem1' */
+      }
+
+      /* End of If: '<S664>/If' */
+      /* End of Outputs for SubSystem: '<S645>/Switch Case Action Subsystem3' */
+      break;
+
+     case 4:
+      /* Outputs for IfAction SubSystem: '<S645>/Switch Case Action Subsystem4' incorporates:
+       *  ActionPort: '<S665>/Action Port'
+       */
+      /* DataStoreWrite: '<S665>/Data Store Write' incorporates:
+       *  Constant: '<S665>/Constant'
+       */
+      rtDW.stepSig_private_o = 10;
+
+      /* Merge: '<S645>/Merge' incorporates:
+       *  Constant: '<S665>/Constant1'
+       *  SignalConversion generated from: '<S665>/step'
+       */
+      rtB.Merge_j = 5;
+
+      /* MATLAB Function: '<S665>/MAX POSITION' incorporates:
+       *  DataStoreRead: '<S665>/Data Store Read5'
+       */
+      /* :  if(LOGGER>0) */
+      if (rtDW.LOGGER_LIN > 0.0) {
+        /* :  fprintf("[LIN 3] Homing. Callibration successful \n"); */
+        printf("[LIN 3] Homing. Callibration successful \n");
+        fflush(stdout);
+      }
+
+      /* End of MATLAB Function: '<S665>/MAX POSITION' */
+      /* End of Outputs for SubSystem: '<S645>/Switch Case Action Subsystem4' */
+      break;
+    }
+
+    /* End of SwitchCase: '<S645>/Switch Case' */
+
+    /* DataStoreWrite: '<S645>/Data Store Write2' */
+    rtDW.stepHoming_private_f = rtB.Merge_j;
+
+    /* Merge: '<S503>/Merge' incorporates:
+     *  DataStoreRead: '<S645>/Data Store Read7'
+     */
+    rtB.Merge_bj = rtDW.stepSig_private_o;
+
+    /* End of Outputs for SubSystem: '<S503>/Homing' */
     break;
   }
 
-  /* End of MultiPortSwitch: '<S690>/Multiport Switch' */
+  /* End of SwitchCase: '<S503>/Switch Case' */
 
-  /* MATLAB Function: '<S691>/AF for Vent mode R' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read15'
+  /* Outport: '<Root>/CCU_Errors_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read10'
    */
-  AFforVentmodeR(rtDW.FIU_BLOWERS_RR, &rtb_out_hi);
+  rtY.CCU_Errors_model = CCU_Errors_Model;
 
-  /* MATLAB Function: '<S691>/AF for Bi Level R' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read15'
+  /* DataStoreWrite: '<S503>/Finish write stepSig' */
+  rtDW.stepSig_private_o = rtB.Merge_bj;
+
+  /* BusCreator: '<S641>/Bus Creator' incorporates:
+   *  DataStoreRead: '<S641>/Data Store Read'
+   *  DataStoreRead: '<S641>/Data Store Read1'
+   *  DataStoreRead: '<S641>/Data Store Read2'
+   *  DataStoreRead: '<S641>/Data Store Read3'
+   *  DataStoreRead: '<S641>/Data Store Read4'
+   *  DataStoreRead: '<S641>/Data Store Read5'
+   *  DataStoreRead: '<S641>/Data Store Read6'
+   *  DataStoreRead: '<S641>/Data Store Read7'
+   *  DataStoreRead: '<S641>/Data Store Read8'
+   *  DataStoreWrite: '<S641>/Data Store Write'
    */
-  AFforBiLevelR(rtDW.FIU_BLOWERS_RR, &rtb_out_cb);
-
-  /* MATLAB Function: '<S691>/AF for Foot R' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read15'
-   */
-  AFforFootR(rtDW.FIU_BLOWERS_RR, &rtb_out_ee);
-
-  /* MultiPortSwitch: '<S691>/Multiport Switch' incorporates:
-   *  Constant: '<S691>/Constant1'
-   *  Constant: '<S691>/Constant2'
-   *  Constant: '<S691>/Constant3'
-   *  DataStoreRead: '<S6>/Data Store Read16'
-   *  DataStoreRead: '<S6>/Data Store Read17'
-   *  Gain: '<S691>/Gain2'
-   *  RelationalOperator: '<S691>/Relational Operator1'
-   *  RelationalOperator: '<S691>/Relational Operator2'
-   *  Sum: '<S691>/Add'
-   */
-  switch ((int32_t)((uint32_t)((rtDW.FIU_FOOT_RR == 1) << 1) + (uint32_t)
-                    (rtDW.FIU_FACE_RR == 1))) {
-   case 0:
-    rtb_out_ee = 0U;
-    break;
-
-   case 1:
-    rtb_out_ee = rtb_out_hi;
-    break;
-
-   case 2:
-    rtb_out_ee = rtb_out_cb;
-    break;
+  for (i = 0; i < 9; i++) {
+    Actuator_Ch2_Command_Model.POS[i] = rtDW.POS_private_g[i];
+    Actuator_Ch2_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_p[i];
+    Actuator_Ch2_Command_Model.MODE[i] = rtDW.MODE_private_p[i];
+    Actuator_Ch2_Command_Model.COM[i] = rtDW.COM_private_b[i];
+    Actuator_Ch2_Command_Model.Stall_SET[i] = rtDW.Stall_private_h3[i];
+    Actuator_Ch2_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_k[i];
+    Actuator_Ch2_Command_Model.Autos_SET[i] = rtDW.Autos_private_k[i];
+    Actuator_Ch2_Command_Model.Speed_SET[i] = rtDW.Speed_private_o[i];
+    Actuator_Ch2_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_m[i];
   }
 
-  /* End of MultiPortSwitch: '<S691>/Multiport Switch' */
+  /* End of BusCreator: '<S641>/Bus Creator' */
 
-  /* DataTypeConversion: '<S687>/Data Type Conversion' incorporates:
-   *  Constant: '<S687>/Constant1'
-   *  DataStoreWrite: '<S687>/Data Store Write1'
-   *  Product: '<S687>/Divide1'
-   *  Sum: '<S687>/Add1'
+  /* RelationalOperator: '<S653>/Compare' incorporates:
+   *  Constant: '<S653>/Constant'
+   *  DataStoreRead: '<S642>/Data Store Read2'
    */
-  rtDW.PWM_rear = (uint8_t)((double)(uint16_t)((uint32_t)rtb_out_bc + rtb_out_ee)
-    / 4.0);
+  for (i = 0; i < 8; i++) {
+    rtb_Compare_l2[i] = (rtDW.ErrorCalibration_private_h[i] == 0);
+  }
 
-  /* MATLAB Function: '<S687>/Write' incorporates:
-   *  DataStoreWrite: '<S687>/Data Store Write'
+  /* End of RelationalOperator: '<S653>/Compare' */
+
+  /* Logic: '<S642>/Logical Operator' */
+  rtb_LogicalOperator1 = rtb_Compare_l2[0];
+  for (y = 0; y < 7; y++) {
+    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_Compare_l2[y + 1]);
+  }
+
+  /* Switch: '<S642>/Switch1' incorporates:
+   *  Constant: '<S642>/Constant'
+   *  Constant: '<S642>/Constant3'
+   *  DataStoreRead: '<S642>/Data Store Read2'
+   *  Logic: '<S642>/Logical Operator'
+   *  Product: '<S642>/Product'
    */
-  /* :  fprintf('pwmFront_output = %u \n',data); */
-  printf("pwmFront_output = %u \n", rtDW.PWM_front);
+  for (i = 0; i < 8; i++) {
+    if (rtb_LogicalOperator1) {
+      rtb_VectorConcatenate_c[i] = (uint8_t)((uint32_t)
+        rtDW.ErrorCalibration_private_h[i] * rtConstP.Constant3_Value_j[i]);
+    } else {
+      rtb_VectorConcatenate_c[i] = 0U;
+    }
+  }
+
+  /* End of Switch: '<S642>/Switch1' */
+
+  /* SignalConversion generated from: '<S642>/Vector Concatenate' incorporates:
+   *  Constant: '<S642>/Constant1'
+   */
+  rtb_VectorConcatenate_c[8] = 0U;
+  for (i = 0; i < 9; i++) {
+    /* DataStoreWrite: '<S642>/Data Store Write7' */
+    rtDW.BUS_ADR_private_p[i] = rtb_VectorConcatenate_c[i];
+
+    /* DataStoreWrite: '<S642>/Data Store Write' */
+    rtDW.COM_private_b[i] = 0U;
+  }
+
+  /* DataStoreWrite: '<S5>/Data Store Write' incorporates:
+   *  Constant: '<S5>/Constant'
+   */
+  rtDW.LOGGER_LIN = 1.0;
+
+  /* BusCreator: '<S7>/Bus Creator' incorporates:
+   *  Constant: '<S7>/Constant2'
+   *  Constant: '<S7>/Constant3'
+   *  DataStoreRead: '<S7>/Data Store Read3'
+   *  DataStoreRead: '<S7>/Data Store Read4'
+   *  DataStoreWrite: '<S7>/Data Store Write'
+   */
+  PWM_Get.pwmPercentFront = rtDW.PWM_front;
+  PWM_Get.pwmPercentRear = rtDW.PWM_rear;
+  PWM_Get.pwmPercentFrontReserved = 0U;
+  PWM_Get.pwmPercentRearReserved = 0U;
+
+  /* MATLAB Function: '<S7>/Write' incorporates:
+   *  DataStoreRead: '<S7>/Data Store Read'
+   */
+  /* :  if(LOGGER) */
+  /* :  fprintf('pwmPercentFront = %u \n',data); */
+  printf("pwmPercentFront = %u \n", rtDW.PWM_Set_Model.pwmPercentFront);
   fflush(stdout);
 
-  /* MATLAB Function: '<S687>/Write2' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* MATLAB Function: '<S7>/Write1' incorporates:
+   *  DataStoreRead: '<S7>/Data Store Read'
    */
-  /* :  fprintf('speedL_input = %u \n',data); */
-  printf("speedL_input = %u \n", rtDW.FIU_BLOWERS_FR);
+  /* :  if(LOGGER) */
+  /* :  fprintf('pwmPercentRear = %u \n',data); */
+  printf("pwmPercentRear = %u \n", rtDW.PWM_Set_Model.pwmPercentRear);
   fflush(stdout);
 
-  /* MATLAB Function: '<S688>/AF for Tri-Level' incorporates:
-   *  DataStoreRead: '<S6>/Data Store Read11'
+  /* MATLAB Function: '<S7>/Write2' incorporates:
+   *  DataStoreRead: '<S7>/Data Store Read'
    */
-  AFforTriLevel(rtDW.FIU_BLOWERS_FR, &rtb_out_ee);
-
-  /* MATLAB Function: '<S687>/Write1' incorporates:
-   *  DataStoreWrite: '<S687>/Data Store Write1'
-   */
-  /* :  fprintf('pwmRear_output = %u \n',data); */
-  printf("pwmRear_output = %u \n", rtDW.PWM_rear);
+  /* :  if(LOGGER) */
+  /* :  fprintf('pwmPercentFrontReserved = %u \n',data); */
+  printf("pwmPercentFrontReserved = %u \n",
+         rtDW.PWM_Set_Model.pwmPercentFrontReserved);
   fflush(stdout);
 
-  /* End of Outputs for SubSystem: '<Root>/PWM and valves in manual' */
+  /* MATLAB Function: '<S7>/Write3' incorporates:
+   *  DataStoreRead: '<S7>/Data Store Read'
+   */
+  /* :  if(LOGGER) */
+  /* :  fprintf('pwmPercentRearReserved = %u \n',data); */
+  printf("pwmPercentRearReserved = %u \n",
+         rtDW.PWM_Set_Model.pwmPercentRearReserved);
+  fflush(stdout);
+
+  /* BusCreator: '<S1284>/Bus Creator1' incorporates:
+   *  DataStoreRead: '<S1284>/Data Store Read1'
+   *  DataStoreRead: '<S1284>/Data Store Read10'
+   *  DataStoreRead: '<S1284>/Data Store Read11'
+   *  DataStoreRead: '<S1284>/Data Store Read13'
+   *  DataStoreRead: '<S1284>/Data Store Read15'
+   *  DataStoreRead: '<S1284>/Data Store Read17'
+   *  DataStoreRead: '<S1284>/Data Store Read19'
+   *  DataStoreRead: '<S1284>/Data Store Read3'
+   *  DataStoreRead: '<S1284>/Data Store Read4'
+   *  DataStoreRead: '<S1284>/Data Store Read8'
+   *  DataStoreWrite: '<S1284>/Data Store Write1'
+   */
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Fb_Select = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Lower_Fb = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Lower_Tgt = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Side_Fb = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Upper_Fb = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Upper_Tgt = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_MultMsg_Idx = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Fb_Select = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Lower_Fb = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Lower_Tgt = Duct1_F;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Side_Fb = Duct2_F;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Upper_Fb = Duct3_R;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Upper_Tgt = Duct4_R;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Fb = Duct5_F;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Fb_Select = Duct6_F;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Side_Fb = Duct1_R;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Tgt = Duct2_R;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Fb = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Fb_Select = 0;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Side_Fb = Duct3_F;
+  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Tgt = Duct4_F;
+
+  /* BusCreator: '<S1285>/Bus Creator1' incorporates:
+   *  DataStoreRead: '<S1285>/Data Store Read3'
+   *  DataStoreRead: '<S1285>/Data Store Read4'
+   *  DataStoreWrite: '<S1285>/Data Store Write1'
+   */
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act00_Def = Actuator_pos_percent_Ch0[0];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act01_Vent_SFL = Actuator_pos_percent_Ch0[5];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act02_Vent_CFL = Actuator_pos_percent_Ch0[4];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act03_Foot_1FL = Actuator_pos_percent_Ch0[7];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act04_Foot_2FL = Actuator_pos_percent_Ch0[8];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act05_Vent_CFR = rtb_DataTypeConversion_md[1];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act06_Vent_SFR = rtb_DataTypeConversion_md[2];
+  rtDW.dbgCAN_dbg_Act0_model.dbg_Act07_Foot_1FR = rtb_DataTypeConversion_md[4];
+
+  /* BusCreator: '<S1285>/Bus Creator3' incorporates:
+   *  DataStoreRead: '<S1285>/Data Store Read3'
+   *  DataStoreRead: '<S1285>/Data Store Read4'
+   *  DataStoreWrite: '<S1285>/Data Store Write2'
+   *  DataStoreWrite: '<S503>/Data Store Write2'
+   */
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act16_TempL_FL = Actuator_pos_percent_Ch0[6];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act17_TempU_FR = rtb_DataTypeConversion_md[0];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act18_TempL_FR = rtb_DataTypeConversion_md[3];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act19_Temp_RL = rtb_DataTypeConversion_ns[1];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act20_Temp_RR = rtb_DataTypeConversion_ns[0];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act21_Rec = Actuator_pos_percent_Ch0[1];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act22_OSA = Actuator_pos_percent_Ch0[2];
+  rtDW.dbgCAN_dbg_Act2_model.dbg_Act23_SealingValve = rtb_DataTypeConversion_ns
+    [8];
+
+  /* BusCreator: '<S1285>/Bus Creator2' incorporates:
+   *  DataStoreRead: '<S1285>/Data Store Read3'
+   *  DataStoreRead: '<S1285>/Data Store Read4'
+   *  DataStoreWrite: '<S1285>/Data Store Write3'
+   *  DataStoreWrite: '<S503>/Data Store Write2'
+   */
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act08_Foot_2FR = rtb_DataTypeConversion_md[5];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act09_Vent_SRL = rtb_DataTypeConversion_ns[2];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act10_Vent_CRL = rtb_DataTypeConversion_ns[4];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act11_Foot_RL = rtb_DataTypeConversion_ns[3];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act12_Vent_CRR = rtb_DataTypeConversion_ns[5];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act13_Vent_SRR = rtb_DataTypeConversion_ns[7];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act14_Foot_RR = rtb_DataTypeConversion_ns[6];
+  rtDW.dbgCAN_dbg_Act1_model.dbg_Act15_TempU_FL = Actuator_pos_percent_Ch0[3];
+
+  /* BusCreator: '<S1286>/Bus Creator' incorporates:
+   *  DataStoreRead: '<S1286>/Data Store Read'
+   *  DataStoreRead: '<S1286>/Data Store Read1'
+   *  DataStoreRead: '<S1286>/Data Store Read2'
+   *  DataStoreRead: '<S1286>/Data Store Read3'
+   *  DataStoreRead: '<S1286>/Data Store Read4'
+   *  DataStoreRead: '<S1286>/Data Store Read5'
+   *  DataStoreWrite: '<S1286>/Data Store Write'
+   */
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_FL = 0U;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_FR = 0U;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_RL = 0U;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_RR = 0U;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Pwm_Front = rtDW.PWM_front;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Pwm_Rear = rtDW.PWM_rear;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_FL = rtDW.Blower_AF_FL;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_FR = rtDW.Blower_AF_FR;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_RL = rtDW.Blower_AF_RL;
+  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_RR = rtDW.Blower_AF_RR;
+
+  /* BusCreator: '<S1287>/Bus Creator' incorporates:
+   *  DataStoreRead: '<S1287>/Data Store Read'
+   *  DataStoreRead: '<S1287>/Data Store Read1'
+   *  DataStoreWrite: '<S1287>/Data Store Write'
+   */
+  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_F = 0;
+  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_R = 0;
+  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_Target = Eva_F;
+  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_Diff_FrontRear = Eva_R;
+
+  /* Outport: '<Root>/PWM_Get' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read7'
+   */
+  rtY.PWM_Get_f = PWM_Get;
+
+  /* Outport: '<Root>/dtc_state_error_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read1'
+   */
+  memcpy(&rtY.dtc_state_error_model[0], &rtDW.dtc_state_error_model[0], 127U *
+         sizeof(uint8_t));
+
+  /* Outport: '<Root>/dbgCAN_dbg_Act0_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read3'
+   */
+  rtY.dbgCAN_dbg_Act0_model = rtDW.dbgCAN_dbg_Act0_model;
+
+  /* Outport: '<Root>/dbgCAN_dbg_Act1_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read4'
+   */
+  rtY.dbgCAN_dbg_Act1_model = rtDW.dbgCAN_dbg_Act1_model;
+
+  /* Outport: '<Root>/dbgCAN_dbg_Act2_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read5'
+   */
+  rtY.dbgCAN_dbg_Act2_model = rtDW.dbgCAN_dbg_Act2_model;
+
+  /* Outport: '<Root>/CCU_Stat1_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read6'
+   */
+  rtY.CCU_Stat1_model = rtDW.CCU_STAT1_MODEL;
+
+  /* Outport: '<Root>/dbgCAN_dbg_Sen_Duct_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read8'
+   */
+  rtY.dbgCAN_dbg_Sen_Duct_model = rtDW.dbgCAN_dbg_Sen_Duct_model;
+
+  /* Outport: '<Root>/dbgCAN_dbg_Sen_Eva_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read9'
+   */
+  rtY.dbgCAN_dbg_Sen_Eva_model = rtDW.dbgCAN_dbg_Sen_Eva_model;
+
+  /* Outport: '<Root>/dbgCAN_dbg_Logic_Blower_model' incorporates:
+   *  DataStoreRead: '<Root>/Data Store Read13'
+   */
+  rtY.dbgCAN_dbg_Logic_Blower_model = rtDW.dbgCAN_dbg_Logic_Blower_model;
+
+  /* Outputs for Enabled SubSystem: '<Root>/PWM and valves in manual1' incorporates:
+   *  EnablePort: '<S6>/Enable'
+   */
+  /* Logic: '<Root>/Logical Operator1' incorporates:
+   *  Constant: '<Root>/Constant2'
+   *  Constant: '<Root>/Constant3'
+   *  DataStoreRead: '<Root>/Data Store Read11'
+   *  DataStoreRead: '<Root>/Data Store Read12'
+   *  RelationalOperator: '<Root>/Equal2'
+   *  RelationalOperator: '<Root>/Equal3'
+   */
+  if ((rtDW.FIU_MODE_FL == 1) && (rtDW.FIU_MODE_FR == 1)) {
+    /* MATLAB Function: '<S737>/Valves for Def' */
+    ValvesforDef(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S737>/Valves for Vent mode' */
+    ValvesforVentmode(0U, &rtb_out_jn);
+
+    /* MATLAB Function: '<S737>/Valves for Hi_Level' */
+    ValvesforHi_Level(0U, &rtb_out_pd);
+
+    /* MATLAB Function: '<S737>/Valves for Foot' */
+    ValvesforFoot(0U, &rtb_out_b5);
+
+    /* MATLAB Function: '<S737>/Valves for Foot + Def' */
+    ValvesforFootDef(0U, &rtb_out_iir);
+
+    /* MATLAB Function: '<S737>/Valves for Bi Level' */
+    ValvesforBiLevel(0U, &rtb_out_e0);
+
+    /* MATLAB Function: '<S737>/Valves for Tri-Level' */
+    ValvesforTriLevel(0U, &rtb_out_bko);
+
+    /* MultiPortSwitch: '<S737>/Multiport Switch' incorporates:
+     *  Constant: '<S737>/Constant'
+     *  Constant: '<S737>/Constant1'
+     *  Constant: '<S737>/Constant2'
+     *  DataStoreRead: '<S6>/Data Store Read10'
+     *  DataStoreRead: '<S6>/Data Store Read4'
+     *  DataStoreRead: '<S6>/Data Store Read5'
+     *  Gain: '<S737>/Gain1'
+     *  Gain: '<S737>/Gain2'
+     *  RelationalOperator: '<S737>/Relational Operator'
+     *  RelationalOperator: '<S737>/Relational Operator1'
+     *  RelationalOperator: '<S737>/Relational Operator2'
+     *  Sum: '<S737>/Add'
+     */
+    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FL == 1) << 1) + (uint32_t)
+                       (rtDW.FIU_DEF_FL == 1)) + (uint32_t)((rtDW.FIU_FOOT_FL ==
+               1) << 2))) {
+     case 0:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = 0U;
+      }
+      break;
+
+     case 1:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_oc;
+      }
+      break;
+
+     case 2:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_jn;
+      }
+      break;
+
+     case 3:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_pd;
+      }
+      break;
+
+     case 4:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_b5;
+      }
+      break;
+
+     case 5:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_iir;
+      }
+      break;
+
+     case 6:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_e0;
+      }
+      break;
+
+     default:
+      for (i = 0; i < 9; i++) {
+        /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+         *  DataStoreWrite: '<S709>/Data Store Write'
+         */
+        rtDW.valves_front_manual_target[i] = rtb_out_bko;
+      }
+      break;
+    }
+
+    /* End of MultiPortSwitch: '<S737>/Multiport Switch' */
+
+    /* MATLAB Function: '<S738>/Valves for Def' */
+    ValvesforDef(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S738>/Valves for Vent mode' */
+    ValvesforVentmode(0U, &rtb_out_jn);
+
+    /* MATLAB Function: '<S738>/Valves for Hi_Level' */
+    ValvesforHi_Level(0U, &rtb_out_pd);
+
+    /* MATLAB Function: '<S738>/Valves for Foot' */
+    ValvesforFoot(0U, &rtb_out_b5);
+
+    /* MATLAB Function: '<S738>/Valves for Foot + Def' */
+    ValvesforFootDef(0U, &rtb_out_iir);
+
+    /* MATLAB Function: '<S738>/Valves for Bi Level' */
+    ValvesforBiLevel(0U, &rtb_out_e0);
+
+    /* MATLAB Function: '<S738>/Valves for Tri-Level' */
+    ValvesforTriLevel(0U, &rtb_out_bko);
+
+    /* MultiPortSwitch: '<S738>/Multiport Switch' incorporates:
+     *  Constant: '<S738>/Constant'
+     *  Constant: '<S738>/Constant1'
+     *  Constant: '<S738>/Constant2'
+     *  DataStoreRead: '<S6>/Data Store Read1'
+     *  DataStoreRead: '<S6>/Data Store Read2'
+     *  DataStoreRead: '<S6>/Data Store Read3'
+     *  Gain: '<S738>/Gain1'
+     *  Gain: '<S738>/Gain2'
+     *  RelationalOperator: '<S738>/Relational Operator'
+     *  RelationalOperator: '<S738>/Relational Operator1'
+     *  RelationalOperator: '<S738>/Relational Operator2'
+     *  Sum: '<S738>/Add'
+     */
+    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FR == 1) << 1) + (uint32_t)
+                       (rtDW.FIU_DEF_FR == 1)) + (uint32_t)((rtDW.FIU_FOOT_FR ==
+               1) << 2))) {
+     case 0:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = 0U;
+      }
+      break;
+
+     case 1:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_oc;
+      }
+      break;
+
+     case 2:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_jn;
+      }
+      break;
+
+     case 3:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_pd;
+      }
+      break;
+
+     case 4:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_b5;
+      }
+      break;
+
+     case 5:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_iir;
+      }
+      break;
+
+     case 6:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_e0;
+      }
+      break;
+
+     default:
+      for (i = 0; i < 9; i++) {
+        rtb_vals_m[i] = rtb_out_bko;
+      }
+      break;
+    }
+
+    /* End of MultiPortSwitch: '<S738>/Multiport Switch' */
+
+    /* Assignment: '<S709>/Присваивание в [3-4]' incorporates:
+     *  Assignment: '<S709>/Присваивание в [7-8]'
+     *  DataStoreWrite: '<S709>/Data Store Write'
+     */
+    rtDW.valves_front_manual_target[2] = rtb_vals_m[2];
+
+    /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+     *  DataStoreWrite: '<S709>/Data Store Write'
+     */
+    rtDW.valves_front_manual_target[6] = rtb_vals_m[6];
+
+    /* Assignment: '<S709>/Присваивание в [3-4]' incorporates:
+     *  Assignment: '<S709>/Присваивание в [7-8]'
+     *  DataStoreWrite: '<S709>/Data Store Write'
+     */
+    rtDW.valves_front_manual_target[3] = rtb_vals_m[3];
+
+    /* Assignment: '<S709>/Присваивание в [7-8]' incorporates:
+     *  DataStoreWrite: '<S709>/Data Store Write'
+     */
+    rtDW.valves_front_manual_target[7] = rtb_vals_m[7];
+
+    /* MATLAB Function: '<S739>/valves for Vent mode' */
+    valvesforVentmode(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S739>/AF for Foot' */
+    AFforFoot_p(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S739>/AF for Bi Level' */
+    AFforBiLevel_m(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S740>/valves for Vent mode' */
+    valvesforVentmode(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S740>/AF for Foot' */
+    AFforFoot_p(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S740>/AF for Bi Level' */
+    AFforBiLevel_m(0U, &rtb_out_oc);
+
+    /* MATLAB Function: '<S710>/AF for Vent mode' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforVentmode(rtDW.FIU_BLOWERS_FL, &rtb_out_oc);
+
+    /* MATLAB Function: '<S710>/AF for Bi Level' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforBiLevel(rtDW.FIU_BLOWERS_FL, &rtb_out_jn);
+
+    /* MATLAB Function: '<S710>/AF for Foot' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforFoot(rtDW.FIU_BLOWERS_FL, &rtb_out_pd);
+
+    /* MATLAB Function: '<S710>/AF for Foor + Def' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforFoorDef(rtDW.FIU_BLOWERS_FL, &rtb_out_b5);
+
+    /* MATLAB Function: '<S710>/AF for Def' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforDef(rtDW.FIU_BLOWERS_FL, &rtb_out_iir);
+
+    /* MATLAB Function: '<S710>/AF for Hi_Level' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforHi_Level(rtDW.FIU_BLOWERS_FL, &rtb_out_e0);
+
+    /* MultiPortSwitch: '<S710>/Multiport Switch' incorporates:
+     *  Constant: '<S710>/Constant'
+     *  Constant: '<S710>/Constant1'
+     *  Constant: '<S710>/Constant2'
+     *  Constant: '<S710>/Constant3'
+     *  DataStoreRead: '<S6>/Data Store Read6'
+     *  DataStoreRead: '<S6>/Data Store Read8'
+     *  DataStoreRead: '<S6>/Data Store Read9'
+     *  Gain: '<S710>/Gain1'
+     *  Gain: '<S710>/Gain2'
+     *  RelationalOperator: '<S710>/Relational Operator'
+     *  RelationalOperator: '<S710>/Relational Operator1'
+     *  RelationalOperator: '<S710>/Relational Operator2'
+     *  Sum: '<S710>/Add'
+     */
+    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FL == 1) << 1) + (uint32_t)
+                       (rtDW.FIU_DEF_FL == 1)) + (uint32_t)((rtDW.FIU_FOOT_FL ==
+               1) << 2))) {
+     case 0:
+      rtb_out_oc = 0U;
+      break;
+
+     case 1:
+      break;
+
+     case 2:
+      rtb_out_oc = rtb_out_jn;
+      break;
+
+     case 3:
+      rtb_out_oc = rtb_out_pd;
+      break;
+
+     case 4:
+      rtb_out_oc = rtb_out_b5;
+      break;
+
+     case 5:
+      rtb_out_oc = rtb_out_iir;
+      break;
+
+     case 6:
+      rtb_out_oc = rtb_out_e0;
+      break;
+
+     default:
+      rtb_out_oc = 0U;
+      break;
+    }
+
+    /* End of MultiPortSwitch: '<S710>/Multiport Switch' */
+
+    /* MATLAB Function: '<S711>/AF for Vent mode' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforVentmode(rtDW.FIU_BLOWERS_FR, &rtb_out_pd);
+
+    /* MATLAB Function: '<S711>/AF for Bi Level' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforBiLevel(rtDW.FIU_BLOWERS_FR, &rtb_out_b5);
+
+    /* MATLAB Function: '<S711>/AF for Foot' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforFoot(rtDW.FIU_BLOWERS_FR, &rtb_out_iir);
+
+    /* MATLAB Function: '<S711>/AF for Foor + Def' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforFoorDef(rtDW.FIU_BLOWERS_FR, &rtb_out_e0);
+
+    /* MATLAB Function: '<S711>/AF for Def' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforDef(rtDW.FIU_BLOWERS_FR, &rtb_out_bko);
+
+    /* MATLAB Function: '<S711>/AF for Hi_Level' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforHi_Level(rtDW.FIU_BLOWERS_FR, &rtb_out_h);
+
+    /* MATLAB Function: '<S711>/AF for Tri-Level' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read7'
+     */
+    AFforTriLevel(rtDW.FIU_BLOWERS_FR, &rtb_out_jn);
+
+    /* MultiPortSwitch: '<S711>/Multiport Switch' incorporates:
+     *  Constant: '<S711>/Constant'
+     *  Constant: '<S711>/Constant1'
+     *  Constant: '<S711>/Constant2'
+     *  Constant: '<S711>/Constant3'
+     *  DataStoreRead: '<S6>/Data Store Read12'
+     *  DataStoreRead: '<S6>/Data Store Read13'
+     *  DataStoreRead: '<S6>/Data Store Read14'
+     *  Gain: '<S711>/Gain1'
+     *  Gain: '<S711>/Gain2'
+     *  RelationalOperator: '<S711>/Relational Operator'
+     *  RelationalOperator: '<S711>/Relational Operator1'
+     *  RelationalOperator: '<S711>/Relational Operator2'
+     *  Sum: '<S711>/Add'
+     */
+    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FR == 1) << 1) + (uint32_t)
+                       (rtDW.FIU_DEF_FR == 1)) + (uint32_t)((rtDW.FIU_FOOT_FR ==
+               1) << 2))) {
+     case 0:
+      rtb_out_jn = 0U;
+      break;
+
+     case 1:
+      rtb_out_jn = rtb_out_pd;
+      break;
+
+     case 2:
+      rtb_out_jn = rtb_out_b5;
+      break;
+
+     case 3:
+      rtb_out_jn = rtb_out_iir;
+      break;
+
+     case 4:
+      rtb_out_jn = rtb_out_e0;
+      break;
+
+     case 5:
+      rtb_out_jn = rtb_out_bko;
+      break;
+
+     case 6:
+      rtb_out_jn = rtb_out_h;
+      break;
+    }
+
+    /* End of MultiPortSwitch: '<S711>/Multiport Switch' */
+
+    /* DataTypeConversion: '<S708>/Data Type Conversion1' incorporates:
+     *  Constant: '<S708>/Constant'
+     *  DataStoreWrite: '<S708>/Data Store Write'
+     *  Product: '<S708>/Divide'
+     *  Sum: '<S708>/Add'
+     */
+    rtDW.PWM_front = (uint8_t)((double)(uint16_t)((uint32_t)rtb_out_oc +
+      rtb_out_jn) / 4.0);
+
+    /* DataTypeConversion: '<S708>/Data Type Conversion3' incorporates:
+     *  DataStoreWrite: '<S708>/Data Store Write2'
+     */
+    rtDW.Blower_AF_FL = (uint8_t)rtb_out_oc;
+
+    /* DataTypeConversion: '<S708>/Data Type Conversion2' incorporates:
+     *  DataStoreWrite: '<S708>/Data Store Write3'
+     */
+    rtDW.Blower_AF_FR = (uint8_t)rtb_out_jn;
+
+    /* MATLAB Function: '<S712>/AF for Vent mode R' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read18'
+     */
+    AFforVentmodeR(rtDW.FIU_FACE_RL, &rtb_out_jn);
+
+    /* MATLAB Function: '<S712>/AF for Bi Level R' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read18'
+     */
+    AFforBiLevelR(rtDW.FIU_FACE_RL, &rtb_out_pd);
+
+    /* MATLAB Function: '<S712>/AF for Foot R' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read18'
+     */
+    AFforFootR(rtDW.FIU_FACE_RL, &rtb_out_oc);
+
+    /* MultiPortSwitch: '<S712>/Multiport Switch' incorporates:
+     *  Constant: '<S712>/Constant1'
+     *  Constant: '<S712>/Constant2'
+     *  Constant: '<S712>/Constant3'
+     *  DataStoreRead: '<S6>/Data Store Read19'
+     *  DataStoreRead: '<S6>/Data Store Read20'
+     *  Gain: '<S712>/Gain2'
+     *  RelationalOperator: '<S712>/Relational Operator1'
+     *  RelationalOperator: '<S712>/Relational Operator2'
+     *  Sum: '<S712>/Add'
+     */
+    switch ((int32_t)((uint32_t)((rtDW.FIU_BLOWERS_RL == 1) << 1) + (uint32_t)
+                      (rtDW.FIU_FOOT_RL == 1))) {
+     case 0:
+      rtb_out_oc = 0U;
+      break;
+
+     case 1:
+      rtb_out_oc = rtb_out_jn;
+      break;
+
+     case 2:
+      rtb_out_oc = rtb_out_pd;
+      break;
+    }
+
+    /* End of MultiPortSwitch: '<S712>/Multiport Switch' */
+
+    /* MATLAB Function: '<S713>/AF for Vent mode R' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read15'
+     */
+    AFforVentmodeR(rtDW.FIU_BLOWERS_RR, &rtb_out_pd);
+
+    /* MATLAB Function: '<S713>/AF for Bi Level R' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read15'
+     */
+    AFforBiLevelR(rtDW.FIU_BLOWERS_RR, &rtb_out_b5);
+
+    /* MATLAB Function: '<S713>/AF for Foot R' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read15'
+     */
+    AFforFootR(rtDW.FIU_BLOWERS_RR, &rtb_out_jn);
+
+    /* MultiPortSwitch: '<S713>/Multiport Switch' incorporates:
+     *  Constant: '<S713>/Constant1'
+     *  Constant: '<S713>/Constant2'
+     *  Constant: '<S713>/Constant3'
+     *  DataStoreRead: '<S6>/Data Store Read16'
+     *  DataStoreRead: '<S6>/Data Store Read17'
+     *  Gain: '<S713>/Gain2'
+     *  RelationalOperator: '<S713>/Relational Operator1'
+     *  RelationalOperator: '<S713>/Relational Operator2'
+     *  Sum: '<S713>/Add'
+     */
+    switch ((int32_t)((uint32_t)((rtDW.FIU_FOOT_RR == 1) << 1) + (uint32_t)
+                      (rtDW.FIU_FACE_RR == 1))) {
+     case 0:
+      rtb_out_jn = 0U;
+      break;
+
+     case 1:
+      rtb_out_jn = rtb_out_pd;
+      break;
+
+     case 2:
+      rtb_out_jn = rtb_out_b5;
+      break;
+    }
+
+    /* End of MultiPortSwitch: '<S713>/Multiport Switch' */
+
+    /* DataTypeConversion: '<S708>/Data Type Conversion' incorporates:
+     *  Constant: '<S708>/Constant1'
+     *  DataStoreWrite: '<S708>/Data Store Write1'
+     *  Product: '<S708>/Divide1'
+     *  Sum: '<S708>/Add1'
+     */
+    rtDW.PWM_rear = (uint8_t)((double)(uint16_t)((uint32_t)rtb_out_oc +
+      rtb_out_jn) / 4.0);
+
+    /* DataTypeConversion: '<S708>/Data Type Conversion4' incorporates:
+     *  DataStoreWrite: '<S708>/Data Store Write4'
+     */
+    rtDW.Blower_AF_RL = (uint8_t)rtb_out_oc;
+
+    /* DataTypeConversion: '<S708>/Data Type Conversion5' incorporates:
+     *  DataStoreWrite: '<S708>/Data Store Write5'
+     */
+    rtDW.Blower_AF_RR = (uint8_t)rtb_out_jn;
+
+    /* MATLAB Function: '<S708>/Write' incorporates:
+     *  DataStoreWrite: '<S708>/Data Store Write'
+     */
+    /* :  fprintf('pwmFront_output = %u \n',data); */
+    printf("pwmFront_output = %u \n", rtDW.PWM_front);
+    fflush(stdout);
+
+    /* MATLAB Function: '<S708>/Write2' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    /* :  fprintf('speedL_input = %u \n',data); */
+    printf("speedL_input = %u \n", rtDW.FIU_BLOWERS_FL);
+    fflush(stdout);
+
+    /* MATLAB Function: '<S710>/AF for Tri-Level' incorporates:
+     *  DataStoreRead: '<S6>/Data Store Read11'
+     */
+    AFforTriLevel(rtDW.FIU_BLOWERS_FL, &rtb_out_oc);
+
+    /* MATLAB Function: '<S708>/Write1' incorporates:
+     *  DataStoreWrite: '<S708>/Data Store Write1'
+     */
+    /* :  fprintf('pwmRear_output = %u \n',data); */
+    printf("pwmRear_output = %u \n", rtDW.PWM_rear);
+    fflush(stdout);
+  }
+
+  /* End of Logic: '<Root>/Logical Operator1' */
+  /* End of Outputs for SubSystem: '<Root>/PWM and valves in manual1' */
 
   /* If: '<S8>/если SC front не завершен' incorporates:
    *  DataStoreRead: '<S8>/Data Store Read'
@@ -12795,1859 +13693,1859 @@ void HVAC_model_step(void)
   if ((rtDW.start_control_finished_front == 0) &&
       (rtDW.SKIPPED_FIRST_SIMULATION_STEP == 0.0)) {
     /* Outputs for IfAction SubSystem: '<S8>/If Action Subsystem' incorporates:
-     *  ActionPort: '<S719>/Action Port'
+     *  ActionPort: '<S765>/Action Port'
      */
-    /* DataStoreWrite: '<S719>/Data Store Write' incorporates:
-     *  Constant: '<S719>/Constant'
+    /* DataStoreWrite: '<S765>/Data Store Write' incorporates:
+     *  Constant: '<S765>/Constant'
      */
     rtDW.SKIPPED_FIRST_SIMULATION_STEP = 1.0;
 
     /* End of Outputs for SubSystem: '<S8>/If Action Subsystem' */
   } else if (rtDW.start_control_finished_front == 0) {
     /* Outputs for IfAction SubSystem: '<S8>/Start Control Front' incorporates:
-     *  ActionPort: '<S720>/Action Port'
+     *  ActionPort: '<S766>/Action Port'
      */
-    /* SwitchCase: '<S720>/Switch Case' incorporates:
-     *  DataStoreRead: '<S720>/Data Store Read'
+    /* SwitchCase: '<S766>/Switch Case' incorporates:
+     *  DataStoreRead: '<S766>/Data Store Read'
      */
     switch (rtDW.step_start_controle_front) {
      case -1:
-      /* Outputs for IfAction SubSystem: '<S720>/Step -1 F (Entry Condition)' incorporates:
-       *  ActionPort: '<S722>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S766>/Step -1 F (Entry Condition)' incorporates:
+       *  ActionPort: '<S768>/Action Port'
        */
-      /* SwitchCase: '<S722>/Switch Case' incorporates:
+      /* SwitchCase: '<S768>/Switch Case' incorporates:
        *  DataStoreWrite: '<S10>/Data Store Write'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S722>/Level 0' incorporates:
-         *  ActionPort: '<S727>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S768>/Level 0' incorporates:
+         *  ActionPort: '<S773>/Action Port'
          */
-        /* MATLAB Function: '<S727>/g_assSTART_ENTER_INCAR' */
+        /* MATLAB Function: '<S773>/g_assSTART_ENTER_INCAR' */
         g_assSTART_ENTER_INCAR_j(rtB.Merge_b, &Eva_F);
 
-        /* MATLAB Function: '<S727>/g_ausSTART_ENTER_SETTEMP' */
+        /* MATLAB Function: '<S773>/g_ausSTART_ENTER_SETTEMP' */
         /* :  out = g_ausSTART_ENTER_SETTEMP(LVL+1); */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        /* Switch: '<S727>/Switch' incorporates:
-         *  Constant: '<S727>/AUTO'
-         *  DataStoreRead: '<S727>/Data Store Read'
-         *  DataStoreRead: '<S727>/Data Store Read1'
-         *  DataStoreRead: '<S727>/Data Store Read2'
-         *  Logic: '<S727>/AND'
-         *  MATLAB Function: '<S727>/g_ausSTART_ENTER_SETTEMP'
-         *  RelationalOperator: '<S727>/Relational Operator'
-         *  RelationalOperator: '<S727>/Relational Operator1'
-         *  RelationalOperator: '<S727>/Relational Operator2'
+        /* Switch: '<S773>/Switch' incorporates:
+         *  Constant: '<S773>/AUTO'
+         *  DataStoreRead: '<S773>/Data Store Read'
+         *  DataStoreRead: '<S773>/Data Store Read1'
+         *  DataStoreRead: '<S773>/Data Store Read2'
+         *  Logic: '<S773>/AND'
+         *  MATLAB Function: '<S773>/g_ausSTART_ENTER_SETTEMP'
+         *  RelationalOperator: '<S773>/Relational Operator'
+         *  RelationalOperator: '<S773>/Relational Operator1'
+         *  RelationalOperator: '<S773>/Relational Operator2'
          */
         if ((Incar_FL > Eva_F) && (rtDW.MODE_DRIVER == 1.0) && (rtDW.FIU_SET_FL <
-             g_ausSTART_ENTER_SETTEMP[q0 - 1])) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S727>/Constant1'
+             g_ausSTART_ENTER_SETTEMP[y - 1])) {
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S773>/Constant1'
            */
           rtB.Merge_ho = 0;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S727>/Constant'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S773>/Constant'
            */
           rtB.Merge_ho = -1;
         }
 
-        /* End of Switch: '<S727>/Switch' */
-        /* End of Outputs for SubSystem: '<S722>/Level 0' */
+        /* End of Switch: '<S773>/Switch' */
+        /* End of Outputs for SubSystem: '<S768>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S722>/Level 1' incorporates:
-         *  ActionPort: '<S728>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S768>/Level 1' incorporates:
+         *  ActionPort: '<S774>/Action Port'
          */
-        /* MATLAB Function: '<S728>/g_assSTART_ENTER_INCAR' */
+        /* MATLAB Function: '<S774>/g_assSTART_ENTER_INCAR' */
         g_assSTART_ENTER_INCAR_j(rtB.Merge_b, &Eva_F);
 
-        /* MATLAB Function: '<S728>/g_ausSTART_ENTER_SETTEMP' */
+        /* MATLAB Function: '<S774>/g_ausSTART_ENTER_SETTEMP' */
         /* :  out = int16(g_ausSTART_ENTER_SETTEMP(LVL+1)); */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        rtb_out_ee = g_ausSTART_ENTER_SETTEMP[q0 - 1];
-        if (rtb_out_ee > 32767) {
-          rtb_out_ee = 32767U;
+        rtb_out_oc = g_ausSTART_ENTER_SETTEMP[y - 1];
+        if (rtb_out_oc > 32767) {
+          rtb_out_oc = 32767U;
         }
 
-        /* Switch: '<S728>/Switch' incorporates:
-         *  Constant: '<S728>/AUTO'
-         *  DataStoreRead: '<S728>/Data Store Read'
-         *  DataStoreRead: '<S728>/Data Store Read1'
-         *  DataStoreRead: '<S728>/Data Store Read2'
-         *  Logic: '<S728>/AND'
-         *  MATLAB Function: '<S728>/g_ausSTART_ENTER_SETTEMP'
-         *  RelationalOperator: '<S728>/Relational Operator'
-         *  RelationalOperator: '<S728>/Relational Operator1'
-         *  RelationalOperator: '<S728>/Relational Operator2'
+        /* Switch: '<S774>/Switch' incorporates:
+         *  Constant: '<S774>/AUTO'
+         *  DataStoreRead: '<S774>/Data Store Read'
+         *  DataStoreRead: '<S774>/Data Store Read1'
+         *  DataStoreRead: '<S774>/Data Store Read2'
+         *  Logic: '<S774>/AND'
+         *  MATLAB Function: '<S774>/g_ausSTART_ENTER_SETTEMP'
+         *  RelationalOperator: '<S774>/Relational Operator'
+         *  RelationalOperator: '<S774>/Relational Operator1'
+         *  RelationalOperator: '<S774>/Relational Operator2'
          */
         if ((Incar_FL > Eva_F) && (rtDW.MODE_DRIVER == 1.0) && (rtDW.FIU_SET_FL <
-             rtb_out_ee)) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S728>/Constant1'
+             rtb_out_oc)) {
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S774>/Constant1'
            */
           rtB.Merge_ho = 0;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S728>/Constant'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S774>/Constant'
            */
           rtB.Merge_ho = -1;
         }
 
-        /* End of Switch: '<S728>/Switch' */
-        /* End of Outputs for SubSystem: '<S722>/Level 1' */
+        /* End of Switch: '<S774>/Switch' */
+        /* End of Outputs for SubSystem: '<S768>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S722>/Level 2' incorporates:
-         *  ActionPort: '<S729>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S768>/Level 2' incorporates:
+         *  ActionPort: '<S775>/Action Port'
          */
-        /* Merge: '<S720>/Merge' incorporates:
-         *  Constant: '<S729>/Constant'
-         *  SignalConversion generated from: '<S729>/step'
+        /* Merge: '<S766>/Merge' incorporates:
+         *  Constant: '<S775>/Constant'
+         *  SignalConversion generated from: '<S775>/step'
          */
         rtB.Merge_ho = 0;
 
-        /* End of Outputs for SubSystem: '<S722>/Level 2' */
+        /* End of Outputs for SubSystem: '<S768>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S722>/Level 3' incorporates:
-         *  ActionPort: '<S730>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S768>/Level 3' incorporates:
+         *  ActionPort: '<S776>/Action Port'
          */
-        /* MATLAB Function: '<S730>/g_assSTART_ENTER_COOLANT ' */
+        /* MATLAB Function: '<S776>/g_assSTART_ENTER_COOLANT ' */
         g_assSTART_ENTER_COOLANT_p(rtB.Merge_b, &Incar_FL);
 
-        /* Switch: '<S730>/Switch' incorporates:
-         *  Constant: '<S730>/AUTO'
-         *  DataStoreRead: '<S730>/Data Store Read'
-         *  DataStoreRead: '<S730>/Data Store Read1'
-         *  Logic: '<S730>/AND'
-         *  RelationalOperator: '<S730>/Relational Operator'
-         *  RelationalOperator: '<S730>/Relational Operator2'
+        /* Switch: '<S776>/Switch' incorporates:
+         *  Constant: '<S776>/AUTO'
+         *  DataStoreRead: '<S776>/Data Store Read'
+         *  DataStoreRead: '<S776>/Data Store Read1'
+         *  Logic: '<S776>/AND'
+         *  RelationalOperator: '<S776>/Relational Operator'
+         *  RelationalOperator: '<S776>/Relational Operator2'
          */
         if ((rtDW.ECT < Incar_FL) && (rtDW.MODE_DRIVER == 1.0)) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S730>/Constant1'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S776>/Constant1'
            */
           rtB.Merge_ho = 0;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S730>/Constant'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S776>/Constant'
            */
           rtB.Merge_ho = -1;
         }
 
-        /* End of Switch: '<S730>/Switch' */
-        /* End of Outputs for SubSystem: '<S722>/Level 3' */
+        /* End of Switch: '<S776>/Switch' */
+        /* End of Outputs for SubSystem: '<S768>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S722>/Level 4' incorporates:
-         *  ActionPort: '<S731>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S768>/Level 4' incorporates:
+         *  ActionPort: '<S777>/Action Port'
          */
         Level4(&rtB.Merge_ho, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);
 
-        /* End of Outputs for SubSystem: '<S722>/Level 4' */
+        /* End of Outputs for SubSystem: '<S768>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S722>/Level 5' incorporates:
-         *  ActionPort: '<S732>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S768>/Level 5' incorporates:
+         *  ActionPort: '<S778>/Action Port'
          */
         Level4(&rtB.Merge_ho, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);
 
-        /* End of Outputs for SubSystem: '<S722>/Level 5' */
+        /* End of Outputs for SubSystem: '<S768>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S722>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S720>/Step -1 F (Entry Condition)' */
+      /* End of SwitchCase: '<S768>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S766>/Step -1 F (Entry Condition)' */
       break;
 
      case 0:
-      /* Outputs for IfAction SubSystem: '<S720>/Step 0 F' incorporates:
-       *  ActionPort: '<S723>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S766>/Step 0 F' incorporates:
+       *  ActionPort: '<S769>/Action Port'
        */
-      /* SwitchCase: '<S723>/Switch Case' incorporates:
+      /* SwitchCase: '<S769>/Switch Case' incorporates:
        *  DataStoreWrite: '<S10>/Data Store Write'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S723>/Level 0' incorporates:
-         *  ActionPort: '<S740>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S769>/Level 0' incorporates:
+         *  ActionPort: '<S786>/Action Port'
          */
         Level0(&rtB.Merge_ho);
 
-        /* End of Outputs for SubSystem: '<S723>/Level 0' */
+        /* End of Outputs for SubSystem: '<S769>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S723>/Level 1' incorporates:
-         *  ActionPort: '<S741>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S769>/Level 1' incorporates:
+         *  ActionPort: '<S787>/Action Port'
          */
         Level0(&rtB.Merge_ho);
 
-        /* End of Outputs for SubSystem: '<S723>/Level 1' */
+        /* End of Outputs for SubSystem: '<S769>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S723>/Level 2' incorporates:
-         *  ActionPort: '<S742>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S769>/Level 2' incorporates:
+         *  ActionPort: '<S788>/Action Port'
          */
         Level0(&rtB.Merge_ho);
 
-        /* End of Outputs for SubSystem: '<S723>/Level 2' */
+        /* End of Outputs for SubSystem: '<S769>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S723>/Level 3' incorporates:
-         *  ActionPort: '<S743>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S769>/Level 3' incorporates:
+         *  ActionPort: '<S789>/Action Port'
          */
-        /* DataStoreWrite: '<S743>/Data Store Write6' incorporates:
-         *  Constant: '<S743>/Constant3'
+        /* DataStoreWrite: '<S789>/Data Store Write6' incorporates:
+         *  Constant: '<S789>/Constant3'
          */
         rtDW.Blower_FL = 20U;
 
-        /* DataStoreWrite: '<S743>/Data Store Write11' incorporates:
-         *  Constant: '<S743>/Constant5'
+        /* DataStoreWrite: '<S789>/Data Store Write11' incorporates:
+         *  Constant: '<S789>/Constant5'
          */
         rtDW.Dtg_FUL = 60U;
 
-        /* DataStoreWrite: '<S743>/Data Store Write13' incorporates:
-         *  Constant: '<S743>/Constant7'
+        /* DataStoreWrite: '<S789>/Data Store Write13' incorporates:
+         *  Constant: '<S789>/Constant7'
          */
         rtDW.Dtg_FLL = 80U;
 
-        /* DataStoreWrite: '<S743>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S743>/incar filter up'
+        /* DataStoreWrite: '<S789>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S789>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S743>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S743>/incar filter down'
+        /* DataStoreWrite: '<S789>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S789>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* DataStoreWrite: '<S743>/Data Store Write3' incorporates:
-         *  Constant: '<S743>/Mode - def'
+        /* DataStoreWrite: '<S789>/Data Store Write3' incorporates:
+         *  Constant: '<S789>/Mode - def'
          */
         rtDW.Mode_FL = 80U;
 
-        /* DataStoreWrite: '<S743>/Data Store Write7' incorporates:
-         *  Constant: '<S743>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S789>/Data Store Write7' incorporates:
+         *  Constant: '<S789>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* DataStoreWrite: '<S743>/Data Store Write8' incorporates:
-         *  Constant: '<S743>/Valve open'
+        /* DataStoreWrite: '<S789>/Data Store Write8' incorporates:
+         *  Constant: '<S789>/Valve open'
          */
         rtb_u_cuz = 1U;
 
-        /* DataStoreWrite: '<S743>/Data Store Write9' incorporates:
-         *  Constant: '<S743>/Valve open'
+        /* DataStoreWrite: '<S789>/Data Store Write9' incorporates:
+         *  Constant: '<S789>/Valve open'
          */
         Valve_2_way = 1U;
 
-        /* MATLAB Function: '<S743>/g_assSTART_COOLANT_STEP0_TO_1 ' */
+        /* MATLAB Function: '<S789>/g_assSTART_COOLANT_STEP0_TO_1 ' */
         /* :  out = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 1 - 2)); */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        rtb_dt_fa = (uint32_t)q0 - 2U;
-        if ((uint32_t)q0 - 2U > (uint32_t)q0) {
+        rtb_dt_fa = (uint32_t)y - 2U;
+        if ((uint32_t)y - 2U > (uint32_t)y) {
           rtb_dt_fa = 0U;
         }
 
-        /* Merge: '<S720>/Merge' incorporates:
-         *  DataStoreRead: '<S743>/Engine coolant temp'
-         *  MATLAB Function: '<S743>/g_assSTART_COOLANT_STEP0_TO_1 '
-         *  RelationalOperator: '<S743>/Relational Operator'
-         *  Switch: '<S743>/Switch'
+        /* Merge: '<S766>/Merge' incorporates:
+         *  DataStoreRead: '<S789>/Engine coolant temp'
+         *  MATLAB Function: '<S789>/g_assSTART_COOLANT_STEP0_TO_1 '
+         *  RelationalOperator: '<S789>/Relational Operator'
+         *  Switch: '<S789>/Switch'
          */
         rtB.Merge_ho = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1
           [(int32_t)rtb_dt_fa - 1]);
 
-        /* End of Outputs for SubSystem: '<S723>/Level 3' */
+        /* End of Outputs for SubSystem: '<S769>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S723>/Level 4' incorporates:
-         *  ActionPort: '<S744>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S769>/Level 4' incorporates:
+         *  ActionPort: '<S790>/Action Port'
          */
-        /* DataStoreWrite: '<S744>/Data Store Write6' incorporates:
-         *  Constant: '<S744>/Constant3'
+        /* DataStoreWrite: '<S790>/Data Store Write6' incorporates:
+         *  Constant: '<S790>/Constant3'
          */
         rtDW.Blower_FL = 20U;
 
-        /* DataStoreWrite: '<S744>/Data Store Write11' incorporates:
-         *  Constant: '<S744>/Constant5'
+        /* DataStoreWrite: '<S790>/Data Store Write11' incorporates:
+         *  Constant: '<S790>/Constant5'
          */
         rtDW.Dtg_FUL = 60U;
 
-        /* DataStoreWrite: '<S744>/Data Store Write13' incorporates:
-         *  Constant: '<S744>/Constant7'
+        /* DataStoreWrite: '<S790>/Data Store Write13' incorporates:
+         *  Constant: '<S790>/Constant7'
          */
         rtDW.Dtg_FLL = 80U;
 
-        /* DataStoreWrite: '<S744>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S744>/incar filter up'
+        /* DataStoreWrite: '<S790>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S790>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S744>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S744>/incar filter down'
+        /* DataStoreWrite: '<S790>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S790>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* DataStoreWrite: '<S744>/Data Store Write3' incorporates:
-         *  Constant: '<S744>/Mode - def'
+        /* DataStoreWrite: '<S790>/Data Store Write3' incorporates:
+         *  Constant: '<S790>/Mode - def'
          */
         rtDW.Mode_FL = 80U;
 
-        /* DataStoreWrite: '<S744>/Data Store Write7' incorporates:
-         *  Constant: '<S744>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S790>/Data Store Write7' incorporates:
+         *  Constant: '<S790>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* DataStoreWrite: '<S744>/Data Store Write8' incorporates:
-         *  Constant: '<S744>/Valve open'
+        /* DataStoreWrite: '<S790>/Data Store Write8' incorporates:
+         *  Constant: '<S790>/Valve open'
          */
         rtb_u_cuz = 1U;
 
-        /* DataStoreWrite: '<S744>/Data Store Write9' incorporates:
-         *  Constant: '<S744>/Valve open'
+        /* DataStoreWrite: '<S790>/Data Store Write9' incorporates:
+         *  Constant: '<S790>/Valve open'
          */
         Valve_2_way = 1U;
 
-        /* MATLAB Function: '<S744>/g_assSTART_COOLANT_STEP0_TO_1 ' */
+        /* MATLAB Function: '<S790>/g_assSTART_COOLANT_STEP0_TO_1 ' */
         g_assSTART_COOLANT_STEP0_TO_1_h(rtB.Merge_b, &Incar_FL);
 
-        /* Merge: '<S720>/Merge' incorporates:
-         *  DataStoreRead: '<S744>/Engine coolant temp'
-         *  RelationalOperator: '<S744>/Relational Operator'
-         *  Switch: '<S744>/Switch'
+        /* Merge: '<S766>/Merge' incorporates:
+         *  DataStoreRead: '<S790>/Engine coolant temp'
+         *  RelationalOperator: '<S790>/Relational Operator'
+         *  Switch: '<S790>/Switch'
          */
         rtB.Merge_ho = (int8_t)(rtDW.ECT > Incar_FL);
 
-        /* End of Outputs for SubSystem: '<S723>/Level 4' */
+        /* End of Outputs for SubSystem: '<S769>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S723>/Level 5' incorporates:
-         *  ActionPort: '<S745>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S769>/Level 5' incorporates:
+         *  ActionPort: '<S791>/Action Port'
          */
-        /* DataStoreWrite: '<S745>/Data Store Write6' incorporates:
-         *  Constant: '<S745>/Constant3'
+        /* DataStoreWrite: '<S791>/Data Store Write6' incorporates:
+         *  Constant: '<S791>/Constant3'
          */
         rtDW.Blower_FL = 20U;
 
-        /* DataStoreWrite: '<S745>/Data Store Write11' incorporates:
-         *  Constant: '<S745>/Constant5'
+        /* DataStoreWrite: '<S791>/Data Store Write11' incorporates:
+         *  Constant: '<S791>/Constant5'
          */
         rtDW.Dtg_FUL = 80U;
 
-        /* DataStoreWrite: '<S745>/Data Store Write13' incorporates:
-         *  Constant: '<S745>/Constant7'
+        /* DataStoreWrite: '<S791>/Data Store Write13' incorporates:
+         *  Constant: '<S791>/Constant7'
          */
         rtDW.Dtg_FLL = 80U;
 
-        /* DataStoreWrite: '<S745>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S745>/incar filter up'
+        /* DataStoreWrite: '<S791>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S791>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S745>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S745>/incar filter down'
+        /* DataStoreWrite: '<S791>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S791>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* DataStoreWrite: '<S745>/Data Store Write3' incorporates:
-         *  Constant: '<S745>/Mode - def'
+        /* DataStoreWrite: '<S791>/Data Store Write3' incorporates:
+         *  Constant: '<S791>/Mode - def'
          */
         rtDW.Mode_FL = 80U;
 
-        /* DataStoreWrite: '<S745>/Data Store Write7' incorporates:
-         *  Constant: '<S745>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S791>/Data Store Write7' incorporates:
+         *  Constant: '<S791>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* DataStoreWrite: '<S745>/Data Store Write8' incorporates:
-         *  Constant: '<S745>/Valve open'
+        /* DataStoreWrite: '<S791>/Data Store Write8' incorporates:
+         *  Constant: '<S791>/Valve open'
          */
         rtb_u_cuz = 1U;
 
-        /* DataStoreWrite: '<S745>/Data Store Write9' incorporates:
-         *  Constant: '<S745>/Valve open'
+        /* DataStoreWrite: '<S791>/Data Store Write9' incorporates:
+         *  Constant: '<S791>/Valve open'
          */
         Valve_2_way = 1U;
 
-        /* MATLAB Function: '<S745>/g_assSTART_COOLANT_STEP0_TO_1 ' */
+        /* MATLAB Function: '<S791>/g_assSTART_COOLANT_STEP0_TO_1 ' */
         g_assSTART_COOLANT_STEP0_TO_1_h(rtB.Merge_b, &Incar_FL);
 
-        /* Merge: '<S720>/Merge' incorporates:
-         *  DataStoreRead: '<S745>/Engine coolant temp'
-         *  RelationalOperator: '<S745>/Relational Operator'
-         *  Switch: '<S745>/Switch'
+        /* Merge: '<S766>/Merge' incorporates:
+         *  DataStoreRead: '<S791>/Engine coolant temp'
+         *  RelationalOperator: '<S791>/Relational Operator'
+         *  Switch: '<S791>/Switch'
          */
         rtB.Merge_ho = (int8_t)(rtDW.ECT > Incar_FL);
 
-        /* End of Outputs for SubSystem: '<S723>/Level 5' */
+        /* End of Outputs for SubSystem: '<S769>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S723>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S720>/Step 0 F' */
+      /* End of SwitchCase: '<S769>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S766>/Step 0 F' */
       break;
 
      case 1:
-      /* Outputs for IfAction SubSystem: '<S720>/Step 1 F' incorporates:
-       *  ActionPort: '<S724>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S766>/Step 1 F' incorporates:
+       *  ActionPort: '<S770>/Action Port'
        */
-      /* SwitchCase: '<S724>/Switch Case' incorporates:
+      /* SwitchCase: '<S770>/Switch Case' incorporates:
        *  DataStoreWrite: '<S10>/Data Store Write'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S724>/Level 0' incorporates:
-         *  ActionPort: '<S755>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S770>/Level 0' incorporates:
+         *  ActionPort: '<S801>/Action Port'
          */
-        /* DataStoreWrite: '<S755>/Data Store Write8' incorporates:
-         *  MATLAB Function: '<S755>/3 way valve status'
+        /* DataStoreWrite: '<S801>/Data Store Write8' incorporates:
+         *  MATLAB Function: '<S801>/3 way valve status'
          */
         uwayvalvestatus(rtB.Merge_b, &rtb_u_cuz);
 
-        /* DataStoreWrite: '<S755>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S755>/incar filter up'
+        /* DataStoreWrite: '<S801>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S801>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S755>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S755>/incar filter down'
+        /* DataStoreWrite: '<S801>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S801>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* DataStoreWrite: '<S755>/Data Store Write3' incorporates:
-         *  MATLAB Function: '<S755>/mode FR step 1'
+        /* DataStoreWrite: '<S801>/Data Store Write3' incorporates:
+         *  MATLAB Function: '<S801>/mode FR step 1'
          */
         modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);
 
-        /* DataStoreWrite: '<S755>/Data Store Write11' incorporates:
-         *  MATLAB Function: '<S755>/window heating'
+        /* DataStoreWrite: '<S801>/Data Store Write11' incorporates:
+         *  MATLAB Function: '<S801>/window heating'
          */
         windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);
 
-        /* DataStoreWrite: '<S755>/Data Store Write6' incorporates:
-         *  MATLAB Function: '<S755>/blower FR'
+        /* DataStoreWrite: '<S801>/Data Store Write6' incorporates:
+         *  MATLAB Function: '<S801>/blower FR'
          */
         blowerFR(rtB.Merge_b, &rtDW.Blower_FL);
 
-        /* DataStoreWrite: '<S755>/Data Store Write11' incorporates:
-         *  MATLAB Function: '<S755>/Dtg_FrontUpper_X'
+        /* DataStoreWrite: '<S801>/Data Store Write11' incorporates:
+         *  MATLAB Function: '<S801>/Dtg_FrontUpper_X'
          */
         Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);
 
-        /* DataStoreWrite: '<S755>/Data Store Write13' incorporates:
-         *  MATLAB Function: '<S755>/Dtg_FrontLower_X'
+        /* DataStoreWrite: '<S801>/Data Store Write13' incorporates:
+         *  MATLAB Function: '<S801>/Dtg_FrontLower_X'
          */
         Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);
 
-        /* DataStoreWrite: '<S755>/Data Store Write7' incorporates:
-         *  Constant: '<S755>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S801>/Data Store Write7' incorporates:
+         *  Constant: '<S801>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* RelationalOperator: '<S755>/Equal' incorporates:
-         *  DataStoreRead: '<S755>/current step'
+        /* RelationalOperator: '<S801>/Equal' incorporates:
+         *  DataStoreRead: '<S801>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);
 
-        /* MATLAB Function: '<S755>/Incar temp goto from step 1 to step 2 ' */
+        /* MATLAB Function: '<S801>/Incar temp goto from step 1 to step 2 ' */
         Incartempgotofromstep1tostep2(rtB.Merge_b, &Eva_F);
 
-        /* MATLAB Function: '<S755>/Time goto from step 1 to step 2 ' */
+        /* MATLAB Function: '<S801>/Time goto from step 1 to step 2 ' */
         /* :  out = int16(g_ausSTART_TIME_STEP1_TO_2(LVL + 1)); */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        rtb_out_ee = g_ausSTART_TIME_STEP1_TO_2[q0 - 1];
-        if (rtb_out_ee > 32767) {
-          rtb_out_ee = 32767U;
+        rtb_out_oc = g_ausSTART_TIME_STEP1_TO_2[y - 1];
+        if (rtb_out_oc > 32767) {
+          rtb_out_oc = 32767U;
         }
 
-        /* Switch: '<S755>/Switch' incorporates:
-         *  DataStoreRead: '<S755>/incar temp'
-         *  DataStoreRead: '<S765>/Data Store Read4'
-         *  Gain: '<S755>/из сек в мс'
-         *  Logic: '<S755>/Logical Operator'
-         *  MATLAB Function: '<S755>/Time goto from step 1 to step 2 '
-         *  RelationalOperator: '<S755>/Relational Operator'
-         *  RelationalOperator: '<S755>/Relational Operator1'
-         *  Sum: '<S765>/Subtract'
-         *  UnitDelay: '<S765>/t_start_delay_private '
+        /* Switch: '<S801>/Switch' incorporates:
+         *  DataStoreRead: '<S801>/incar temp'
+         *  DataStoreRead: '<S811>/Data Store Read4'
+         *  Gain: '<S801>/из сек в мс'
+         *  Logic: '<S801>/Logical Operator'
+         *  MATLAB Function: '<S801>/Time goto from step 1 to step 2 '
+         *  RelationalOperator: '<S801>/Relational Operator'
+         *  RelationalOperator: '<S801>/Relational Operator1'
+         *  Sum: '<S811>/Subtract'
+         *  UnitDelay: '<S811>/t_start_delay_private '
          */
         if ((Incar_FL < Eva_F) || (rtDW.t_now -
-             rtDW.t_start_delay_private_DSTATE_pd > (uint16_t)(1000 * rtb_out_ee)))
+             rtDW.t_start_delay_private_DSTATE_pd > (uint16_t)(1000 * rtb_out_oc)))
         {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S755>/go to next step'
-           *  SignalConversion generated from: '<S755>/step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S801>/go to next step'
+           *  SignalConversion generated from: '<S801>/step'
            */
           rtB.Merge_ho = 2;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S755>/stay at step 1'
-           *  SignalConversion generated from: '<S755>/step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S801>/stay at step 1'
+           *  SignalConversion generated from: '<S801>/step'
            */
           rtB.Merge_ho = 1;
         }
 
-        /* End of Switch: '<S755>/Switch' */
+        /* End of Switch: '<S801>/Switch' */
 
-        /* Switch: '<S765>/Switch' incorporates:
-         *  DataStoreRead: '<S765>/Data Store Read4'
-         *  Logic: '<S765>/Logical Operator3'
-         *  Logic: '<S765>/Logical Operator4'
-         *  UnitDelay: '<S765>/Cond_prev_private '
-         *  UnitDelay: '<S765>/t_start_delay_private '
+        /* Switch: '<S811>/Switch' incorporates:
+         *  DataStoreRead: '<S811>/Data Store Read4'
+         *  Logic: '<S811>/Logical Operator3'
+         *  Logic: '<S811>/Logical Operator4'
+         *  UnitDelay: '<S811>/Cond_prev_private '
+         *  UnitDelay: '<S811>/t_start_delay_private '
          */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_gx)) {
           rtDW.t_start_delay_private_DSTATE_pd = rtDW.t_now;
         }
 
-        /* End of Switch: '<S765>/Switch' */
+        /* End of Switch: '<S811>/Switch' */
 
-        /* Update for UnitDelay: '<S765>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S811>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_gx = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S724>/Level 0' */
+        /* End of Outputs for SubSystem: '<S770>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S724>/Level 1' incorporates:
-         *  ActionPort: '<S756>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S770>/Level 1' incorporates:
+         *  ActionPort: '<S802>/Action Port'
          */
-        /* DataStoreWrite: '<S756>/Data Store Write8' incorporates:
-         *  MATLAB Function: '<S756>/3 way valve status'
+        /* DataStoreWrite: '<S802>/Data Store Write8' incorporates:
+         *  MATLAB Function: '<S802>/3 way valve status'
          */
         uwayvalvestatus(rtB.Merge_b, &rtb_u_cuz);
 
-        /* DataStoreWrite: '<S756>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S756>/incar filter up'
+        /* DataStoreWrite: '<S802>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S802>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S756>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S756>/incar filter down'
+        /* DataStoreWrite: '<S802>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S802>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* DataStoreWrite: '<S756>/Data Store Write3' incorporates:
-         *  MATLAB Function: '<S756>/mode FR step 1'
+        /* DataStoreWrite: '<S802>/Data Store Write3' incorporates:
+         *  MATLAB Function: '<S802>/mode FR step 1'
          */
         modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);
 
-        /* DataStoreWrite: '<S756>/Data Store Write11' incorporates:
-         *  MATLAB Function: '<S756>/window heating'
+        /* DataStoreWrite: '<S802>/Data Store Write11' incorporates:
+         *  MATLAB Function: '<S802>/window heating'
          */
         windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);
 
-        /* DataStoreWrite: '<S756>/Data Store Write6' incorporates:
-         *  MATLAB Function: '<S756>/blower FR'
+        /* DataStoreWrite: '<S802>/Data Store Write6' incorporates:
+         *  MATLAB Function: '<S802>/blower FR'
          */
         blowerFR(rtB.Merge_b, &rtDW.Blower_FL);
 
-        /* DataStoreWrite: '<S756>/Data Store Write11' incorporates:
-         *  MATLAB Function: '<S756>/Dtg_FrontUpper_X'
+        /* DataStoreWrite: '<S802>/Data Store Write11' incorporates:
+         *  MATLAB Function: '<S802>/Dtg_FrontUpper_X'
          */
         Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);
 
-        /* DataStoreWrite: '<S756>/Data Store Write13' incorporates:
-         *  MATLAB Function: '<S756>/Dtg_FrontLower_X'
+        /* DataStoreWrite: '<S802>/Data Store Write13' incorporates:
+         *  MATLAB Function: '<S802>/Dtg_FrontLower_X'
          */
         Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);
 
-        /* DataStoreWrite: '<S756>/Data Store Write7' incorporates:
-         *  Constant: '<S756>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S802>/Data Store Write7' incorporates:
+         *  Constant: '<S802>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* RelationalOperator: '<S756>/Equal' incorporates:
-         *  DataStoreRead: '<S756>/current step'
+        /* RelationalOperator: '<S802>/Equal' incorporates:
+         *  DataStoreRead: '<S802>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);
 
-        /* MATLAB Function: '<S756>/Incar temp goto from step 1 to step 2 ' */
+        /* MATLAB Function: '<S802>/Incar temp goto from step 1 to step 2 ' */
         Incartempgotofromstep1tostep2(rtB.Merge_b, &Eva_F);
 
-        /* MATLAB Function: '<S756>/Time goto from step 1 to step 2 ' */
+        /* MATLAB Function: '<S802>/Time goto from step 1 to step 2 ' */
         Timegotofromstep1tostep2(rtB.Merge_b, &Eva_R);
 
-        /* RelationalOperator: '<S756>/Relational Operator1' incorporates:
-         *  DataStoreRead: '<S776>/Data Store Read4'
-         *  Gain: '<S756>/из сек в мс'
-         *  Sum: '<S776>/Subtract'
-         *  UnitDelay: '<S776>/t_start_delay_private '
+        /* RelationalOperator: '<S802>/Relational Operator1' incorporates:
+         *  DataStoreRead: '<S822>/Data Store Read4'
+         *  Gain: '<S802>/из сек в мс'
+         *  Sum: '<S822>/Subtract'
+         *  UnitDelay: '<S822>/t_start_delay_private '
          */
         rtb_LogicalOperator1_g = (rtDW.t_now -
           rtDW.t_start_delay_private_DSTATE_mk > (uint32_t)(1000 * Eva_R));
 
-        /* Switch: '<S776>/Switch' incorporates:
-         *  DataStoreRead: '<S776>/Data Store Read4'
-         *  Logic: '<S776>/Logical Operator3'
-         *  Logic: '<S776>/Logical Operator4'
-         *  UnitDelay: '<S776>/Cond_prev_private '
-         *  UnitDelay: '<S776>/t_start_delay_private '
+        /* Switch: '<S822>/Switch' incorporates:
+         *  DataStoreRead: '<S822>/Data Store Read4'
+         *  Logic: '<S822>/Logical Operator3'
+         *  Logic: '<S822>/Logical Operator4'
+         *  UnitDelay: '<S822>/Cond_prev_private '
+         *  UnitDelay: '<S822>/t_start_delay_private '
          */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_h)) {
           rtDW.t_start_delay_private_DSTATE_mk = rtDW.t_now;
         }
 
-        /* End of Switch: '<S776>/Switch' */
+        /* End of Switch: '<S822>/Switch' */
 
-        /* Switch: '<S756>/Switch' incorporates:
-         *  DataStoreRead: '<S756>/incar temp'
-         *  Logic: '<S756>/Logical Operator'
-         *  RelationalOperator: '<S756>/Relational Operator'
+        /* Switch: '<S802>/Switch' incorporates:
+         *  DataStoreRead: '<S802>/incar temp'
+         *  Logic: '<S802>/Logical Operator'
+         *  RelationalOperator: '<S802>/Relational Operator'
          */
         if ((Incar_FL < Eva_F) || rtb_LogicalOperator1_g) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S756>/go to next step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S802>/go to next step'
            */
           rtB.Merge_ho = 2;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S756>/stay at step 1'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S802>/stay at step 1'
            */
           rtB.Merge_ho = 1;
         }
 
-        /* End of Switch: '<S756>/Switch' */
+        /* End of Switch: '<S802>/Switch' */
 
-        /* Update for UnitDelay: '<S776>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S822>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_h = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S724>/Level 1' */
+        /* End of Outputs for SubSystem: '<S770>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S724>/Level 2' incorporates:
-         *  ActionPort: '<S757>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S770>/Level 2' incorporates:
+         *  ActionPort: '<S803>/Action Port'
          */
-        /* Merge: '<S720>/Merge' incorporates:
-         *  Constant: '<S757>/Constant'
-         *  SignalConversion generated from: '<S757>/step'
+        /* Merge: '<S766>/Merge' incorporates:
+         *  Constant: '<S803>/Constant'
+         *  SignalConversion generated from: '<S803>/step'
          */
         rtB.Merge_ho = 2;
 
-        /* End of Outputs for SubSystem: '<S724>/Level 2' */
+        /* End of Outputs for SubSystem: '<S770>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S724>/Level 3' incorporates:
-         *  ActionPort: '<S758>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S770>/Level 3' incorporates:
+         *  ActionPort: '<S804>/Action Port'
          */
-        /* DataStoreWrite: '<S758>/Data Store Write8' incorporates:
-         *  MATLAB Function: '<S758>/3 way valve status'
+        /* DataStoreWrite: '<S804>/Data Store Write8' incorporates:
+         *  MATLAB Function: '<S804>/3 way valve status'
          */
         uwayvalvestatus(rtB.Merge_b, &rtb_u_cuz);
 
-        /* DataStoreWrite: '<S758>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S758>/incar filter up'
+        /* DataStoreWrite: '<S804>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S804>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S758>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S758>/incar filter down'
+        /* DataStoreWrite: '<S804>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S804>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* DataStoreWrite: '<S758>/Data Store Write3' incorporates:
-         *  MATLAB Function: '<S758>/mode FR step 1'
+        /* DataStoreWrite: '<S804>/Data Store Write3' incorporates:
+         *  MATLAB Function: '<S804>/mode FR step 1'
          */
         modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);
 
-        /* DataStoreWrite: '<S758>/Data Store Write11' incorporates:
-         *  MATLAB Function: '<S758>/window heating'
+        /* DataStoreWrite: '<S804>/Data Store Write11' incorporates:
+         *  MATLAB Function: '<S804>/window heating'
          */
         windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);
 
-        /* MATLAB Function: '<S789>/blower min max' */
-        blowerminmax(rtB.Merge_b, rtb_out_he);
+        /* MATLAB Function: '<S835>/blower min max' */
+        blowerminmax(rtB.Merge_b, rtb_out_jq);
 
-        /* MATLAB Function: '<S789>/ECT min max' */
-        ECTminmax(rtB.Merge_b, rtb_out_hl);
+        /* MATLAB Function: '<S835>/ECT min max' */
+        ECTminmax(rtB.Merge_b, rtb_out_j4);
 
-        /* DataStoreWrite: '<S758>/Data Store Write6' incorporates:
-         *  DataStoreRead: '<S789>/engine coolant temp'
-         *  Lookup_n-D: '<S789>/blower для текущего ECT'
+        /* DataStoreWrite: '<S804>/Data Store Write6' incorporates:
+         *  DataStoreRead: '<S835>/engine coolant temp'
+         *  Lookup_n-D: '<S835>/blower для текущего ECT'
          */
-        rtDW.Blower_FL = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_hl,
-          rtb_out_he, 1U);
+        rtDW.Blower_FL = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_j4,
+          rtb_out_jq, 1U);
 
-        /* DataStoreWrite: '<S758>/Data Store Write11' incorporates:
-         *  MATLAB Function: '<S758>/Dtg_FrontUpper_X'
+        /* DataStoreWrite: '<S804>/Data Store Write11' incorporates:
+         *  MATLAB Function: '<S804>/Dtg_FrontUpper_X'
          */
         Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);
 
-        /* DataStoreWrite: '<S758>/Data Store Write13' incorporates:
-         *  MATLAB Function: '<S758>/Dtg_FrontLower_X'
+        /* DataStoreWrite: '<S804>/Data Store Write13' incorporates:
+         *  MATLAB Function: '<S804>/Dtg_FrontLower_X'
          */
         Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);
 
-        /* DataStoreWrite: '<S758>/Data Store Write7' incorporates:
-         *  Constant: '<S758>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S804>/Data Store Write7' incorporates:
+         *  Constant: '<S804>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* RelationalOperator: '<S758>/Equal' incorporates:
-         *  DataStoreRead: '<S758>/current step'
+        /* RelationalOperator: '<S804>/Equal' incorporates:
+         *  DataStoreRead: '<S804>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);
 
-        /* MATLAB Function: '<S758>/Incar temp goto from step 1 to step 2 ' */
+        /* MATLAB Function: '<S804>/Incar temp goto from step 1 to step 2 ' */
         Incartempgotofromstep1tostep2(rtB.Merge_b, &Eva_F);
 
-        /* Sum: '<S787>/Subtract' incorporates:
-         *  DataStoreRead: '<S787>/Data Store Read4'
-         *  UnitDelay: '<S787>/t_start_delay_private '
+        /* Sum: '<S833>/Subtract' incorporates:
+         *  DataStoreRead: '<S833>/Data Store Read4'
+         *  UnitDelay: '<S833>/t_start_delay_private '
          */
         rtb_dt_ih = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_fm;
 
-        /* MATLAB Function: '<S758>/Time goto from step 1 to step 2 ' */
+        /* MATLAB Function: '<S804>/Time goto from step 1 to step 2 ' */
         Timegotofromstep1tostep2(rtB.Merge_b, &Eva_R);
 
-        /* Switch: '<S787>/Switch' incorporates:
-         *  DataStoreRead: '<S787>/Data Store Read4'
-         *  Logic: '<S787>/Logical Operator3'
-         *  Logic: '<S787>/Logical Operator4'
-         *  UnitDelay: '<S787>/Cond_prev_private '
-         *  UnitDelay: '<S787>/t_start_delay_private '
+        /* Switch: '<S833>/Switch' incorporates:
+         *  DataStoreRead: '<S833>/Data Store Read4'
+         *  Logic: '<S833>/Logical Operator3'
+         *  Logic: '<S833>/Logical Operator4'
+         *  UnitDelay: '<S833>/Cond_prev_private '
+         *  UnitDelay: '<S833>/t_start_delay_private '
          */
         /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(LVL + 1 - 3)); */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_f)) {
           rtDW.t_start_delay_private_DSTATE_fm = rtDW.t_now;
         }
 
-        /* End of Switch: '<S787>/Switch' */
+        /* End of Switch: '<S833>/Switch' */
 
-        /* MATLAB Function: '<S758>/g_assSTART_COOLANT_TO_STEP2 ' */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        /* MATLAB Function: '<S804>/g_assSTART_COOLANT_TO_STEP2 ' */
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
         /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
-        rtb_dt_fa = (uint32_t)q0 - 3U;
+        rtb_dt_fa = (uint32_t)y - 3U;
 
         /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
-        if ((uint32_t)q0 - 3U > (uint32_t)q0) {
+        if ((uint32_t)y - 3U > (uint32_t)y) {
           rtb_dt_fa = 0U;
         }
 
-        /* Switch: '<S758>/Switch' incorporates:
-         *  DataStoreRead: '<S758>/engine coolant temp'
-         *  DataStoreRead: '<S758>/incar temp'
-         *  Gain: '<S758>/из сек в мс'
-         *  Logic: '<S758>/Logical Operator'
-         *  MATLAB Function: '<S758>/g_assSTART_COOLANT_TO_STEP2 '
-         *  RelationalOperator: '<S758>/Relational Operator'
-         *  RelationalOperator: '<S758>/Relational Operator1'
-         *  RelationalOperator: '<S758>/Relational Operator2'
+        /* Switch: '<S804>/Switch' incorporates:
+         *  DataStoreRead: '<S804>/engine coolant temp'
+         *  DataStoreRead: '<S804>/incar temp'
+         *  Gain: '<S804>/из сек в мс'
+         *  Logic: '<S804>/Logical Operator'
+         *  MATLAB Function: '<S804>/g_assSTART_COOLANT_TO_STEP2 '
+         *  RelationalOperator: '<S804>/Relational Operator'
+         *  RelationalOperator: '<S804>/Relational Operator1'
+         *  RelationalOperator: '<S804>/Relational Operator2'
          */
         if ((Incar_FL < Eva_F) || (rtb_dt_ih > (uint32_t)(1000 * Eva_R)) ||
             (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[(int32_t)rtb_dt_fa - 1])) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S758>/go to next step 2'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S804>/go to next step 2'
            */
           rtB.Merge_ho = 2;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S758>/stay at step 1'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S804>/stay at step 1'
            */
           rtB.Merge_ho = 1;
         }
 
-        /* End of Switch: '<S758>/Switch' */
+        /* End of Switch: '<S804>/Switch' */
 
-        /* Update for UnitDelay: '<S787>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S833>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_f = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S724>/Level 3' */
+        /* End of Outputs for SubSystem: '<S770>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S724>/Level 4' incorporates:
-         *  ActionPort: '<S759>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S770>/Level 4' incorporates:
+         *  ActionPort: '<S805>/Action Port'
          */
-        Level4_c(&rtB.Merge_ho, &rtDW.Blower_FL, &rtb_out_ee, &rtDW.Dtg_FLL,
+        Level4_c(&rtB.Merge_ho, &rtDW.Blower_FL, &rtb_out_oc, &rtDW.Dtg_FLL,
                  &Valve_2_way, &rtDW.Dtg_FUL, &Dtg_FUR, &rtDW.ECT,
-                 &El_window_heating, &Incar_FL, &rtb_Gain2_c, &rtb_Gain_ge,
+                 &El_window_heating, &Incar_FL, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtb_Divide1, &rtb_u_cuz,
                  &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level4_cw);
 
-        /* End of Outputs for SubSystem: '<S724>/Level 4' */
+        /* End of Outputs for SubSystem: '<S770>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S724>/Level 5' incorporates:
-         *  ActionPort: '<S760>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S770>/Level 5' incorporates:
+         *  ActionPort: '<S806>/Action Port'
          */
-        Level4_c(&rtB.Merge_ho, &rtDW.Blower_FL, &rtb_out_ee, &rtDW.Dtg_FLL,
+        Level4_c(&rtB.Merge_ho, &rtDW.Blower_FL, &rtb_out_oc, &rtDW.Dtg_FLL,
                  &Valve_2_way, &rtDW.Dtg_FUL, &Dtg_FUR, &rtDW.ECT,
-                 &El_window_heating, &Incar_FL, &rtb_Gain2_c, &rtb_Gain_ge,
+                 &El_window_heating, &Incar_FL, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtb_Divide1, &rtb_u_cuz,
                  &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level5_g);
 
-        /* End of Outputs for SubSystem: '<S724>/Level 5' */
+        /* End of Outputs for SubSystem: '<S770>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S724>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S720>/Step 1 F' */
+      /* End of SwitchCase: '<S770>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S766>/Step 1 F' */
       break;
 
      case 2:
-      /* Outputs for IfAction SubSystem: '<S720>/Step 2 F' incorporates:
-       *  ActionPort: '<S725>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S766>/Step 2 F' incorporates:
+       *  ActionPort: '<S771>/Action Port'
        */
-      /* SwitchCase: '<S725>/Switch Case' incorporates:
+      /* SwitchCase: '<S771>/Switch Case' incorporates:
        *  DataStoreWrite: '<S10>/Data Store Write'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S725>/Level 0' incorporates:
-         *  ActionPort: '<S823>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S771>/Level 0' incorporates:
+         *  ActionPort: '<S869>/Action Port'
          */
-        /* DataStoreWrite: '<S823>/Data Store Write8' incorporates:
-         *  MATLAB Function: '<S823>/3 way valve status'
+        /* DataStoreWrite: '<S869>/Data Store Write8' incorporates:
+         *  MATLAB Function: '<S869>/3 way valve status'
          */
         uwayvalvestatus_a(rtB.Merge_b, &rtb_u_cuz);
 
-        /* MATLAB Function: '<S830>/step' */
+        /* MATLAB Function: '<S876>/step' */
         Dtg_FrontLower_X(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S830>/time for step' */
-        timeforstep(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S876>/time for step' */
+        timeforstep(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Switch: '<S830>/Switch' incorporates:
-         *  Constant: '<S839>/epsilon'
-         *  DataStoreRead: '<S830>/Текущее значение blower '
-         *  DataStoreRead: '<S830>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S839>/Relational Operator'
-         *  RelationalOperator: '<S843>/Relational Operator'
-         *  Sum: '<S839>/Add'
-         *  Switch: '<S843>/Switch'
+        /* Switch: '<S876>/Switch' incorporates:
+         *  Constant: '<S885>/epsilon'
+         *  DataStoreRead: '<S876>/Текущее значение blower '
+         *  DataStoreRead: '<S876>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S885>/Relational Operator'
+         *  RelationalOperator: '<S889>/Relational Operator'
+         *  Sum: '<S885>/Add'
+         *  Switch: '<S889>/Switch'
          */
         if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
-          /* DataStoreWrite: '<S823>/Data Store Write13' */
+          /* DataStoreWrite: '<S869>/Data Store Write13' */
           rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
         } else {
           if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
-            /* Switch: '<S843>/Switch' incorporates:
-             *  Constant: '<S843>/Constant'
+            /* Switch: '<S889>/Switch' incorporates:
+             *  Constant: '<S889>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S843>/Switch' incorporates:
-             *  Constant: '<S843>/Constant1'
+            /* Switch: '<S889>/Switch' incorporates:
+             *  Constant: '<S889>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S823>/Data Store Write13' incorporates:
-           *  Constant: '<S830>/Constant'
-           *  DataStoreRead: '<S830>/текущее время в мс'
-           *  Product: '<S830>/Product1'
-           *  Product: '<S830>/change rate (dtg//sec)'
-           *  Product: '<S830>/скорость в мс'
-           *  Product: '<S830>/шаг изменения'
-           *  Sum: '<S830>/Add'
-           *  Sum: '<S840>/Subtract'
-           *  Switch: '<S843>/Switch'
-           *  UnitDelay: '<S840>/Unit Delay'
+          /* DataStoreWrite: '<S869>/Data Store Write13' incorporates:
+           *  Constant: '<S876>/Constant'
+           *  DataStoreRead: '<S876>/текущее время в мс'
+           *  Product: '<S876>/Product1'
+           *  Product: '<S876>/change rate (dtg//sec)'
+           *  Product: '<S876>/скорость в мс'
+           *  Product: '<S876>/шаг изменения'
+           *  Sum: '<S876>/Add'
+           *  Sum: '<S886>/Subtract'
+           *  Switch: '<S889>/Switch'
+           *  UnitDelay: '<S886>/Unit Delay'
            */
-          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_k) * (double)q0
+          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_k) * (double)y
             + (double)rtDW.Dtg_FLL);
         }
 
-        /* End of Switch: '<S830>/Switch' */
+        /* End of Switch: '<S876>/Switch' */
 
-        /* MATLAB Function: '<S831>/step' */
+        /* MATLAB Function: '<S877>/step' */
         Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S831>/time for step' */
-        timeforstep_j(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S877>/time for step' */
+        timeforstep_j(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Switch: '<S831>/Switch' incorporates:
-         *  Constant: '<S844>/epsilon'
-         *  DataStoreRead: '<S831>/Текущее значение blower '
-         *  DataStoreRead: '<S831>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S844>/Relational Operator'
-         *  RelationalOperator: '<S848>/Relational Operator'
-         *  Sum: '<S844>/Add'
-         *  Switch: '<S848>/Switch'
+        /* Switch: '<S877>/Switch' incorporates:
+         *  Constant: '<S890>/epsilon'
+         *  DataStoreRead: '<S877>/Текущее значение blower '
+         *  DataStoreRead: '<S877>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S890>/Relational Operator'
+         *  RelationalOperator: '<S894>/Relational Operator'
+         *  Sum: '<S890>/Add'
+         *  Switch: '<S894>/Switch'
          */
         if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
-          /* DataStoreWrite: '<S823>/Data Store Write11' */
+          /* DataStoreWrite: '<S869>/Data Store Write11' */
           rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
         } else {
           if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
-            /* Switch: '<S848>/Switch' incorporates:
-             *  Constant: '<S848>/Constant'
+            /* Switch: '<S894>/Switch' incorporates:
+             *  Constant: '<S894>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S848>/Switch' incorporates:
-             *  Constant: '<S848>/Constant1'
+            /* Switch: '<S894>/Switch' incorporates:
+             *  Constant: '<S894>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S823>/Data Store Write11' incorporates:
-           *  Constant: '<S831>/Constant'
-           *  DataStoreRead: '<S831>/текущее время в мс'
-           *  Product: '<S831>/Product1'
-           *  Product: '<S831>/change rate (dtg//sec)'
-           *  Product: '<S831>/скорость в мс'
-           *  Product: '<S831>/шаг изменения'
-           *  Sum: '<S831>/Add'
-           *  Sum: '<S845>/Subtract'
-           *  Switch: '<S848>/Switch'
-           *  UnitDelay: '<S845>/Unit Delay'
+          /* DataStoreWrite: '<S869>/Data Store Write11' incorporates:
+           *  Constant: '<S877>/Constant'
+           *  DataStoreRead: '<S877>/текущее время в мс'
+           *  Product: '<S877>/Product1'
+           *  Product: '<S877>/change rate (dtg//sec)'
+           *  Product: '<S877>/скорость в мс'
+           *  Product: '<S877>/шаг изменения'
+           *  Sum: '<S877>/Add'
+           *  Sum: '<S891>/Subtract'
+           *  Switch: '<S894>/Switch'
+           *  UnitDelay: '<S891>/Unit Delay'
            */
-          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_pb) * (double)
-            q0 + (double)rtDW.Dtg_FUL);
+          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_pb) * (double)y
+            + (double)rtDW.Dtg_FUL);
         }
 
-        /* End of Switch: '<S831>/Switch' */
+        /* End of Switch: '<S877>/Switch' */
 
-        /* DataStoreWrite: '<S823>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S823>/incar filter up'
+        /* DataStoreWrite: '<S869>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S869>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S823>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S823>/incar filter down'
+        /* DataStoreWrite: '<S869>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S869>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Sum: '<S854>/Add' incorporates:
-         *  DataStoreRead: '<S837>/Текущее значение blower '
-         *  DataStoreRead: '<S837>/значение auto (в соответствии с логикой)'
+        /* Sum: '<S900>/Add' incorporates:
+         *  DataStoreRead: '<S883>/Текущее значение blower '
+         *  DataStoreRead: '<S883>/значение auto (в соответствии с логикой)'
          */
         rtb_Gain_ge = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);
 
-        /* RelationalOperator: '<S854>/Relational Operator' incorporates:
-         *  Constant: '<S854>/epsilon'
+        /* RelationalOperator: '<S900>/Relational Operator' incorporates:
+         *  Constant: '<S900>/epsilon'
          */
         rtb_LogicalOperator1 = (rtb_Gain_ge <= 0.01);
 
-        /* MATLAB Function: '<S837>/step' */
-        step_j(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S883>/step' */
+        step_j(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* MATLAB Function: '<S837>/time for step' */
+        /* MATLAB Function: '<S883>/time for step' */
         timeforstep_g(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* Switch: '<S837>/Switch' incorporates:
-         *  DataStoreRead: '<S837>/Текущее значение blower '
-         *  DataStoreRead: '<S837>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S858>/Relational Operator'
-         *  Switch: '<S858>/Switch'
+        /* Switch: '<S883>/Switch' incorporates:
+         *  DataStoreRead: '<S883>/Текущее значение blower '
+         *  DataStoreRead: '<S883>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S904>/Relational Operator'
+         *  Switch: '<S904>/Switch'
          */
         if (rtb_LogicalOperator1) {
-          /* DataStoreWrite: '<S823>/Data Store Write3' incorporates:
-           *  DataStoreRead: '<S837>/значение auto (в соответствии с логикой)'
+          /* DataStoreWrite: '<S869>/Data Store Write3' incorporates:
+           *  DataStoreRead: '<S883>/значение auto (в соответствии с логикой)'
            */
           rtDW.Mode_FL = rtDW.Mode_logic_FL;
         } else {
           if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
-            /* Switch: '<S858>/Switch' incorporates:
-             *  Constant: '<S858>/Constant'
+            /* Switch: '<S904>/Switch' incorporates:
+             *  Constant: '<S904>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S858>/Switch' incorporates:
-             *  Constant: '<S858>/Constant1'
+            /* Switch: '<S904>/Switch' incorporates:
+             *  Constant: '<S904>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S823>/Data Store Write3' incorporates:
-           *  Constant: '<S837>/Constant'
-           *  DataStoreRead: '<S837>/Текущее значение blower '
-           *  DataStoreRead: '<S837>/текущее время в мс'
-           *  Product: '<S837>/Product1'
-           *  Product: '<S837>/change rate (step//sec)'
-           *  Product: '<S837>/скорость в мс'
-           *  Product: '<S837>/шаг изменения'
-           *  Sum: '<S837>/Add'
-           *  Sum: '<S855>/Subtract'
-           *  Switch: '<S858>/Switch'
-           *  UnitDelay: '<S855>/Unit Delay'
+          /* DataStoreWrite: '<S869>/Data Store Write3' incorporates:
+           *  Constant: '<S883>/Constant'
+           *  DataStoreRead: '<S883>/Текущее значение blower '
+           *  DataStoreRead: '<S883>/текущее время в мс'
+           *  Product: '<S883>/Product1'
+           *  Product: '<S883>/change rate (step//sec)'
+           *  Product: '<S883>/скорость в мс'
+           *  Product: '<S883>/шаг изменения'
+           *  Sum: '<S883>/Add'
+           *  Sum: '<S901>/Subtract'
+           *  Switch: '<S904>/Switch'
+           *  UnitDelay: '<S901>/Unit Delay'
            */
-          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain2_c / (double)rtb_Gain_ge /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_mk) * (double)
-            q0 + (double)rtDW.Mode_FL);
+          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain2_hu / (double)rtb_Gain_ge /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_mk) * (double)y
+            + (double)rtDW.Mode_FL);
         }
 
-        /* End of Switch: '<S837>/Switch' */
+        /* End of Switch: '<S883>/Switch' */
 
-        /* Sum: '<S849>/Add' incorporates:
-         *  DataStoreRead: '<S834>/Текущее значение blower '
-         *  DataStoreRead: '<S834>/значение auto (в соответствии с логикой)'
+        /* Sum: '<S895>/Add' incorporates:
+         *  DataStoreRead: '<S880>/Текущее значение blower '
+         *  DataStoreRead: '<S880>/значение auto (в соответствии с логикой)'
          */
         /* :  out = g_aucSTART_ELEC_WINDOW(LVL + 1 + 6); */
-        rtb_out_ee = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);
+        rtb_out_oc = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);
 
-        /* RelationalOperator: '<S849>/Relational Operator' incorporates:
-         *  Constant: '<S849>/epsilon'
+        /* RelationalOperator: '<S895>/Relational Operator' incorporates:
+         *  Constant: '<S895>/epsilon'
          */
-        rtb_LogicalOperator1 = (rtb_out_ee <= 0.01);
+        rtb_LogicalOperator1 = (rtb_out_oc <= 0.01);
 
-        /* MATLAB Function: '<S834>/blower step' */
-        blowerstep(rtB.Merge_b, &rtb_out_bc);
+        /* MATLAB Function: '<S880>/blower step' */
+        blowerstep(rtB.Merge_b, &rtb_out_jn);
 
-        /* MATLAB Function: '<S834>/blower time for step' */
-        blowertimeforstep(rtB.Merge_b, &rtb_out_ee);
+        /* MATLAB Function: '<S880>/blower time for step' */
+        blowertimeforstep(rtB.Merge_b, &rtb_out_oc);
 
-        /* Switch: '<S834>/Switch' incorporates:
-         *  DataStoreRead: '<S834>/Текущее значение blower '
-         *  DataStoreRead: '<S834>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S853>/Relational Operator'
-         *  Switch: '<S853>/Switch'
+        /* Switch: '<S880>/Switch' incorporates:
+         *  DataStoreRead: '<S880>/Текущее значение blower '
+         *  DataStoreRead: '<S880>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S899>/Relational Operator'
+         *  Switch: '<S899>/Switch'
          */
         if (rtb_LogicalOperator1) {
-          /* DataStoreWrite: '<S823>/Data Store Write6' incorporates:
-           *  DataStoreRead: '<S834>/значение auto (в соответствии с логикой)'
+          /* DataStoreWrite: '<S869>/Data Store Write6' incorporates:
+           *  DataStoreRead: '<S880>/значение auto (в соответствии с логикой)'
            */
           rtDW.Blower_FL = rtDW.Blower_logic_FL;
         } else {
           if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
-            /* Switch: '<S853>/Switch' incorporates:
-             *  Constant: '<S853>/Constant'
+            /* Switch: '<S899>/Switch' incorporates:
+             *  Constant: '<S899>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S853>/Switch' incorporates:
-             *  Constant: '<S853>/Constant1'
+            /* Switch: '<S899>/Switch' incorporates:
+             *  Constant: '<S899>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S823>/Data Store Write6' incorporates:
-           *  Constant: '<S834>/Constant'
-           *  DataStoreRead: '<S834>/Текущее значение blower '
-           *  DataStoreRead: '<S834>/текущее время в мс'
-           *  Product: '<S834>/Product1'
-           *  Product: '<S834>/change rate (step//sec)'
-           *  Product: '<S834>/скорость в мс'
-           *  Product: '<S834>/шаг изменения'
-           *  Sum: '<S834>/Add'
-           *  Sum: '<S850>/Subtract'
-           *  Switch: '<S853>/Switch'
-           *  UnitDelay: '<S850>/Unit Delay'
+          /* DataStoreWrite: '<S869>/Data Store Write6' incorporates:
+           *  Constant: '<S880>/Constant'
+           *  DataStoreRead: '<S880>/Текущее значение blower '
+           *  DataStoreRead: '<S880>/текущее время в мс'
+           *  Product: '<S880>/Product1'
+           *  Product: '<S880>/change rate (step//sec)'
+           *  Product: '<S880>/скорость в мс'
+           *  Product: '<S880>/шаг изменения'
+           *  Sum: '<S880>/Add'
+           *  Sum: '<S896>/Subtract'
+           *  Switch: '<S899>/Switch'
+           *  UnitDelay: '<S896>/Unit Delay'
            */
-          rtDW.Blower_FL = (uint16_t)((double)rtb_out_bc / (double)rtb_out_ee /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gm) * (double)
-            q0 + (double)rtDW.Blower_FL);
+          rtDW.Blower_FL = (uint16_t)((double)rtb_out_jn / (double)rtb_out_oc /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gm) * (double)y
+            + (double)rtDW.Blower_FL);
         }
 
-        /* End of Switch: '<S834>/Switch' */
+        /* End of Switch: '<S880>/Switch' */
 
-        /* DataStoreWrite: '<S823>/Data Store Write7' incorporates:
-         *  Constant: '<S823>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S869>/Data Store Write7' incorporates:
+         *  Constant: '<S869>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* RelationalOperator: '<S823>/Equal' incorporates:
-         *  DataStoreRead: '<S823>/current step'
+        /* RelationalOperator: '<S869>/Equal' incorporates:
+         *  DataStoreRead: '<S869>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 2);
 
-        /* Sum: '<S832>/Subtract' incorporates:
-         *  DataStoreRead: '<S832>/Data Store Read4'
-         *  UnitDelay: '<S832>/t_start_delay_private '
+        /* Sum: '<S878>/Subtract' incorporates:
+         *  DataStoreRead: '<S878>/Data Store Read4'
+         *  UnitDelay: '<S878>/t_start_delay_private '
          */
         rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_g;
 
-        /* Switch: '<S832>/Switch' incorporates:
-         *  DataStoreRead: '<S832>/Data Store Read4'
-         *  Logic: '<S832>/Logical Operator3'
-         *  Logic: '<S832>/Logical Operator4'
-         *  UnitDelay: '<S832>/Cond_prev_private '
-         *  UnitDelay: '<S832>/t_start_delay_private '
+        /* Switch: '<S878>/Switch' incorporates:
+         *  DataStoreRead: '<S878>/Data Store Read4'
+         *  Logic: '<S878>/Logical Operator3'
+         *  Logic: '<S878>/Logical Operator4'
+         *  UnitDelay: '<S878>/Cond_prev_private '
+         *  UnitDelay: '<S878>/t_start_delay_private '
          */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_m)) {
           rtDW.t_start_delay_private_DSTATE_g = rtDW.t_now;
         }
 
-        /* End of Switch: '<S832>/Switch' */
+        /* End of Switch: '<S878>/Switch' */
 
-        /* MATLAB Function: '<S823>/Time goto from step 2 to step 3 ' */
+        /* MATLAB Function: '<S869>/Time goto from step 2 to step 3 ' */
         Timegotofromstep2tostep3(rtB.Merge_b, &Incar_FL);
 
-        /* Switch: '<S823>/Switch' incorporates:
-         *  Gain: '<S823>/из сек в мс'
-         *  RelationalOperator: '<S823>/Relational Operator1'
+        /* Switch: '<S869>/Switch' incorporates:
+         *  Gain: '<S869>/из сек в мс'
+         *  RelationalOperator: '<S869>/Relational Operator1'
          */
         if (rtb_dt_fa > (uint32_t)(1000 * Incar_FL)) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S823>/go to next step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S869>/go to next step'
            */
           rtB.Merge_ho = 3;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S823>/stay at step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S869>/stay at step'
            */
           rtB.Merge_ho = 2;
         }
 
-        /* End of Switch: '<S823>/Switch' */
+        /* End of Switch: '<S869>/Switch' */
 
-        /* Update for UnitDelay: '<S840>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S830>/текущее время в мс'
+        /* Update for UnitDelay: '<S886>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S876>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_k = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S845>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S831>/текущее время в мс'
+        /* Update for UnitDelay: '<S891>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S877>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_pb = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S855>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S837>/текущее время в мс'
+        /* Update for UnitDelay: '<S901>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S883>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_mk = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S850>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S834>/текущее время в мс'
+        /* Update for UnitDelay: '<S896>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S880>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_gm = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S832>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S878>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_m = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S725>/Level 0' */
+        /* End of Outputs for SubSystem: '<S771>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S725>/Level 1' incorporates:
-         *  ActionPort: '<S824>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S771>/Level 1' incorporates:
+         *  ActionPort: '<S870>/Action Port'
          */
-        /* DataStoreWrite: '<S824>/Data Store Write8' incorporates:
-         *  MATLAB Function: '<S824>/3 way valve status'
+        /* DataStoreWrite: '<S870>/Data Store Write8' incorporates:
+         *  MATLAB Function: '<S870>/3 way valve status'
          */
         uwayvalvestatus_a(rtB.Merge_b, &rtb_u_cuz);
 
-        /* MATLAB Function: '<S860>/step' */
+        /* MATLAB Function: '<S906>/step' */
         Dtg_FrontLower_X(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S860>/time for step' */
-        timeforstep(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S906>/time for step' */
+        timeforstep(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Switch: '<S860>/Switch' incorporates:
-         *  Constant: '<S869>/epsilon'
-         *  DataStoreRead: '<S860>/Текущее значение blower '
-         *  DataStoreRead: '<S860>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S869>/Relational Operator'
-         *  RelationalOperator: '<S873>/Relational Operator'
-         *  Sum: '<S869>/Add'
-         *  Switch: '<S873>/Switch'
+        /* Switch: '<S906>/Switch' incorporates:
+         *  Constant: '<S915>/epsilon'
+         *  DataStoreRead: '<S906>/Текущее значение blower '
+         *  DataStoreRead: '<S906>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S915>/Relational Operator'
+         *  RelationalOperator: '<S919>/Relational Operator'
+         *  Sum: '<S915>/Add'
+         *  Switch: '<S919>/Switch'
          */
         if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
-          /* DataStoreWrite: '<S824>/Data Store Write13' */
+          /* DataStoreWrite: '<S870>/Data Store Write13' */
           rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
         } else {
           if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
-            /* Switch: '<S873>/Switch' incorporates:
-             *  Constant: '<S873>/Constant'
+            /* Switch: '<S919>/Switch' incorporates:
+             *  Constant: '<S919>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S873>/Switch' incorporates:
-             *  Constant: '<S873>/Constant1'
+            /* Switch: '<S919>/Switch' incorporates:
+             *  Constant: '<S919>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S824>/Data Store Write13' incorporates:
-           *  Constant: '<S860>/Constant'
-           *  DataStoreRead: '<S860>/текущее время в мс'
-           *  Product: '<S860>/Product1'
-           *  Product: '<S860>/change rate (dtg//sec)'
-           *  Product: '<S860>/скорость в мс'
-           *  Product: '<S860>/шаг изменения'
-           *  Sum: '<S860>/Add'
-           *  Sum: '<S870>/Subtract'
-           *  Switch: '<S873>/Switch'
-           *  UnitDelay: '<S870>/Unit Delay'
+          /* DataStoreWrite: '<S870>/Data Store Write13' incorporates:
+           *  Constant: '<S906>/Constant'
+           *  DataStoreRead: '<S906>/текущее время в мс'
+           *  Product: '<S906>/Product1'
+           *  Product: '<S906>/change rate (dtg//sec)'
+           *  Product: '<S906>/скорость в мс'
+           *  Product: '<S906>/шаг изменения'
+           *  Sum: '<S906>/Add'
+           *  Sum: '<S916>/Subtract'
+           *  Switch: '<S919>/Switch'
+           *  UnitDelay: '<S916>/Unit Delay'
            */
-          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_m) * (double)q0
+          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_m) * (double)y
             + (double)rtDW.Dtg_FLL);
         }
 
-        /* End of Switch: '<S860>/Switch' */
+        /* End of Switch: '<S906>/Switch' */
 
-        /* MATLAB Function: '<S861>/step' */
+        /* MATLAB Function: '<S907>/step' */
         Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S861>/time for step' */
-        timeforstep_j(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S907>/time for step' */
+        timeforstep_j(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Switch: '<S861>/Switch' incorporates:
-         *  Constant: '<S874>/epsilon'
-         *  DataStoreRead: '<S861>/Текущее значение blower '
-         *  DataStoreRead: '<S861>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S874>/Relational Operator'
-         *  RelationalOperator: '<S878>/Relational Operator'
-         *  Sum: '<S874>/Add'
-         *  Switch: '<S878>/Switch'
+        /* Switch: '<S907>/Switch' incorporates:
+         *  Constant: '<S920>/epsilon'
+         *  DataStoreRead: '<S907>/Текущее значение blower '
+         *  DataStoreRead: '<S907>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S920>/Relational Operator'
+         *  RelationalOperator: '<S924>/Relational Operator'
+         *  Sum: '<S920>/Add'
+         *  Switch: '<S924>/Switch'
          */
         if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
-          /* DataStoreWrite: '<S824>/Data Store Write11' */
+          /* DataStoreWrite: '<S870>/Data Store Write11' */
           rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
         } else {
           if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
-            /* Switch: '<S878>/Switch' incorporates:
-             *  Constant: '<S878>/Constant'
+            /* Switch: '<S924>/Switch' incorporates:
+             *  Constant: '<S924>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S878>/Switch' incorporates:
-             *  Constant: '<S878>/Constant1'
+            /* Switch: '<S924>/Switch' incorporates:
+             *  Constant: '<S924>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S824>/Data Store Write11' incorporates:
-           *  Constant: '<S861>/Constant'
-           *  DataStoreRead: '<S861>/текущее время в мс'
-           *  Product: '<S861>/Product1'
-           *  Product: '<S861>/change rate (dtg//sec)'
-           *  Product: '<S861>/скорость в мс'
-           *  Product: '<S861>/шаг изменения'
-           *  Sum: '<S861>/Add'
-           *  Sum: '<S875>/Subtract'
-           *  Switch: '<S878>/Switch'
-           *  UnitDelay: '<S875>/Unit Delay'
+          /* DataStoreWrite: '<S870>/Data Store Write11' incorporates:
+           *  Constant: '<S907>/Constant'
+           *  DataStoreRead: '<S907>/текущее время в мс'
+           *  Product: '<S907>/Product1'
+           *  Product: '<S907>/change rate (dtg//sec)'
+           *  Product: '<S907>/скорость в мс'
+           *  Product: '<S907>/шаг изменения'
+           *  Sum: '<S907>/Add'
+           *  Sum: '<S921>/Subtract'
+           *  Switch: '<S924>/Switch'
+           *  UnitDelay: '<S921>/Unit Delay'
            */
-          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gf) * (double)
-            q0 + (double)rtDW.Dtg_FUL);
+          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gf) * (double)y
+            + (double)rtDW.Dtg_FUL);
         }
 
-        /* End of Switch: '<S861>/Switch' */
+        /* End of Switch: '<S907>/Switch' */
 
-        /* DataStoreWrite: '<S824>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S824>/incar filter up'
+        /* DataStoreWrite: '<S870>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S870>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S824>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S824>/incar filter down'
+        /* DataStoreWrite: '<S870>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S870>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Sum: '<S884>/Add' incorporates:
-         *  DataStoreRead: '<S867>/Текущее значение blower '
-         *  DataStoreRead: '<S867>/значение auto (в соответствии с логикой)'
+        /* Sum: '<S930>/Add' incorporates:
+         *  DataStoreRead: '<S913>/Текущее значение blower '
+         *  DataStoreRead: '<S913>/значение auto (в соответствии с логикой)'
          */
         rtb_Gain_ge = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);
 
-        /* MATLAB Function: '<S867>/step' */
-        step_j(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S913>/step' */
+        step_j(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* MATLAB Function: '<S867>/time for step' */
+        /* MATLAB Function: '<S913>/time for step' */
         timeforstep_g(rtB.Merge_b, &rtb_u_cuz);
 
-        /* Switch: '<S867>/Switch' incorporates:
-         *  Constant: '<S884>/epsilon'
-         *  DataStoreRead: '<S867>/Текущее значение blower '
-         *  DataStoreRead: '<S867>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S884>/Relational Operator'
-         *  RelationalOperator: '<S888>/Relational Operator'
-         *  Switch: '<S888>/Switch'
+        /* Switch: '<S913>/Switch' incorporates:
+         *  Constant: '<S930>/epsilon'
+         *  DataStoreRead: '<S913>/Текущее значение blower '
+         *  DataStoreRead: '<S913>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S930>/Relational Operator'
+         *  RelationalOperator: '<S934>/Relational Operator'
+         *  Switch: '<S934>/Switch'
          */
         if (rtb_Gain_ge <= 0.01) {
-          /* DataStoreWrite: '<S824>/Data Store Write3' incorporates:
-           *  DataStoreRead: '<S867>/значение auto (в соответствии с логикой)'
+          /* DataStoreWrite: '<S870>/Data Store Write3' incorporates:
+           *  DataStoreRead: '<S913>/значение auto (в соответствии с логикой)'
            */
           rtDW.Mode_FL = rtDW.Mode_logic_FL;
         } else {
           if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
-            /* Switch: '<S888>/Switch' incorporates:
-             *  Constant: '<S888>/Constant'
+            /* Switch: '<S934>/Switch' incorporates:
+             *  Constant: '<S934>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S888>/Switch' incorporates:
-             *  Constant: '<S888>/Constant1'
+            /* Switch: '<S934>/Switch' incorporates:
+             *  Constant: '<S934>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S824>/Data Store Write3' incorporates:
-           *  Constant: '<S867>/Constant'
-           *  DataStoreRead: '<S867>/Текущее значение blower '
-           *  DataStoreRead: '<S867>/текущее время в мс'
-           *  Product: '<S867>/Product1'
-           *  Product: '<S867>/change rate (step//sec)'
-           *  Product: '<S867>/скорость в мс'
-           *  Product: '<S867>/шаг изменения'
-           *  Sum: '<S867>/Add'
-           *  Sum: '<S885>/Subtract'
-           *  Switch: '<S888>/Switch'
-           *  UnitDelay: '<S885>/Unit Delay'
+          /* DataStoreWrite: '<S870>/Data Store Write3' incorporates:
+           *  Constant: '<S913>/Constant'
+           *  DataStoreRead: '<S913>/Текущее значение blower '
+           *  DataStoreRead: '<S913>/текущее время в мс'
+           *  Product: '<S913>/Product1'
+           *  Product: '<S913>/change rate (step//sec)'
+           *  Product: '<S913>/скорость в мс'
+           *  Product: '<S913>/шаг изменения'
+           *  Sum: '<S913>/Add'
+           *  Sum: '<S931>/Subtract'
+           *  Switch: '<S934>/Switch'
+           *  UnitDelay: '<S931>/Unit Delay'
            */
-          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain2_c / (double)rtb_u_cuz /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_l) * (double)q0
+          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain2_hu / (double)rtb_u_cuz /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_l) * (double)y
             + (double)rtDW.Mode_FL);
         }
 
-        /* End of Switch: '<S867>/Switch' */
+        /* End of Switch: '<S913>/Switch' */
 
-        /* MATLAB Function: '<S824>/window heating' */
+        /* MATLAB Function: '<S870>/window heating' */
         windowheating_k(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* Sum: '<S879>/Add' incorporates:
-         *  DataStoreRead: '<S864>/Текущее значение blower '
-         *  DataStoreRead: '<S864>/значение auto (в соответствии с логикой)'
+        /* Sum: '<S925>/Add' incorporates:
+         *  DataStoreRead: '<S910>/Текущее значение blower '
+         *  DataStoreRead: '<S910>/значение auto (в соответствии с логикой)'
          */
-        rtb_out_ee = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);
+        rtb_out_oc = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);
 
-        /* RelationalOperator: '<S879>/Relational Operator' incorporates:
-         *  Constant: '<S879>/epsilon'
+        /* RelationalOperator: '<S925>/Relational Operator' incorporates:
+         *  Constant: '<S925>/epsilon'
          */
-        rtb_LogicalOperator1 = (rtb_out_ee <= 0.01);
+        rtb_LogicalOperator1 = (rtb_out_oc <= 0.01);
 
-        /* MATLAB Function: '<S864>/blower step' */
-        blowerstep(rtB.Merge_b, &rtb_out_bc);
+        /* MATLAB Function: '<S910>/blower step' */
+        blowerstep(rtB.Merge_b, &rtb_out_jn);
 
-        /* MATLAB Function: '<S864>/blower time for step' */
-        blowertimeforstep(rtB.Merge_b, &rtb_out_ee);
+        /* MATLAB Function: '<S910>/blower time for step' */
+        blowertimeforstep(rtB.Merge_b, &rtb_out_oc);
 
-        /* Switch: '<S864>/Switch' incorporates:
-         *  DataStoreRead: '<S864>/Текущее значение blower '
-         *  DataStoreRead: '<S864>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S883>/Relational Operator'
-         *  Switch: '<S883>/Switch'
+        /* Switch: '<S910>/Switch' incorporates:
+         *  DataStoreRead: '<S910>/Текущее значение blower '
+         *  DataStoreRead: '<S910>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S929>/Relational Operator'
+         *  Switch: '<S929>/Switch'
          */
         if (rtb_LogicalOperator1) {
-          /* DataStoreWrite: '<S824>/Data Store Write6' incorporates:
-           *  DataStoreRead: '<S864>/значение auto (в соответствии с логикой)'
+          /* DataStoreWrite: '<S870>/Data Store Write6' incorporates:
+           *  DataStoreRead: '<S910>/значение auto (в соответствии с логикой)'
            */
           rtDW.Blower_FL = rtDW.Blower_logic_FL;
         } else {
           if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
-            /* Switch: '<S883>/Switch' incorporates:
-             *  Constant: '<S883>/Constant'
+            /* Switch: '<S929>/Switch' incorporates:
+             *  Constant: '<S929>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S883>/Switch' incorporates:
-             *  Constant: '<S883>/Constant1'
+            /* Switch: '<S929>/Switch' incorporates:
+             *  Constant: '<S929>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S824>/Data Store Write6' incorporates:
-           *  Constant: '<S864>/Constant'
-           *  DataStoreRead: '<S864>/Текущее значение blower '
-           *  DataStoreRead: '<S864>/текущее время в мс'
-           *  Product: '<S864>/Product1'
-           *  Product: '<S864>/change rate (step//sec)'
-           *  Product: '<S864>/скорость в мс'
-           *  Product: '<S864>/шаг изменения'
-           *  Sum: '<S864>/Add'
-           *  Sum: '<S880>/Subtract'
-           *  Switch: '<S883>/Switch'
-           *  UnitDelay: '<S880>/Unit Delay'
+          /* DataStoreWrite: '<S870>/Data Store Write6' incorporates:
+           *  Constant: '<S910>/Constant'
+           *  DataStoreRead: '<S910>/Текущее значение blower '
+           *  DataStoreRead: '<S910>/текущее время в мс'
+           *  Product: '<S910>/Product1'
+           *  Product: '<S910>/change rate (step//sec)'
+           *  Product: '<S910>/скорость в мс'
+           *  Product: '<S910>/шаг изменения'
+           *  Sum: '<S910>/Add'
+           *  Sum: '<S926>/Subtract'
+           *  Switch: '<S929>/Switch'
+           *  UnitDelay: '<S926>/Unit Delay'
            */
-          rtDW.Blower_FL = (uint16_t)((double)rtb_out_bc / (double)rtb_out_ee /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p0) * (double)
-            q0 + (double)rtDW.Blower_FL);
+          rtDW.Blower_FL = (uint16_t)((double)rtb_out_jn / (double)rtb_out_oc /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p0) * (double)y
+            + (double)rtDW.Blower_FL);
         }
 
-        /* End of Switch: '<S864>/Switch' */
+        /* End of Switch: '<S910>/Switch' */
 
-        /* DataStoreWrite: '<S824>/Data Store Write7' incorporates:
-         *  Constant: '<S824>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S870>/Data Store Write7' incorporates:
+         *  Constant: '<S870>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* RelationalOperator: '<S824>/Equal' incorporates:
-         *  DataStoreRead: '<S824>/current step'
+        /* RelationalOperator: '<S870>/Equal' incorporates:
+         *  DataStoreRead: '<S870>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 2);
 
-        /* Sum: '<S862>/Subtract' incorporates:
-         *  DataStoreRead: '<S862>/Data Store Read4'
-         *  UnitDelay: '<S862>/t_start_delay_private '
+        /* Sum: '<S908>/Subtract' incorporates:
+         *  DataStoreRead: '<S908>/Data Store Read4'
+         *  UnitDelay: '<S908>/t_start_delay_private '
          */
         rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_mz;
 
-        /* Switch: '<S862>/Switch' incorporates:
-         *  DataStoreRead: '<S862>/Data Store Read4'
-         *  Logic: '<S862>/Logical Operator3'
-         *  Logic: '<S862>/Logical Operator4'
-         *  UnitDelay: '<S862>/Cond_prev_private '
-         *  UnitDelay: '<S862>/t_start_delay_private '
+        /* Switch: '<S908>/Switch' incorporates:
+         *  DataStoreRead: '<S908>/Data Store Read4'
+         *  Logic: '<S908>/Logical Operator3'
+         *  Logic: '<S908>/Logical Operator4'
+         *  UnitDelay: '<S908>/Cond_prev_private '
+         *  UnitDelay: '<S908>/t_start_delay_private '
          */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_b3)) {
           rtDW.t_start_delay_private_DSTATE_mz = rtDW.t_now;
         }
 
-        /* End of Switch: '<S862>/Switch' */
+        /* End of Switch: '<S908>/Switch' */
 
-        /* MATLAB Function: '<S824>/Time goto from step 2 to step 3 ' */
+        /* MATLAB Function: '<S870>/Time goto from step 2 to step 3 ' */
         Timegotofromstep2tostep3(rtB.Merge_b, &Incar_FL);
 
-        /* Switch: '<S824>/Switch' incorporates:
-         *  Gain: '<S824>/из сек в мс'
-         *  RelationalOperator: '<S824>/Relational Operator1'
+        /* Switch: '<S870>/Switch' incorporates:
+         *  Gain: '<S870>/из сек в мс'
+         *  RelationalOperator: '<S870>/Relational Operator1'
          */
         if (rtb_dt_fa > (uint32_t)(1000 * Incar_FL)) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S824>/go to next step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S870>/go to next step'
            */
           rtB.Merge_ho = 3;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S824>/stay at step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S870>/stay at step'
            */
           rtB.Merge_ho = 2;
         }
 
-        /* End of Switch: '<S824>/Switch' */
+        /* End of Switch: '<S870>/Switch' */
 
-        /* Update for UnitDelay: '<S870>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S860>/текущее время в мс'
+        /* Update for UnitDelay: '<S916>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S906>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_m = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S875>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S861>/текущее время в мс'
+        /* Update for UnitDelay: '<S921>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S907>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_gf = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S885>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S867>/текущее время в мс'
+        /* Update for UnitDelay: '<S931>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S913>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_l = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S880>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S864>/текущее время в мс'
+        /* Update for UnitDelay: '<S926>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S910>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_p0 = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S862>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S908>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_b3 = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S725>/Level 1' */
+        /* End of Outputs for SubSystem: '<S771>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S725>/Level 2' incorporates:
-         *  ActionPort: '<S825>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S771>/Level 2' incorporates:
+         *  ActionPort: '<S871>/Action Port'
          */
-        /* Merge: '<S720>/Merge' incorporates:
-         *  Constant: '<S825>/Constant'
-         *  SignalConversion generated from: '<S825>/step'
+        /* Merge: '<S766>/Merge' incorporates:
+         *  Constant: '<S871>/Constant'
+         *  SignalConversion generated from: '<S871>/step'
          */
         rtB.Merge_ho = 3;
 
-        /* End of Outputs for SubSystem: '<S725>/Level 2' */
+        /* End of Outputs for SubSystem: '<S771>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S725>/Level 3' incorporates:
-         *  ActionPort: '<S826>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S771>/Level 3' incorporates:
+         *  ActionPort: '<S872>/Action Port'
          */
-        Level3(&rtB.Merge_ho, &Autodefog, &rtDW.Blower_FL, &rtb_out_ee,
+        Level3(&rtB.Merge_ho, &Autodefog, &rtDW.Blower_FL, &rtb_out_oc,
                &rtDW.Blower_logic_FL, &rtDW.Dtg_FLL, &Valve_2_way, &rtDW.Dtg_FUL,
                &Dtg_FUR, &rtDW.Dtg_logic_FLL, &rtDW.Dtg_logic_FUL,
-               &El_window_heating, &rtDW.HI_logic_on, &rtb_Gain2_c, &rtb_Gain_ge,
-               &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtDW.Mode_logic_FL,
-               &rtb_Divide1, &rtb_u_cuz, &rtDW.step_start_controle_front,
-               &rtDW.t_now, &rtDW.Level3_l);
+               &El_window_heating, &rtDW.HI_logic_on, &rtb_Gain2_hu,
+               &rtb_Gain_ge, &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR,
+               &rtDW.Mode_logic_FL, &rtb_Divide1, &rtb_u_cuz,
+               &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level3_l);
 
-        /* End of Outputs for SubSystem: '<S725>/Level 3' */
+        /* End of Outputs for SubSystem: '<S771>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S725>/Level 4' incorporates:
-         *  ActionPort: '<S827>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S771>/Level 4' incorporates:
+         *  ActionPort: '<S873>/Action Port'
          */
-        Level3(&rtB.Merge_ho, &Autodefog, &rtDW.Blower_FL, &rtb_out_ee,
+        Level3(&rtB.Merge_ho, &Autodefog, &rtDW.Blower_FL, &rtb_out_oc,
                &rtDW.Blower_logic_FL, &rtDW.Dtg_FLL, &Valve_2_way, &rtDW.Dtg_FUL,
                &Dtg_FUR, &rtDW.Dtg_logic_FLL, &rtDW.Dtg_logic_FUL,
-               &El_window_heating, &rtDW.HI_logic_on, &rtb_Gain2_c, &rtb_Gain_ge,
-               &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtDW.Mode_logic_FL,
-               &rtb_Divide1, &rtb_u_cuz, &rtDW.step_start_controle_front,
-               &rtDW.t_now, &rtDW.Level4_a);
+               &El_window_heating, &rtDW.HI_logic_on, &rtb_Gain2_hu,
+               &rtb_Gain_ge, &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR,
+               &rtDW.Mode_logic_FL, &rtb_Divide1, &rtb_u_cuz,
+               &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level4_a);
 
-        /* End of Outputs for SubSystem: '<S725>/Level 4' */
+        /* End of Outputs for SubSystem: '<S771>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S725>/Level 5' incorporates:
-         *  ActionPort: '<S828>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S771>/Level 5' incorporates:
+         *  ActionPort: '<S874>/Action Port'
          */
-        /* DataStoreWrite: '<S828>/Data Store Write8' incorporates:
-         *  MATLAB Function: '<S828>/3 way valve status'
+        /* DataStoreWrite: '<S874>/Data Store Write8' incorporates:
+         *  MATLAB Function: '<S874>/3 way valve status'
          */
         uwayvalvestatus_a(rtB.Merge_b, &rtb_u_cuz);
 
-        /* MATLAB Function: '<S952>/step' */
+        /* MATLAB Function: '<S998>/step' */
         Dtg_FrontLower_X(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S952>/time for step' */
-        timeforstep(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S998>/time for step' */
+        timeforstep(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Switch: '<S952>/Switch' incorporates:
-         *  Constant: '<S962>/epsilon'
-         *  DataStoreRead: '<S952>/Текущее значение blower '
-         *  DataStoreRead: '<S952>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S962>/Relational Operator'
-         *  RelationalOperator: '<S966>/Relational Operator'
-         *  Sum: '<S962>/Add'
-         *  Switch: '<S966>/Switch'
+        /* Switch: '<S998>/Switch' incorporates:
+         *  Constant: '<S1008>/epsilon'
+         *  DataStoreRead: '<S998>/Текущее значение blower '
+         *  DataStoreRead: '<S998>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S1008>/Relational Operator'
+         *  RelationalOperator: '<S1012>/Relational Operator'
+         *  Sum: '<S1008>/Add'
+         *  Switch: '<S1012>/Switch'
          */
         if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
-          /* DataStoreWrite: '<S828>/Data Store Write13' */
+          /* DataStoreWrite: '<S874>/Data Store Write13' */
           rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
         } else {
           if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
-            /* Switch: '<S966>/Switch' incorporates:
-             *  Constant: '<S966>/Constant'
+            /* Switch: '<S1012>/Switch' incorporates:
+             *  Constant: '<S1012>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S966>/Switch' incorporates:
-             *  Constant: '<S966>/Constant1'
+            /* Switch: '<S1012>/Switch' incorporates:
+             *  Constant: '<S1012>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S828>/Data Store Write13' incorporates:
-           *  Constant: '<S952>/Constant'
-           *  DataStoreRead: '<S952>/текущее время в мс'
-           *  Product: '<S952>/Product1'
-           *  Product: '<S952>/change rate (dtg//sec)'
-           *  Product: '<S952>/скорость в мс'
-           *  Product: '<S952>/шаг изменения'
-           *  Sum: '<S952>/Add'
-           *  Sum: '<S963>/Subtract'
-           *  Switch: '<S966>/Switch'
-           *  UnitDelay: '<S963>/Unit Delay'
+          /* DataStoreWrite: '<S874>/Data Store Write13' incorporates:
+           *  Constant: '<S998>/Constant'
+           *  DataStoreRead: '<S998>/текущее время в мс'
+           *  Product: '<S998>/Product1'
+           *  Product: '<S998>/change rate (dtg//sec)'
+           *  Product: '<S998>/скорость в мс'
+           *  Product: '<S998>/шаг изменения'
+           *  Sum: '<S1009>/Subtract'
+           *  Sum: '<S998>/Add'
+           *  Switch: '<S1012>/Switch'
+           *  UnitDelay: '<S1009>/Unit Delay'
            */
-          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_f) * (double)q0
+          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_f) * (double)y
             + (double)rtDW.Dtg_FLL);
         }
 
-        /* End of Switch: '<S952>/Switch' */
+        /* End of Switch: '<S998>/Switch' */
 
-        /* MATLAB Function: '<S953>/step' */
+        /* MATLAB Function: '<S999>/step' */
         Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S953>/time for step' */
-        timeforstep_j(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S999>/time for step' */
+        timeforstep_j(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Switch: '<S953>/Switch' incorporates:
-         *  Constant: '<S967>/epsilon'
-         *  DataStoreRead: '<S953>/Текущее значение blower '
-         *  DataStoreRead: '<S953>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S967>/Relational Operator'
-         *  RelationalOperator: '<S971>/Relational Operator'
-         *  Sum: '<S967>/Add'
-         *  Switch: '<S971>/Switch'
+        /* Switch: '<S999>/Switch' incorporates:
+         *  Constant: '<S1013>/epsilon'
+         *  DataStoreRead: '<S999>/Текущее значение blower '
+         *  DataStoreRead: '<S999>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S1013>/Relational Operator'
+         *  RelationalOperator: '<S1017>/Relational Operator'
+         *  Sum: '<S1013>/Add'
+         *  Switch: '<S1017>/Switch'
          */
         if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
-          /* DataStoreWrite: '<S828>/Data Store Write11' */
+          /* DataStoreWrite: '<S874>/Data Store Write11' */
           rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
         } else {
           if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
-            /* Switch: '<S971>/Switch' incorporates:
-             *  Constant: '<S971>/Constant'
+            /* Switch: '<S1017>/Switch' incorporates:
+             *  Constant: '<S1017>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S971>/Switch' incorporates:
-             *  Constant: '<S971>/Constant1'
+            /* Switch: '<S1017>/Switch' incorporates:
+             *  Constant: '<S1017>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S828>/Data Store Write11' incorporates:
-           *  Constant: '<S953>/Constant'
-           *  DataStoreRead: '<S953>/текущее время в мс'
-           *  Product: '<S953>/Product1'
-           *  Product: '<S953>/change rate (dtg//sec)'
-           *  Product: '<S953>/скорость в мс'
-           *  Product: '<S953>/шаг изменения'
-           *  Sum: '<S953>/Add'
-           *  Sum: '<S968>/Subtract'
-           *  Switch: '<S971>/Switch'
-           *  UnitDelay: '<S968>/Unit Delay'
+          /* DataStoreWrite: '<S874>/Data Store Write11' incorporates:
+           *  Constant: '<S999>/Constant'
+           *  DataStoreRead: '<S999>/текущее время в мс'
+           *  Product: '<S999>/Product1'
+           *  Product: '<S999>/change rate (dtg//sec)'
+           *  Product: '<S999>/скорость в мс'
+           *  Product: '<S999>/шаг изменения'
+           *  Sum: '<S1014>/Subtract'
+           *  Sum: '<S999>/Add'
+           *  Switch: '<S1017>/Switch'
+           *  UnitDelay: '<S1014>/Unit Delay'
            */
-          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_pu) * (double)
-            q0 + (double)rtDW.Dtg_FUL);
+          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_pu) * (double)y
+            + (double)rtDW.Dtg_FUL);
         }
 
-        /* End of Switch: '<S953>/Switch' */
+        /* End of Switch: '<S999>/Switch' */
 
-        /* DataStoreWrite: '<S828>/Data Store Write' incorporates:
-         *  MATLAB Function: '<S828>/incar filter up'
+        /* DataStoreWrite: '<S874>/Data Store Write' incorporates:
+         *  MATLAB Function: '<S874>/incar filter up'
          */
         incarfilterup(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S828>/Data Store Write1' incorporates:
-         *  MATLAB Function: '<S828>/incar filter down'
+        /* DataStoreWrite: '<S874>/Data Store Write1' incorporates:
+         *  MATLAB Function: '<S874>/incar filter down'
          */
-        incarfilterdown(rtB.Merge_b, &rtb_Gain2_c);
+        incarfilterdown(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* MATLAB Function: '<S828>/autodemist (autodefog)' */
+        /* MATLAB Function: '<S874>/autodemist (autodefog)' */
         autodemistautodefog(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* Sum: '<S977>/Add' incorporates:
-         *  DataStoreRead: '<S960>/Текущее значение blower '
-         *  DataStoreRead: '<S960>/значение auto (в соответствии с логикой)'
+        /* Sum: '<S1023>/Add' incorporates:
+         *  DataStoreRead: '<S1006>/Текущее значение blower '
+         *  DataStoreRead: '<S1006>/значение auto (в соответствии с логикой)'
          */
-        rtb_Gain2_c = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);
+        rtb_Gain2_hu = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);
 
-        /* MATLAB Function: '<S960>/step' */
+        /* MATLAB Function: '<S1006>/step' */
         step_j(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S960>/time for step' */
+        /* MATLAB Function: '<S1006>/time for step' */
         timeforstep_g(rtB.Merge_b, &rtb_u_cuz);
 
-        /* Switch: '<S960>/Switch' incorporates:
-         *  Constant: '<S977>/epsilon'
-         *  DataStoreRead: '<S960>/Текущее значение blower '
-         *  DataStoreRead: '<S960>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S977>/Relational Operator'
-         *  RelationalOperator: '<S981>/Relational Operator'
-         *  Switch: '<S981>/Switch'
+        /* Switch: '<S1006>/Switch' incorporates:
+         *  Constant: '<S1023>/epsilon'
+         *  DataStoreRead: '<S1006>/Текущее значение blower '
+         *  DataStoreRead: '<S1006>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S1023>/Relational Operator'
+         *  RelationalOperator: '<S1027>/Relational Operator'
+         *  Switch: '<S1027>/Switch'
          */
-        if (rtb_Gain2_c <= 0.01) {
-          /* DataStoreWrite: '<S828>/Data Store Write3' incorporates:
-           *  DataStoreRead: '<S960>/значение auto (в соответствии с логикой)'
+        if (rtb_Gain2_hu <= 0.01) {
+          /* DataStoreWrite: '<S874>/Data Store Write3' incorporates:
+           *  DataStoreRead: '<S1006>/значение auto (в соответствии с логикой)'
            */
           rtDW.Mode_FL = rtDW.Mode_logic_FL;
         } else {
           if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
-            /* Switch: '<S981>/Switch' incorporates:
-             *  Constant: '<S981>/Constant'
+            /* Switch: '<S1027>/Switch' incorporates:
+             *  Constant: '<S1027>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S981>/Switch' incorporates:
-             *  Constant: '<S981>/Constant1'
+            /* Switch: '<S1027>/Switch' incorporates:
+             *  Constant: '<S1027>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S828>/Data Store Write3' incorporates:
-           *  Constant: '<S960>/Constant'
-           *  DataStoreRead: '<S960>/Текущее значение blower '
-           *  DataStoreRead: '<S960>/текущее время в мс'
-           *  Product: '<S960>/Product1'
-           *  Product: '<S960>/change rate (step//sec)'
-           *  Product: '<S960>/скорость в мс'
-           *  Product: '<S960>/шаг изменения'
-           *  Sum: '<S960>/Add'
-           *  Sum: '<S978>/Subtract'
-           *  Switch: '<S981>/Switch'
-           *  UnitDelay: '<S978>/Unit Delay'
+          /* DataStoreWrite: '<S874>/Data Store Write3' incorporates:
+           *  Constant: '<S1006>/Constant'
+           *  DataStoreRead: '<S1006>/Текущее значение blower '
+           *  DataStoreRead: '<S1006>/текущее время в мс'
+           *  Product: '<S1006>/Product1'
+           *  Product: '<S1006>/change rate (step//sec)'
+           *  Product: '<S1006>/скорость в мс'
+           *  Product: '<S1006>/шаг изменения'
+           *  Sum: '<S1006>/Add'
+           *  Sum: '<S1024>/Subtract'
+           *  Switch: '<S1027>/Switch'
+           *  UnitDelay: '<S1024>/Unit Delay'
            */
           rtDW.Mode_FL = (uint8_t)((double)rtb_Gain_ge / (double)rtb_u_cuz /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_b) * (double)q0
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_b) * (double)y
             + (double)rtDW.Mode_FL);
         }
 
-        /* End of Switch: '<S960>/Switch' */
+        /* End of Switch: '<S1006>/Switch' */
 
-        /* MATLAB Function: '<S828>/window heating' */
-        windowheating_k(rtB.Merge_b, &rtb_Gain2_c);
+        /* MATLAB Function: '<S874>/window heating' */
+        windowheating_k(rtB.Merge_b, &rtb_Gain2_hu);
 
-        /* Sum: '<S972>/Add' incorporates:
-         *  DataStoreRead: '<S957>/Текущее значение blower '
-         *  DataStoreRead: '<S957>/значение auto (в соответствии с логикой)'
+        /* Sum: '<S1018>/Add' incorporates:
+         *  DataStoreRead: '<S1003>/Текущее значение blower '
+         *  DataStoreRead: '<S1003>/значение auto (в соответствии с логикой)'
          */
-        rtb_out_ee = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);
+        rtb_out_oc = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);
 
-        /* RelationalOperator: '<S972>/Relational Operator' incorporates:
-         *  Constant: '<S972>/epsilon'
+        /* RelationalOperator: '<S1018>/Relational Operator' incorporates:
+         *  Constant: '<S1018>/epsilon'
          */
-        rtb_LogicalOperator1 = (rtb_out_ee <= 0.01);
+        rtb_LogicalOperator1 = (rtb_out_oc <= 0.01);
 
-        /* MATLAB Function: '<S957>/blower step' */
-        blowerstep(rtB.Merge_b, &rtb_out_bc);
+        /* MATLAB Function: '<S1003>/blower step' */
+        blowerstep(rtB.Merge_b, &rtb_out_jn);
 
-        /* MATLAB Function: '<S957>/blower time for step' */
-        blowertimeforstep(rtB.Merge_b, &rtb_out_ee);
+        /* MATLAB Function: '<S1003>/blower time for step' */
+        blowertimeforstep(rtB.Merge_b, &rtb_out_oc);
 
-        /* Switch: '<S957>/Switch' incorporates:
-         *  DataStoreRead: '<S957>/Текущее значение blower '
-         *  DataStoreRead: '<S957>/значение auto (в соответствии с логикой)'
-         *  RelationalOperator: '<S976>/Relational Operator'
-         *  Switch: '<S976>/Switch'
+        /* Switch: '<S1003>/Switch' incorporates:
+         *  DataStoreRead: '<S1003>/Текущее значение blower '
+         *  DataStoreRead: '<S1003>/значение auto (в соответствии с логикой)'
+         *  RelationalOperator: '<S1022>/Relational Operator'
+         *  Switch: '<S1022>/Switch'
          */
         if (rtb_LogicalOperator1) {
-          /* DataStoreWrite: '<S828>/Data Store Write6' incorporates:
-           *  DataStoreRead: '<S957>/значение auto (в соответствии с логикой)'
+          /* DataStoreWrite: '<S874>/Data Store Write6' incorporates:
+           *  DataStoreRead: '<S1003>/значение auto (в соответствии с логикой)'
            */
           rtDW.Blower_FL = rtDW.Blower_logic_FL;
         } else {
           if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
-            /* Switch: '<S976>/Switch' incorporates:
-             *  Constant: '<S976>/Constant'
+            /* Switch: '<S1022>/Switch' incorporates:
+             *  Constant: '<S1022>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
-            /* Switch: '<S976>/Switch' incorporates:
-             *  Constant: '<S976>/Constant1'
+            /* Switch: '<S1022>/Switch' incorporates:
+             *  Constant: '<S1022>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          /* DataStoreWrite: '<S828>/Data Store Write6' incorporates:
-           *  Constant: '<S957>/Constant'
-           *  DataStoreRead: '<S957>/Текущее значение blower '
-           *  DataStoreRead: '<S957>/текущее время в мс'
-           *  Product: '<S957>/Product1'
-           *  Product: '<S957>/change rate (step//sec)'
-           *  Product: '<S957>/скорость в мс'
-           *  Product: '<S957>/шаг изменения'
-           *  Sum: '<S957>/Add'
-           *  Sum: '<S973>/Subtract'
-           *  Switch: '<S976>/Switch'
-           *  UnitDelay: '<S973>/Unit Delay'
+          /* DataStoreWrite: '<S874>/Data Store Write6' incorporates:
+           *  Constant: '<S1003>/Constant'
+           *  DataStoreRead: '<S1003>/Текущее значение blower '
+           *  DataStoreRead: '<S1003>/текущее время в мс'
+           *  Product: '<S1003>/Product1'
+           *  Product: '<S1003>/change rate (step//sec)'
+           *  Product: '<S1003>/скорость в мс'
+           *  Product: '<S1003>/шаг изменения'
+           *  Sum: '<S1003>/Add'
+           *  Sum: '<S1019>/Subtract'
+           *  Switch: '<S1022>/Switch'
+           *  UnitDelay: '<S1019>/Unit Delay'
            */
-          rtDW.Blower_FL = (uint16_t)((double)rtb_out_bc / (double)rtb_out_ee /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_e) * (double)q0
+          rtDW.Blower_FL = (uint16_t)((double)rtb_out_jn / (double)rtb_out_oc /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_e) * (double)y
             + (double)rtDW.Blower_FL);
         }
 
-        /* End of Switch: '<S957>/Switch' */
+        /* End of Switch: '<S1003>/Switch' */
 
-        /* DataStoreWrite: '<S828>/Data Store Write7' incorporates:
-         *  Constant: '<S828>/Recirc logic Partial REC'
+        /* DataStoreWrite: '<S874>/Data Store Write7' incorporates:
+         *  Constant: '<S874>/Recirc logic Partial REC'
          */
         rtb_Divide1 = 1.0;
 
-        /* RelationalOperator: '<S828>/Equal' incorporates:
-         *  DataStoreRead: '<S828>/current step'
+        /* RelationalOperator: '<S874>/Equal' incorporates:
+         *  DataStoreRead: '<S874>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 2);
 
-        /* MATLAB Function: '<S828>/Time goto from step 2 to step 3 ' */
+        /* MATLAB Function: '<S874>/Time goto from step 2 to step 3 ' */
         Timegotofromstep2tostep3(rtB.Merge_b, &Incar_FL);
 
-        /* RelationalOperator: '<S828>/Relational Operator1' incorporates:
-         *  DataStoreRead: '<S954>/Data Store Read4'
-         *  Gain: '<S828>/из сек в мс'
-         *  Sum: '<S954>/Subtract'
-         *  UnitDelay: '<S954>/t_start_delay_private '
+        /* RelationalOperator: '<S874>/Relational Operator1' incorporates:
+         *  DataStoreRead: '<S1000>/Data Store Read4'
+         *  Gain: '<S874>/из сек в мс'
+         *  Sum: '<S1000>/Subtract'
+         *  UnitDelay: '<S1000>/t_start_delay_private '
          */
         rtb_LogicalOperator1_g = (rtDW.t_now -
           rtDW.t_start_delay_private_DSTATE_nr > (uint32_t)(1000 * Incar_FL));
 
-        /* Switch: '<S954>/Switch' incorporates:
-         *  DataStoreRead: '<S954>/Data Store Read4'
-         *  Logic: '<S954>/Logical Operator3'
-         *  Logic: '<S954>/Logical Operator4'
-         *  UnitDelay: '<S954>/Cond_prev_private '
-         *  UnitDelay: '<S954>/t_start_delay_private '
+        /* Switch: '<S1000>/Switch' incorporates:
+         *  DataStoreRead: '<S1000>/Data Store Read4'
+         *  Logic: '<S1000>/Logical Operator3'
+         *  Logic: '<S1000>/Logical Operator4'
+         *  UnitDelay: '<S1000>/Cond_prev_private '
+         *  UnitDelay: '<S1000>/t_start_delay_private '
          */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_iy)) {
           rtDW.t_start_delay_private_DSTATE_nr = rtDW.t_now;
         }
 
-        /* End of Switch: '<S954>/Switch' */
+        /* End of Switch: '<S1000>/Switch' */
 
-        /* Switch: '<S828>/Switch' incorporates:
-         *  DataStoreRead: '<S828>/Data Store Read'
-         *  Logic: '<S828>/Logical Operator'
+        /* Switch: '<S874>/Switch' incorporates:
+         *  DataStoreRead: '<S874>/Data Store Read'
+         *  Logic: '<S874>/Logical Operator'
          */
         if (rtb_LogicalOperator1_g || rtDW.HI_logic_on) {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S828>/go to next step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S874>/go to next step'
            */
           rtB.Merge_ho = 3;
         } else {
-          /* Merge: '<S720>/Merge' incorporates:
-           *  Constant: '<S828>/stay at step'
+          /* Merge: '<S766>/Merge' incorporates:
+           *  Constant: '<S874>/stay at step'
            */
           rtB.Merge_ho = 2;
         }
 
-        /* End of Switch: '<S828>/Switch' */
+        /* End of Switch: '<S874>/Switch' */
 
-        /* Update for UnitDelay: '<S963>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S952>/текущее время в мс'
+        /* Update for UnitDelay: '<S1009>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S998>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_f = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S968>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S953>/текущее время в мс'
+        /* Update for UnitDelay: '<S1014>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S999>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_pu = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S978>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S960>/текущее время в мс'
+        /* Update for UnitDelay: '<S1024>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1006>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_b = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S973>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S957>/текущее время в мс'
+        /* Update for UnitDelay: '<S1019>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1003>/текущее время в мс'
          */
         rtDW.UnitDelay_DSTATE_e = rtDW.t_now;
 
-        /* Update for UnitDelay: '<S954>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S1000>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_iy = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S725>/Level 5' */
+        /* End of Outputs for SubSystem: '<S771>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S725>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S720>/Step 2 F' */
+      /* End of SwitchCase: '<S771>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S766>/Step 2 F' */
       break;
 
      case 3:
-      /* Outputs for IfAction SubSystem: '<S720>/Step 3 F' incorporates:
-       *  ActionPort: '<S726>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S766>/Step 3 F' incorporates:
+       *  ActionPort: '<S772>/Action Port'
        */
       Step3F(&rtB.Merge_ho, &rtDW.start_control_finished_front);
 
-      /* End of Outputs for SubSystem: '<S720>/Step 3 F' */
+      /* End of Outputs for SubSystem: '<S766>/Step 3 F' */
       break;
     }
 
-    /* End of SwitchCase: '<S720>/Switch Case' */
+    /* End of SwitchCase: '<S766>/Switch Case' */
 
-    /* DataStoreWrite: '<S720>/Data Store Write' */
+    /* DataStoreWrite: '<S766>/Data Store Write' */
     rtDW.step_start_controle_front = rtB.Merge_ho;
 
     /* End of Outputs for SubSystem: '<S8>/Start Control Front' */
@@ -14660,1195 +15558,699 @@ void HVAC_model_step(void)
    */
   if (rtDW.start_control_finished_rear == 0.0) {
     /* Outputs for IfAction SubSystem: '<S8>/Start Control Rear' incorporates:
-     *  ActionPort: '<S721>/Action Port'
+     *  ActionPort: '<S767>/Action Port'
      */
-    /* SwitchCase: '<S721>/Switch Case' incorporates:
-     *  DataStoreRead: '<S721>/Data Store Read'
+    /* SwitchCase: '<S767>/Switch Case' incorporates:
+     *  DataStoreRead: '<S767>/Data Store Read'
      */
     switch (rtDW.step_start_controle_rear) {
      case -1:
-      /* Outputs for IfAction SubSystem: '<S721>/Step -1 R (Entry Condition)' incorporates:
-       *  ActionPort: '<S982>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S767>/Step -1 R (Entry Condition)' incorporates:
+       *  ActionPort: '<S1028>/Action Port'
        */
-      /* SwitchCase: '<S982>/Switch Case' incorporates:
-       *  DataStoreRead: '<S982>/Data Store Read1'
+      /* SwitchCase: '<S1028>/Switch Case' incorporates:
+       *  DataStoreRead: '<S1028>/Data Store Read1'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S982>/Level 0' incorporates:
-         *  ActionPort: '<S987>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1028>/Level 0' incorporates:
+         *  ActionPort: '<S1033>/Action Port'
          */
-        /* MATLAB Function: '<S987>/g_ausSTART_ENTER_SETTEMP' incorporates:
-         *  DataStoreRead: '<S987>/Data Store Read4'
+        /* MATLAB Function: '<S1033>/g_ausSTART_ENTER_SETTEMP' incorporates:
+         *  DataStoreRead: '<S1033>/Data Store Read4'
          */
         /* :  out = int16(g_assSTART_ENTER_INCAR(LVL + 1 + 6)); */
         g_ausSTART_ENTER_SETTEMP_b(rtB.Merge_b, &Incar_FL);
 
-        /* MATLAB Function: '<S987>/g_assSTART_ENTER_INCAR' incorporates:
-         *  DataStoreRead: '<S987>/Data Store Read3'
+        /* MATLAB Function: '<S1033>/g_assSTART_ENTER_INCAR' incorporates:
+         *  DataStoreRead: '<S1033>/Data Store Read3'
          */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        i = (int32_t)((uint32_t)q0 + 6U);
-        if ((uint32_t)q0 + 6U > 255U) {
+        i = (int32_t)((uint32_t)y + 6U);
+        if ((uint32_t)y + 6U > 255U) {
           i = 255;
         }
 
-        /* Switch: '<S987>/Switch' incorporates:
-         *  Constant: '<S987>/AUTO'
-         *  DataStoreRead: '<S987>/Data Store Read'
-         *  DataStoreRead: '<S987>/Data Store Read1'
-         *  DataStoreRead: '<S987>/Data Store Read2'
-         *  Logic: '<S987>/AND'
-         *  MATLAB Function: '<S987>/g_assSTART_ENTER_INCAR'
-         *  RelationalOperator: '<S987>/Relational Operator'
-         *  RelationalOperator: '<S987>/Relational Operator1'
-         *  RelationalOperator: '<S987>/Relational Operator2'
+        /* Switch: '<S1033>/Switch' incorporates:
+         *  Constant: '<S1033>/AUTO'
+         *  DataStoreRead: '<S1033>/Data Store Read'
+         *  DataStoreRead: '<S1033>/Data Store Read1'
+         *  DataStoreRead: '<S1033>/Data Store Read2'
+         *  Logic: '<S1033>/AND'
+         *  MATLAB Function: '<S1033>/g_assSTART_ENTER_INCAR'
+         *  RelationalOperator: '<S1033>/Relational Operator'
+         *  RelationalOperator: '<S1033>/Relational Operator1'
+         *  RelationalOperator: '<S1033>/Relational Operator2'
          */
         if ((Incar_RR > g_assSTART_ENTER_INCAR[i - 1]) &&
-            (rtDW.MODE_RR_passenger == 1.0) && (rtDW.FIU_SET_RR < Incar_FL)) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S987>/Constant1'
+            (rtDW.MODE_RR_passenger == 1.0) && (FIU_SET_RR < Incar_FL)) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1033>/Constant1'
            */
           rtB.Merge_c = 0;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S987>/Constant'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1033>/Constant'
            */
           rtB.Merge_c = -1;
         }
 
-        /* End of Switch: '<S987>/Switch' */
-        /* End of Outputs for SubSystem: '<S982>/Level 0' */
+        /* End of Switch: '<S1033>/Switch' */
+        /* End of Outputs for SubSystem: '<S1028>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S982>/Level 1' incorporates:
-         *  ActionPort: '<S988>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1028>/Level 1' incorporates:
+         *  ActionPort: '<S1034>/Action Port'
          */
-        /* MATLAB Function: '<S988>/g_assSTART_ENTER_INCAR' incorporates:
-         *  DataStoreRead: '<S988>/Data Store Read3'
+        /* MATLAB Function: '<S1034>/g_assSTART_ENTER_INCAR' incorporates:
+         *  DataStoreRead: '<S1034>/Data Store Read3'
          */
         g_assSTART_ENTER_INCAR_p(rtB.Merge_b, &Incar_FL);
 
-        /* MATLAB Function: '<S988>/g_ausSTART_ENTER_SETTEMP' incorporates:
-         *  DataStoreRead: '<S988>/Data Store Read4'
+        /* MATLAB Function: '<S1034>/g_ausSTART_ENTER_SETTEMP' incorporates:
+         *  DataStoreRead: '<S1034>/Data Store Read4'
          */
         g_ausSTART_ENTER_SETTEMP_b(rtB.Merge_b, &Eva_F);
 
-        /* Switch: '<S988>/Switch' incorporates:
-         *  Constant: '<S988>/AUTO'
-         *  DataStoreRead: '<S988>/Data Store Read'
-         *  DataStoreRead: '<S988>/Data Store Read1'
-         *  DataStoreRead: '<S988>/Data Store Read2'
-         *  Logic: '<S988>/AND'
-         *  RelationalOperator: '<S988>/Relational Operator'
-         *  RelationalOperator: '<S988>/Relational Operator1'
-         *  RelationalOperator: '<S988>/Relational Operator2'
+        /* Switch: '<S1034>/Switch' incorporates:
+         *  Constant: '<S1034>/AUTO'
+         *  DataStoreRead: '<S1034>/Data Store Read'
+         *  DataStoreRead: '<S1034>/Data Store Read1'
+         *  DataStoreRead: '<S1034>/Data Store Read2'
+         *  Logic: '<S1034>/AND'
+         *  RelationalOperator: '<S1034>/Relational Operator'
+         *  RelationalOperator: '<S1034>/Relational Operator1'
+         *  RelationalOperator: '<S1034>/Relational Operator2'
          */
         if ((Incar_RR > Incar_FL) && (rtDW.MODE_RR_passenger == 1.0) &&
-            (rtDW.FIU_SET_RR < Eva_F)) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S988>/Constant1'
+            (FIU_SET_RR < Eva_F)) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1034>/Constant1'
            */
           rtB.Merge_c = 0;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S988>/Constant'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1034>/Constant'
            */
           rtB.Merge_c = -1;
         }
 
-        /* End of Switch: '<S988>/Switch' */
-        /* End of Outputs for SubSystem: '<S982>/Level 1' */
+        /* End of Switch: '<S1034>/Switch' */
+        /* End of Outputs for SubSystem: '<S1028>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S982>/Level 2' incorporates:
-         *  ActionPort: '<S989>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1028>/Level 2' incorporates:
+         *  ActionPort: '<S1035>/Action Port'
          */
-        /* MATLAB Function: '<S989>/g_assSTART_ENTER_INCAR' incorporates:
-         *  DataStoreRead: '<S989>/Data Store Read3'
+        /* MATLAB Function: '<S1035>/g_assSTART_ENTER_INCAR' incorporates:
+         *  DataStoreRead: '<S1035>/Data Store Read3'
          */
         g_assSTART_ENTER_INCAR_p(rtB.Merge_b, &Incar_FL);
 
-        /* MATLAB Function: '<S989>/g_ausSTART_ENTER_SETTEMP' incorporates:
-         *  DataStoreRead: '<S989>/Data Store Read4'
+        /* MATLAB Function: '<S1035>/g_ausSTART_ENTER_SETTEMP' incorporates:
+         *  DataStoreRead: '<S1035>/Data Store Read4'
          */
         g_ausSTART_ENTER_SETTEMP_b(rtB.Merge_b, &Eva_F);
 
-        /* Switch: '<S989>/Switch' incorporates:
-         *  Constant: '<S989>/AUTO'
-         *  DataStoreRead: '<S989>/Data Store Read'
-         *  DataStoreRead: '<S989>/Data Store Read1'
-         *  DataStoreRead: '<S989>/Data Store Read2'
-         *  Logic: '<S989>/AND'
-         *  RelationalOperator: '<S989>/Relational Operator'
-         *  RelationalOperator: '<S989>/Relational Operator1'
-         *  RelationalOperator: '<S989>/Relational Operator2'
+        /* Switch: '<S1035>/Switch' incorporates:
+         *  Constant: '<S1035>/AUTO'
+         *  DataStoreRead: '<S1035>/Data Store Read'
+         *  DataStoreRead: '<S1035>/Data Store Read1'
+         *  DataStoreRead: '<S1035>/Data Store Read2'
+         *  Logic: '<S1035>/AND'
+         *  RelationalOperator: '<S1035>/Relational Operator'
+         *  RelationalOperator: '<S1035>/Relational Operator1'
+         *  RelationalOperator: '<S1035>/Relational Operator2'
          */
         if ((Incar_RR < Incar_FL) && (rtDW.MODE_RR_passenger == 1.0) &&
-            (rtDW.FIU_SET_RR > Eva_F)) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S989>/Constant1'
+            (FIU_SET_RR > Eva_F)) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1035>/Constant1'
            */
           rtB.Merge_c = 0;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S989>/Constant'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1035>/Constant'
            */
           rtB.Merge_c = -1;
         }
 
-        /* End of Switch: '<S989>/Switch' */
-        /* End of Outputs for SubSystem: '<S982>/Level 2' */
+        /* End of Switch: '<S1035>/Switch' */
+        /* End of Outputs for SubSystem: '<S1028>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S982>/Level 3' incorporates:
-         *  ActionPort: '<S990>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1028>/Level 3' incorporates:
+         *  ActionPort: '<S1036>/Action Port'
          */
-        /* MATLAB Function: '<S990>/g_assSTART_ENTER_INCAR' incorporates:
-         *  DataStoreRead: '<S990>/Data Store Read4'
+        /* MATLAB Function: '<S1036>/g_assSTART_ENTER_INCAR' incorporates:
+         *  DataStoreRead: '<S1036>/Data Store Read4'
          */
         g_assSTART_ENTER_INCAR_p(rtB.Merge_b, &Incar_FL);
 
-        /* MATLAB Function: '<S990>/g_assSTART_ENTER_COOLANT ' incorporates:
-         *  DataStoreRead: '<S990>/Data Store Read3'
+        /* MATLAB Function: '<S1036>/g_assSTART_ENTER_COOLANT ' incorporates:
+         *  DataStoreRead: '<S1036>/Data Store Read3'
          */
         g_assSTART_ENTER_COOLANT_e(rtB.Merge_b, &Eva_F);
 
-        /* MATLAB Function: '<S990>/g_ausSTART_ENTER_SETTEMP' incorporates:
-         *  DataStoreRead: '<S990>/Data Store Read6'
+        /* MATLAB Function: '<S1036>/g_ausSTART_ENTER_SETTEMP' incorporates:
+         *  DataStoreRead: '<S1036>/Data Store Read6'
          */
         /* :  out = int16(g_ausSTART_ENTER_SETTEMP(LVL+1+6)); */
-        q0 = (int32_t)(rtB.Merge_b + 1U);
+        y = (int32_t)(rtB.Merge_b + 1U);
         if (rtB.Merge_b + 1U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        i = (int32_t)((uint32_t)q0 + 6U);
-        if ((uint32_t)q0 + 6U > 255U) {
+        i = (int32_t)((uint32_t)y + 6U);
+        if ((uint32_t)y + 6U > 255U) {
           i = 255;
         }
 
-        rtb_out_ee = g_ausSTART_ENTER_SETTEMP[i - 1];
-        if (rtb_out_ee > 32767) {
-          rtb_out_ee = 32767U;
+        rtb_out_oc = g_ausSTART_ENTER_SETTEMP[i - 1];
+        if (rtb_out_oc > 32767) {
+          rtb_out_oc = 32767U;
         }
 
-        /* Switch: '<S990>/Switch' incorporates:
-         *  Constant: '<S990>/AUTO'
-         *  DataStoreRead: '<S990>/Data Store Read'
-         *  DataStoreRead: '<S990>/Data Store Read1'
-         *  DataStoreRead: '<S990>/Data Store Read2'
-         *  DataStoreRead: '<S990>/Data Store Read5'
-         *  Logic: '<S990>/AND'
-         *  Logic: '<S990>/AND1'
-         *  MATLAB Function: '<S990>/g_ausSTART_ENTER_SETTEMP'
-         *  RelationalOperator: '<S990>/Relational Operator'
-         *  RelationalOperator: '<S990>/Relational Operator1'
-         *  RelationalOperator: '<S990>/Relational Operator2'
-         *  RelationalOperator: '<S990>/Relational Operator3'
+        /* Switch: '<S1036>/Switch' incorporates:
+         *  Constant: '<S1036>/AUTO'
+         *  DataStoreRead: '<S1036>/Data Store Read'
+         *  DataStoreRead: '<S1036>/Data Store Read1'
+         *  DataStoreRead: '<S1036>/Data Store Read2'
+         *  DataStoreRead: '<S1036>/Data Store Read5'
+         *  Logic: '<S1036>/AND'
+         *  Logic: '<S1036>/AND1'
+         *  MATLAB Function: '<S1036>/g_ausSTART_ENTER_SETTEMP'
+         *  RelationalOperator: '<S1036>/Relational Operator'
+         *  RelationalOperator: '<S1036>/Relational Operator1'
+         *  RelationalOperator: '<S1036>/Relational Operator2'
+         *  RelationalOperator: '<S1036>/Relational Operator3'
          */
         if (((Incar_RR < Incar_FL) || (rtDW.ECT < Eva_F)) &&
-            (rtDW.MODE_RR_passenger == 1.0) && (rtDW.FIU_SET_RR > rtb_out_ee)) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S990>/Constant1'
+            (rtDW.MODE_RR_passenger == 1.0) && (FIU_SET_RR > rtb_out_oc)) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1036>/Constant1'
            */
           rtB.Merge_c = 0;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S990>/Constant'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1036>/Constant'
            */
           rtB.Merge_c = -1;
         }
 
-        /* End of Switch: '<S990>/Switch' */
-        /* End of Outputs for SubSystem: '<S982>/Level 3' */
+        /* End of Switch: '<S1036>/Switch' */
+        /* End of Outputs for SubSystem: '<S1028>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S982>/Level 4' incorporates:
-         *  ActionPort: '<S991>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1028>/Level 4' incorporates:
+         *  ActionPort: '<S1037>/Action Port'
          */
         Level4_e(&rtB.Merge_c, &rtDW.ECT, &Incar_RR, &rtB.Merge_b,
                  &rtDW.MODE_RR_passenger);
 
-        /* End of Outputs for SubSystem: '<S982>/Level 4' */
+        /* End of Outputs for SubSystem: '<S1028>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S982>/Level 5' incorporates:
-         *  ActionPort: '<S992>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1028>/Level 5' incorporates:
+         *  ActionPort: '<S1038>/Action Port'
          */
         Level4_e(&rtB.Merge_c, &rtDW.ECT, &Incar_RR, &rtB.Merge_b,
                  &rtDW.MODE_RR_passenger);
 
-        /* End of Outputs for SubSystem: '<S982>/Level 5' */
+        /* End of Outputs for SubSystem: '<S1028>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S982>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S721>/Step -1 R (Entry Condition)' */
+      /* End of SwitchCase: '<S1028>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S767>/Step -1 R (Entry Condition)' */
       break;
 
      case 0:
-      /* Outputs for IfAction SubSystem: '<S721>/Step 0 R' incorporates:
-       *  ActionPort: '<S983>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S767>/Step 0 R' incorporates:
+       *  ActionPort: '<S1029>/Action Port'
        */
-      /* SwitchCase: '<S983>/Switch Case' incorporates:
-       *  DataStoreRead: '<S983>/Data Store Read1'
+      /* SwitchCase: '<S1029>/Switch Case' incorporates:
+       *  DataStoreRead: '<S1029>/Data Store Read1'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S983>/Level 0' incorporates:
-         *  ActionPort: '<S1006>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1029>/Level 0' incorporates:
+         *  ActionPort: '<S1052>/Action Port'
          */
         Level0(&rtB.Merge_c);
 
-        /* End of Outputs for SubSystem: '<S983>/Level 0' */
+        /* End of Outputs for SubSystem: '<S1029>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S983>/Level 1' incorporates:
-         *  ActionPort: '<S1007>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1029>/Level 1' incorporates:
+         *  ActionPort: '<S1053>/Action Port'
          */
         Level0(&rtB.Merge_c);
 
-        /* End of Outputs for SubSystem: '<S983>/Level 1' */
+        /* End of Outputs for SubSystem: '<S1029>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S983>/Level 2' incorporates:
-         *  ActionPort: '<S1008>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1029>/Level 2' incorporates:
+         *  ActionPort: '<S1054>/Action Port'
          */
-        /* DataStoreWrite: '<S1008>/Data Store Write5' incorporates:
-         *  Constant: '<S1008>/Constant2'
+        /* DataStoreWrite: '<S1054>/Data Store Write5' incorporates:
+         *  Constant: '<S1054>/Constant2'
          */
         rtDW.Blower_RR = 10U;
 
-        /* DataStoreWrite: '<S1008>/Data Store Write10' incorporates:
-         *  Constant: '<S1008>/Constant4'
+        /* DataStoreWrite: '<S1054>/Data Store Write10' incorporates:
+         *  Constant: '<S1054>/Constant4'
          */
         rtDW.Dtg_RR = 65U;
 
-        /* MATLAB Function: '<S1008>/incar filter up' incorporates:
-         *  DataStoreRead: '<S1008>/Data Store Read1'
+        /* MATLAB Function: '<S1054>/incar filter up' incorporates:
+         *  DataStoreRead: '<S1054>/Data Store Read1'
          */
         incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S1008>/incar filter down' incorporates:
-         *  DataStoreRead: '<S1008>/Data Store Read2'
+        /* MATLAB Function: '<S1054>/incar filter down' incorporates:
+         *  DataStoreRead: '<S1054>/Data Store Read2'
          */
         incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S1008>/Data Store Write2' incorporates:
-         *  Constant: '<S1008>/Mode - foot'
+        /* DataStoreWrite: '<S1054>/Data Store Write2' incorporates:
+         *  Constant: '<S1054>/Mode - foot'
          */
         rtDW.Mode_RR = 60U;
 
-        /* MATLAB Function: '<S1008>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
-         *  DataStoreRead: '<S1008>/Data Store Read3'
+        /* MATLAB Function: '<S1054>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
+         *  DataStoreRead: '<S1054>/Data Store Read3'
          */
         /* :  out = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 3)); */
-        q0 = (int32_t)(rtB.Merge_b + 3U);
+        y = (int32_t)(rtB.Merge_b + 3U);
         if (rtB.Merge_b + 3U > 255U) {
-          q0 = 255;
+          y = 255;
         }
 
-        /* Merge: '<S721>/Merge' incorporates:
-         *  DataStoreRead: '<S1008>/Engine coolant temp'
-         *  MATLAB Function: '<S1008>/g_assSTART_COOLANT_STEP0_TO_1 '
-         *  RelationalOperator: '<S1008>/Relational Operator'
-         *  Switch: '<S1008>/Switch'
+        /* Merge: '<S767>/Merge' incorporates:
+         *  DataStoreRead: '<S1054>/Engine coolant temp'
+         *  MATLAB Function: '<S1054>/g_assSTART_COOLANT_STEP0_TO_1 '
+         *  RelationalOperator: '<S1054>/Relational Operator'
+         *  Switch: '<S1054>/Switch'
          */
-        rtB.Merge_c = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1[q0 - 1]);
+        rtB.Merge_c = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1[y - 1]);
 
-        /* End of Outputs for SubSystem: '<S983>/Level 2' */
+        /* End of Outputs for SubSystem: '<S1029>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S983>/Level 3' incorporates:
-         *  ActionPort: '<S1009>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1029>/Level 3' incorporates:
+         *  ActionPort: '<S1055>/Action Port'
          */
-        /* DataStoreWrite: '<S1009>/Data Store Write5' incorporates:
-         *  Constant: '<S1009>/Constant2'
+        /* DataStoreWrite: '<S1055>/Data Store Write5' incorporates:
+         *  Constant: '<S1055>/Constant2'
          */
         rtDW.Blower_RR = 10U;
 
-        /* DataStoreWrite: '<S1009>/Data Store Write10' incorporates:
-         *  Constant: '<S1009>/Constant4'
+        /* DataStoreWrite: '<S1055>/Data Store Write10' incorporates:
+         *  Constant: '<S1055>/Constant4'
          */
         rtDW.Dtg_RR = 65U;
 
-        /* MATLAB Function: '<S1009>/incar filter up' incorporates:
-         *  DataStoreRead: '<S1009>/Data Store Read1'
+        /* MATLAB Function: '<S1055>/incar filter up' incorporates:
+         *  DataStoreRead: '<S1055>/Data Store Read1'
          */
         incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S1009>/incar filter down' incorporates:
-         *  DataStoreRead: '<S1009>/Data Store Read2'
+        /* MATLAB Function: '<S1055>/incar filter down' incorporates:
+         *  DataStoreRead: '<S1055>/Data Store Read2'
          */
         incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* DataStoreWrite: '<S1009>/Data Store Write2' incorporates:
-         *  Constant: '<S1009>/Mode - foot'
+        /* DataStoreWrite: '<S1055>/Data Store Write2' incorporates:
+         *  Constant: '<S1055>/Mode - foot'
          */
         rtDW.Mode_RR = 60U;
 
-        /* MATLAB Function: '<S1009>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
-         *  DataStoreRead: '<S1009>/Data Store Read3'
+        /* MATLAB Function: '<S1055>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
+         *  DataStoreRead: '<S1055>/Data Store Read3'
          */
         g_assSTART_COOLANT_STEP0_TO_1_e(rtB.Merge_b, &Incar_RR);
 
-        /* Merge: '<S721>/Merge' incorporates:
-         *  DataStoreRead: '<S1009>/Engine coolant temp'
-         *  RelationalOperator: '<S1009>/Relational Operator'
-         *  Switch: '<S1009>/Switch'
+        /* Merge: '<S767>/Merge' incorporates:
+         *  DataStoreRead: '<S1055>/Engine coolant temp'
+         *  RelationalOperator: '<S1055>/Relational Operator'
+         *  Switch: '<S1055>/Switch'
          */
         rtB.Merge_c = (int8_t)(rtDW.ECT > Incar_RR);
 
-        /* End of Outputs for SubSystem: '<S983>/Level 3' */
+        /* End of Outputs for SubSystem: '<S1029>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S983>/Level 4' incorporates:
-         *  ActionPort: '<S1010>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1029>/Level 4' incorporates:
+         *  ActionPort: '<S1056>/Action Port'
          */
-        Level4_m(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR, &Dtg_FUR,
-                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Gain2_c, &rtb_Gain_ge,
+        Level4_m(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR, &Dtg_FUR,
+                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &Valve_2_way,
                  &rtb_u_cuz);
 
-        /* End of Outputs for SubSystem: '<S983>/Level 4' */
+        /* End of Outputs for SubSystem: '<S1029>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S983>/Level 5' incorporates:
-         *  ActionPort: '<S1011>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1029>/Level 5' incorporates:
+         *  ActionPort: '<S1057>/Action Port'
          */
-        Level4_m(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR, &Dtg_FUR,
-                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Gain2_c, &rtb_Gain_ge,
+        Level4_m(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR, &Dtg_FUR,
+                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &Valve_2_way,
                  &rtb_u_cuz);
 
-        /* End of Outputs for SubSystem: '<S983>/Level 5' */
+        /* End of Outputs for SubSystem: '<S1029>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S983>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S721>/Step 0 R' */
+      /* End of SwitchCase: '<S1029>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S767>/Step 0 R' */
       break;
 
      case 1:
-      /* Outputs for IfAction SubSystem: '<S721>/Step 1 R' incorporates:
-       *  ActionPort: '<S984>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S767>/Step 1 R' incorporates:
+       *  ActionPort: '<S1030>/Action Port'
        */
-      /* SwitchCase: '<S984>/Switch Case' incorporates:
-       *  DataStoreRead: '<S984>/Data Store Read1'
+      /* SwitchCase: '<S1030>/Switch Case' incorporates:
+       *  DataStoreRead: '<S1030>/Data Store Read1'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S984>/Level 0' incorporates:
-         *  ActionPort: '<S1024>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1030>/Level 0' incorporates:
+         *  ActionPort: '<S1070>/Action Port'
          */
-        Level0_b(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR, &Dtg_FUR,
-                 &rtDW.Dtg_RR, &Incar_RR, &rtb_Gain2_c, &rtb_Gain_ge,
+        Level0_b(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR, &Dtg_FUR,
+                 &rtDW.Dtg_RR, &Incar_RR, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1,
                  &Valve_2_way, &rtDW.step_start_controle_rear, &rtDW.t_now,
                  &rtDW.Level0_bc);
 
-        /* End of Outputs for SubSystem: '<S984>/Level 0' */
+        /* End of Outputs for SubSystem: '<S1030>/Level 0' */
         break;
 
        case 1:
-        /* Outputs for IfAction SubSystem: '<S984>/Level 1' incorporates:
-         *  ActionPort: '<S1025>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1030>/Level 1' incorporates:
+         *  ActionPort: '<S1071>/Action Port'
          */
-        Level0_b(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR, &Dtg_FUR,
-                 &rtDW.Dtg_RR, &Incar_RR, &rtb_Gain2_c, &rtb_Gain_ge,
+        Level0_b(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR, &Dtg_FUR,
+                 &rtDW.Dtg_RR, &Incar_RR, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1,
                  &Valve_2_way, &rtDW.step_start_controle_rear, &rtDW.t_now,
                  &rtDW.Level1_d3);
 
-        /* End of Outputs for SubSystem: '<S984>/Level 1' */
+        /* End of Outputs for SubSystem: '<S1030>/Level 1' */
         break;
 
        case 2:
-        /* Outputs for IfAction SubSystem: '<S984>/Level 2' incorporates:
-         *  ActionPort: '<S1026>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1030>/Level 2' incorporates:
+         *  ActionPort: '<S1072>/Action Port'
          */
-        /* DataStoreWrite: '<S1026>/Data Store Write2' incorporates:
-         *  DataStoreRead: '<S1026>/Data Store Read1'
-         *  DataStoreRead: '<S1026>/Data Store Read2'
-         *  DataStoreRead: '<S1026>/Data Store Read5'
-         *  DataStoreRead: '<S1026>/Data Store Read6'
-         *  MATLAB Function: '<S1026>/2 way valve'
-         *  MATLAB Function: '<S1026>/incar filter down'
-         *  MATLAB Function: '<S1026>/incar filter up'
-         *  MATLAB Function: '<S1026>/mode rear step 1'
+        /* DataStoreWrite: '<S1072>/Data Store Write2' incorporates:
+         *  DataStoreRead: '<S1072>/Data Store Read1'
+         *  DataStoreRead: '<S1072>/Data Store Read2'
+         *  DataStoreRead: '<S1072>/Data Store Read5'
+         *  DataStoreRead: '<S1072>/Data Store Read6'
+         *  MATLAB Function: '<S1072>/2 way valve'
+         *  MATLAB Function: '<S1072>/incar filter down'
+         *  MATLAB Function: '<S1072>/incar filter up'
+         *  MATLAB Function: '<S1072>/mode rear step 1'
          */
         uwayvalve(rtB.Merge_b, &rtDW.Mode_RR);
         incarfilterup_i(rtB.Merge_b, &rtDW.Mode_RR);
         incarfilterdown_c(rtB.Merge_b, &rtDW.Mode_RR);
         moderearstep1(rtB.Merge_b, &rtDW.Mode_RR);
 
-        /* MATLAB Function: '<S1053>/blower start finish' incorporates:
-         *  DataStoreRead: '<S1026>/Data Store Read7'
+        /* MATLAB Function: '<S1099>/blower start finish' incorporates:
+         *  DataStoreRead: '<S1072>/Data Store Read7'
          */
-        blowerstartfinish(rtB.Merge_b, rtb_out_he);
+        blowerstartfinish(rtB.Merge_b, rtb_out_jq);
 
-        /* MATLAB Function: '<S1053>/ECT min max' */
+        /* MATLAB Function: '<S1099>/ECT min max' */
         /* :  min = int16(g_assSTART_COOLANT_STEP0_TO_1(5)); */
         /* :  max = int16(g_assSTART_COOLANT_TO_STEP2(2)); */
         /* :  out = [min, max]; */
-        rtb_out_hl[0] = g_assSTART_COOLANT_STEP0_TO_1[4];
-        rtb_out_hl[1] = g_assSTART_COOLANT_TO_STEP2[1];
+        rtb_out_j4[0] = g_assSTART_COOLANT_STEP0_TO_1[4];
+        rtb_out_j4[1] = g_assSTART_COOLANT_TO_STEP2[1];
 
-        /* Lookup_n-D: '<S1053>/blower для текущего ECT' incorporates:
-         *  DataStoreRead: '<S1053>/engine coolant temp'
-         *  DataStoreWrite: '<S1026>/Data Store Write5'
+        /* Lookup_n-D: '<S1099>/blower для текущего ECT' incorporates:
+         *  DataStoreRead: '<S1099>/engine coolant temp'
+         *  DataStoreWrite: '<S1072>/Data Store Write5'
          */
-        rtDW.Blower_RR = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_hl,
-          rtb_out_he, 1U);
+        rtDW.Blower_RR = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_j4,
+          rtb_out_jq, 1U);
 
-        /* DataStoreWrite: '<S1026>/Data Store Write10' incorporates:
-         *  DataStoreRead: '<S1026>/Data Store Read8'
-         *  MATLAB Function: '<S1026>/Dtg_rear'
+        /* DataStoreWrite: '<S1072>/Data Store Write10' incorporates:
+         *  DataStoreRead: '<S1072>/Data Store Read8'
+         *  MATLAB Function: '<S1072>/Dtg_rear'
          */
         Dtg_rear(rtB.Merge_b, &rtDW.Dtg_RR);
 
-        /* RelationalOperator: '<S1026>/Equal' incorporates:
-         *  DataStoreRead: '<S1026>/current step'
+        /* RelationalOperator: '<S1072>/Equal' incorporates:
+         *  DataStoreRead: '<S1072>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 1);
 
-        /* MATLAB Function: '<S1026>/Incar temp goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1026>/Data Store Read3'
+        /* MATLAB Function: '<S1072>/Incar temp goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1072>/Data Store Read3'
          */
         Incartempgotofromstep1tostep2_j(rtB.Merge_b, &Incar_FL);
 
-        /* Sum: '<S1051>/Subtract' incorporates:
-         *  DataStoreRead: '<S1051>/Data Store Read4'
-         *  UnitDelay: '<S1051>/t_start_delay_private '
+        /* Sum: '<S1097>/Subtract' incorporates:
+         *  DataStoreRead: '<S1097>/Data Store Read4'
+         *  UnitDelay: '<S1097>/t_start_delay_private '
          */
         rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_em;
 
-        /* MATLAB Function: '<S1026>/Time goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1026>/Data Store Read4'
+        /* MATLAB Function: '<S1072>/Time goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1072>/Data Store Read4'
          */
         Timegotofromstep1tostep2_l(rtB.Merge_b, &Eva_F);
 
-        /* Switch: '<S1051>/Switch' incorporates:
-         *  DataStoreRead: '<S1051>/Data Store Read4'
-         *  Logic: '<S1051>/Logical Operator3'
-         *  Logic: '<S1051>/Logical Operator4'
-         *  UnitDelay: '<S1051>/Cond_prev_private '
-         *  UnitDelay: '<S1051>/t_start_delay_private '
+        /* Switch: '<S1097>/Switch' incorporates:
+         *  DataStoreRead: '<S1097>/Data Store Read4'
+         *  Logic: '<S1097>/Logical Operator3'
+         *  Logic: '<S1097>/Logical Operator4'
+         *  UnitDelay: '<S1097>/Cond_prev_private '
+         *  UnitDelay: '<S1097>/t_start_delay_private '
          */
         /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(2)); */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_cp)) {
           rtDW.t_start_delay_private_DSTATE_em = rtDW.t_now;
         }
 
-        /* End of Switch: '<S1051>/Switch' */
+        /* End of Switch: '<S1097>/Switch' */
 
-        /* Switch: '<S1026>/Switch' incorporates:
-         *  DataStoreRead: '<S1026>/engine coolant temp'
-         *  DataStoreRead: '<S1026>/incar temp'
-         *  Gain: '<S1026>/из сек в мс'
-         *  Logic: '<S1026>/Logical Operator'
-         *  MATLAB Function: '<S1026>/g_assSTART_COOLANT_TO_STEP2 '
-         *  RelationalOperator: '<S1026>/Relational Operator'
-         *  RelationalOperator: '<S1026>/Relational Operator1'
-         *  RelationalOperator: '<S1026>/Relational Operator2'
+        /* Switch: '<S1072>/Switch' incorporates:
+         *  DataStoreRead: '<S1072>/engine coolant temp'
+         *  DataStoreRead: '<S1072>/incar temp'
+         *  Gain: '<S1072>/из сек в мс'
+         *  Logic: '<S1072>/Logical Operator'
+         *  MATLAB Function: '<S1072>/g_assSTART_COOLANT_TO_STEP2 '
+         *  RelationalOperator: '<S1072>/Relational Operator'
+         *  RelationalOperator: '<S1072>/Relational Operator1'
+         *  RelationalOperator: '<S1072>/Relational Operator2'
          */
         if ((Incar_RR > Incar_FL) || (rtb_dt_fa > (uint16_t)(1000 * Eva_F)) ||
             (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[1])) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1026>/go to next step'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1072>/go to next step'
            */
           rtB.Merge_c = 2;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1026>/stay at step 1'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1072>/stay at step 1'
            */
           rtB.Merge_c = 1;
         }
 
-        /* End of Switch: '<S1026>/Switch' */
+        /* End of Switch: '<S1072>/Switch' */
 
-        /* Update for UnitDelay: '<S1051>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S1097>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_cp = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S984>/Level 2' */
+        /* End of Outputs for SubSystem: '<S1030>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S984>/Level 3' incorporates:
-         *  ActionPort: '<S1027>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1030>/Level 3' incorporates:
+         *  ActionPort: '<S1073>/Action Port'
          */
-        /* DataStoreWrite: '<S1027>/Data Store Write2' incorporates:
-         *  DataStoreRead: '<S1027>/Data Store Read1'
-         *  DataStoreRead: '<S1027>/Data Store Read2'
-         *  DataStoreRead: '<S1027>/Data Store Read5'
-         *  DataStoreRead: '<S1027>/Data Store Read6'
-         *  MATLAB Function: '<S1027>/2 way valve'
-         *  MATLAB Function: '<S1027>/incar filter down'
-         *  MATLAB Function: '<S1027>/incar filter up'
-         *  MATLAB Function: '<S1027>/mode rear step 1'
+        /* DataStoreWrite: '<S1073>/Data Store Write2' incorporates:
+         *  DataStoreRead: '<S1073>/Data Store Read1'
+         *  DataStoreRead: '<S1073>/Data Store Read2'
+         *  DataStoreRead: '<S1073>/Data Store Read5'
+         *  DataStoreRead: '<S1073>/Data Store Read6'
+         *  MATLAB Function: '<S1073>/2 way valve'
+         *  MATLAB Function: '<S1073>/incar filter down'
+         *  MATLAB Function: '<S1073>/incar filter up'
+         *  MATLAB Function: '<S1073>/mode rear step 1'
          */
         uwayvalve(rtB.Merge_b, &rtDW.Mode_RR);
         incarfilterup_i(rtB.Merge_b, &rtDW.Mode_RR);
         incarfilterdown_c(rtB.Merge_b, &rtDW.Mode_RR);
         moderearstep1(rtB.Merge_b, &rtDW.Mode_RR);
 
-        /* MATLAB Function: '<S1065>/blower start finish' incorporates:
-         *  DataStoreRead: '<S1027>/Data Store Read7'
+        /* MATLAB Function: '<S1111>/blower start finish' incorporates:
+         *  DataStoreRead: '<S1073>/Data Store Read7'
          */
-        blowerstartfinish(rtB.Merge_b, rtb_out_he);
+        blowerstartfinish(rtB.Merge_b, rtb_out_jq);
 
-        /* MATLAB Function: '<S1065>/ECT min max' incorporates:
-         *  DataStoreRead: '<S1027>/Data Store Read7'
+        /* MATLAB Function: '<S1111>/ECT min max' incorporates:
+         *  DataStoreRead: '<S1073>/Data Store Read7'
          */
-        ECTminmax_l(rtB.Merge_b, rtb_out_hl);
+        ECTminmax_l(rtB.Merge_b, rtb_out_j4);
 
-        /* Lookup_n-D: '<S1065>/blower для текущего ECT' incorporates:
-         *  DataStoreRead: '<S1065>/engine coolant temp'
-         *  DataStoreWrite: '<S1027>/Data Store Write5'
+        /* Lookup_n-D: '<S1111>/blower для текущего ECT' incorporates:
+         *  DataStoreRead: '<S1111>/engine coolant temp'
+         *  DataStoreWrite: '<S1073>/Data Store Write5'
          */
-        rtDW.Blower_RR = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_hl,
-          rtb_out_he, 1U);
+        rtDW.Blower_RR = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_j4,
+          rtb_out_jq, 1U);
 
-        /* DataStoreWrite: '<S1027>/Data Store Write10' incorporates:
-         *  DataStoreRead: '<S1027>/Data Store Read8'
-         *  MATLAB Function: '<S1027>/Dtg_rear'
+        /* DataStoreWrite: '<S1073>/Data Store Write10' incorporates:
+         *  DataStoreRead: '<S1073>/Data Store Read8'
+         *  MATLAB Function: '<S1073>/Dtg_rear'
          */
         Dtg_rear(rtB.Merge_b, &rtDW.Dtg_RR);
 
-        /* RelationalOperator: '<S1027>/Equal' incorporates:
-         *  DataStoreRead: '<S1027>/current step'
+        /* RelationalOperator: '<S1073>/Equal' incorporates:
+         *  DataStoreRead: '<S1073>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 1);
 
-        /* MATLAB Function: '<S1027>/Incar temp goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1027>/Data Store Read3'
+        /* MATLAB Function: '<S1073>/Incar temp goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1073>/Data Store Read3'
          */
         Incartempgotofromstep1tostep2_j(rtB.Merge_b, &Incar_FL);
 
-        /* Sum: '<S1063>/Subtract' incorporates:
-         *  DataStoreRead: '<S1063>/Data Store Read4'
-         *  UnitDelay: '<S1063>/t_start_delay_private '
+        /* Sum: '<S1109>/Subtract' incorporates:
+         *  DataStoreRead: '<S1109>/Data Store Read4'
+         *  UnitDelay: '<S1109>/t_start_delay_private '
          */
         rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_o;
 
-        /* MATLAB Function: '<S1027>/Time goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1027>/Data Store Read4'
+        /* MATLAB Function: '<S1073>/Time goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1073>/Data Store Read4'
          */
         Timegotofromstep1tostep2_l(rtB.Merge_b, &Eva_F);
 
-        /* Switch: '<S1063>/Switch' incorporates:
-         *  DataStoreRead: '<S1063>/Data Store Read4'
-         *  Logic: '<S1063>/Logical Operator3'
-         *  Logic: '<S1063>/Logical Operator4'
-         *  UnitDelay: '<S1063>/Cond_prev_private '
-         *  UnitDelay: '<S1063>/t_start_delay_private '
+        /* Switch: '<S1109>/Switch' incorporates:
+         *  DataStoreRead: '<S1109>/Data Store Read4'
+         *  Logic: '<S1109>/Logical Operator3'
+         *  Logic: '<S1109>/Logical Operator4'
+         *  UnitDelay: '<S1109>/Cond_prev_private '
+         *  UnitDelay: '<S1109>/t_start_delay_private '
          */
         /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(3)); */
         if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_aw)) {
           rtDW.t_start_delay_private_DSTATE_o = rtDW.t_now;
         }
 
-        /* End of Switch: '<S1063>/Switch' */
+        /* End of Switch: '<S1109>/Switch' */
 
-        /* Switch: '<S1027>/Switch' incorporates:
-         *  DataStoreRead: '<S1027>/engine coolant temp'
-         *  DataStoreRead: '<S1027>/incar temp'
-         *  Gain: '<S1027>/из сек в мс'
-         *  Logic: '<S1027>/Logical Operator'
-         *  MATLAB Function: '<S1027>/g_assSTART_COOLANT_TO_STEP2 '
-         *  RelationalOperator: '<S1027>/Relational Operator'
-         *  RelationalOperator: '<S1027>/Relational Operator1'
-         *  RelationalOperator: '<S1027>/Relational Operator2'
+        /* Switch: '<S1073>/Switch' incorporates:
+         *  DataStoreRead: '<S1073>/engine coolant temp'
+         *  DataStoreRead: '<S1073>/incar temp'
+         *  Gain: '<S1073>/из сек в мс'
+         *  Logic: '<S1073>/Logical Operator'
+         *  MATLAB Function: '<S1073>/g_assSTART_COOLANT_TO_STEP2 '
+         *  RelationalOperator: '<S1073>/Relational Operator'
+         *  RelationalOperator: '<S1073>/Relational Operator1'
+         *  RelationalOperator: '<S1073>/Relational Operator2'
          */
         if ((Incar_RR > Incar_FL) || (rtb_dt_fa > (uint16_t)(1000 * Eva_F)) ||
             (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[2])) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1027>/go to next step'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1073>/go to next step'
            */
           rtB.Merge_c = 2;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1027>/stay at step 1'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1073>/stay at step 1'
            */
           rtB.Merge_c = 1;
         }
 
-        /* End of Switch: '<S1027>/Switch' */
+        /* End of Switch: '<S1073>/Switch' */
 
-        /* Update for UnitDelay: '<S1063>/Cond_prev_private ' */
+        /* Update for UnitDelay: '<S1109>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_aw = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S984>/Level 3' */
+        /* End of Outputs for SubSystem: '<S1030>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S984>/Level 4' incorporates:
-         *  ActionPort: '<S1028>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1030>/Level 4' incorporates:
+         *  ActionPort: '<S1074>/Action Port'
          */
-        Level4_d(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR, &Dtg_FUR,
-                 &rtDW.Dtg_RR, &rtDW.ECT, &Incar_RR, &rtb_Gain2_c, &rtb_Gain_ge,
+        Level4_d(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR, &Dtg_FUR,
+                 &rtDW.Dtg_RR, &rtDW.ECT, &Incar_RR, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1,
                  &Valve_2_way, &rtDW.step_start_controle_rear, &rtDW.t_now,
                  &rtDW.Level4_dp);
 
-        /* End of Outputs for SubSystem: '<S984>/Level 4' */
+        /* End of Outputs for SubSystem: '<S1030>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S984>/Level 5' incorporates:
-         *  ActionPort: '<S1029>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1030>/Level 5' incorporates:
+         *  ActionPort: '<S1075>/Action Port'
          */
-        Level4_d(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR, &Dtg_FUR,
-                 &rtDW.Dtg_RR, &rtDW.ECT, &Incar_RR, &rtb_Gain2_c, &rtb_Gain_ge,
+        Level4_d(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR, &Dtg_FUR,
+                 &rtDW.Dtg_RR, &rtDW.ECT, &Incar_RR, &rtb_Gain2_hu, &rtb_Gain_ge,
                  &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1,
                  &Valve_2_way, &rtDW.step_start_controle_rear, &rtDW.t_now,
                  &rtDW.Level5_f);
 
-        /* End of Outputs for SubSystem: '<S984>/Level 5' */
+        /* End of Outputs for SubSystem: '<S1030>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S984>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S721>/Step 1 R' */
+      /* End of SwitchCase: '<S1030>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S767>/Step 1 R' */
       break;
 
      case 2:
-      /* Outputs for IfAction SubSystem: '<S721>/Step 2 R' incorporates:
-       *  ActionPort: '<S985>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S767>/Step 2 R' incorporates:
+       *  ActionPort: '<S1031>/Action Port'
        */
-      /* SwitchCase: '<S985>/Switch Case' incorporates:
-       *  DataStoreRead: '<S985>/Data Store Read1'
+      /* SwitchCase: '<S1031>/Switch Case' incorporates:
+       *  DataStoreRead: '<S1031>/Data Store Read1'
        */
       switch (rtB.Merge_b) {
        case 0:
-        /* Outputs for IfAction SubSystem: '<S985>/Level 0' incorporates:
-         *  ActionPort: '<S1094>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1031>/Level 0' incorporates:
+         *  ActionPort: '<S1140>/Action Port'
          */
-        /* MATLAB Function: '<S1094>/2 way valve' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read6'
-         */
-        uwayvalve(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1101>/step' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read8'
-         */
-        Dtg_rear(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1101>/time for step' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read8'
-         */
-        timeforstep_jn(rtB.Merge_b, &rtb_Gain2_c);
-
-        /* Switch: '<S1101>/Switch' incorporates:
-         *  Constant: '<S1101>/Constant'
-         *  Constant: '<S1108>/epsilon'
-         *  DataStoreRead: '<S1101>/Текущее значение blower '
-         *  DataStoreRead: '<S1101>/значение auto (в соответствии с логикой)'
-         *  DataStoreRead: '<S1101>/текущее время в мс'
-         *  DataStoreWrite: '<S1094>/Data Store Write10'
-         *  Product: '<S1101>/Product1'
-         *  Product: '<S1101>/change rate (dtg//sec)'
-         *  Product: '<S1101>/скорость в мс'
-         *  Product: '<S1101>/шаг изменения'
-         *  RelationalOperator: '<S1108>/Relational Operator'
-         *  RelationalOperator: '<S1112>/Relational Operator'
-         *  Sum: '<S1101>/Add'
-         *  Sum: '<S1108>/Add'
-         *  Sum: '<S1109>/Subtract'
-         *  Switch: '<S1112>/Switch'
-         *  UnitDelay: '<S1109>/Unit Delay'
-         */
-        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
-          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
-        } else {
-          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
-            /* Switch: '<S1112>/Switch' incorporates:
-             *  Constant: '<S1112>/Constant'
-             */
-            q0 = 1;
-          } else {
-            /* Switch: '<S1112>/Switch' incorporates:
-             *  Constant: '<S1112>/Constant1'
-             */
-            q0 = -1;
-          }
-
-          rtDW.Dtg_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_d) * (double)q0
-            + (double)rtDW.Dtg_RR);
-        }
-
-        /* End of Switch: '<S1101>/Switch' */
-
-        /* MATLAB Function: '<S1094>/incar filter up' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read1'
-         */
-        incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1094>/incar filter down' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read2'
-         */
-        incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* Sum: '<S1118>/Add' incorporates:
-         *  DataStoreRead: '<S1107>/Текущее значение blower '
-         *  DataStoreRead: '<S1107>/значение auto (в соответствии с логикой)'
-         */
-        rtb_Gain2_c = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);
-
-        /* RelationalOperator: '<S1118>/Relational Operator' incorporates:
-         *  Constant: '<S1118>/epsilon'
-         */
-        rtb_LogicalOperator1 = (rtb_Gain2_c <= 0.01);
-
-        /* MATLAB Function: '<S1107>/step' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read5'
-         */
-        step_a(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1107>/time for step' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read5'
-         */
-        timeforstep_h(rtB.Merge_b, &rtb_Gain2_c);
-
-        /* Switch: '<S1107>/Switch' incorporates:
-         *  Constant: '<S1107>/Constant'
-         *  DataStoreRead: '<S1107>/Текущее значение blower '
-         *  DataStoreRead: '<S1107>/значение auto (в соответствии с логикой)'
-         *  DataStoreRead: '<S1107>/текущее время в мс'
-         *  DataStoreWrite: '<S1094>/Data Store Write2'
-         *  Product: '<S1107>/Product1'
-         *  Product: '<S1107>/change rate (step//sec)'
-         *  Product: '<S1107>/скорость в мс'
-         *  Product: '<S1107>/шаг изменения'
-         *  RelationalOperator: '<S1122>/Relational Operator'
-         *  Sum: '<S1107>/Add'
-         *  Sum: '<S1119>/Subtract'
-         *  Switch: '<S1122>/Switch'
-         *  UnitDelay: '<S1119>/Unit Delay'
-         */
-        if (rtb_LogicalOperator1) {
-          rtDW.Mode_RR = rtDW.Mode_logic_RR;
-        } else {
-          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
-            /* Switch: '<S1122>/Switch' incorporates:
-             *  Constant: '<S1122>/Constant'
-             */
-            q0 = 1;
-          } else {
-            /* Switch: '<S1122>/Switch' incorporates:
-             *  Constant: '<S1122>/Constant1'
-             */
-            q0 = -1;
-          }
-
-          rtDW.Mode_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_nc) * (double)
-            q0 + (double)rtDW.Mode_RR);
-        }
-
-        /* End of Switch: '<S1107>/Switch' */
-
-        /* MATLAB Function: '<S1104>/blower step' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read7'
-         */
-        blowerstep_d(rtB.Merge_b, &rtb_out_ee);
-
-        /* MATLAB Function: '<S1104>/blower time for step' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read7'
-         */
-        blowertimeforstep_l(rtB.Merge_b, &rtb_out_bc);
-
-        /* Switch: '<S1104>/Switch' incorporates:
-         *  Constant: '<S1104>/Constant'
-         *  Constant: '<S1113>/epsilon'
-         *  DataStoreRead: '<S1104>/Текущее значение blower '
-         *  DataStoreRead: '<S1104>/значение auto (в соответствии с логикой)'
-         *  DataStoreRead: '<S1104>/текущее время в мс'
-         *  DataStoreWrite: '<S1094>/Data Store Write5'
-         *  Product: '<S1104>/Product1'
-         *  Product: '<S1104>/change rate (step//sec)'
-         *  Product: '<S1104>/скорость в мс'
-         *  Product: '<S1104>/шаг изменения'
-         *  RelationalOperator: '<S1113>/Relational Operator'
-         *  RelationalOperator: '<S1117>/Relational Operator'
-         *  Sum: '<S1104>/Add'
-         *  Sum: '<S1113>/Add'
-         *  Sum: '<S1114>/Subtract'
-         *  Switch: '<S1117>/Switch'
-         *  UnitDelay: '<S1114>/Unit Delay'
-         */
-        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
-          rtDW.Blower_RR = rtDW.Blower_logic_RR;
-        } else {
-          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
-            /* Switch: '<S1117>/Switch' incorporates:
-             *  Constant: '<S1117>/Constant'
-             */
-            q0 = 1;
-          } else {
-            /* Switch: '<S1117>/Switch' incorporates:
-             *  Constant: '<S1117>/Constant1'
-             */
-            q0 = -1;
-          }
-
-          rtDW.Blower_RR = (uint16_t)((double)rtb_out_ee / (double)rtb_out_bc /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_hs) * (double)
-            q0 + (double)rtDW.Blower_RR);
-        }
-
-        /* End of Switch: '<S1104>/Switch' */
-
-        /* RelationalOperator: '<S1094>/Equal' incorporates:
-         *  DataStoreRead: '<S1094>/current step'
-         */
-        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);
-
-        /* Sum: '<S1102>/Subtract' incorporates:
-         *  DataStoreRead: '<S1102>/Data Store Read4'
-         *  UnitDelay: '<S1102>/t_start_delay_private '
-         */
-        rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_fvm;
-
-        /* Switch: '<S1102>/Switch' incorporates:
-         *  DataStoreRead: '<S1102>/Data Store Read4'
-         *  Logic: '<S1102>/Logical Operator3'
-         *  Logic: '<S1102>/Logical Operator4'
-         *  UnitDelay: '<S1102>/Cond_prev_private '
-         *  UnitDelay: '<S1102>/t_start_delay_private '
-         */
-        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_i5)) {
-          rtDW.t_start_delay_private_DSTATE_fvm = rtDW.t_now;
-        }
-
-        /* End of Switch: '<S1102>/Switch' */
-
-        /* MATLAB Function: '<S1094>/Time goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1094>/Data Store Read4'
-         */
-        Timegotofromstep1tostep2_l(rtB.Merge_b, &Incar_RR);
-
-        /* Switch: '<S1094>/Switch' incorporates:
-         *  Gain: '<S1094>/из сек в мс'
-         *  RelationalOperator: '<S1094>/Relational Operator1'
-         */
-        if (rtb_dt_fa > (uint16_t)(1000 * Incar_RR)) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1094>/go to next step'
-           */
-          rtB.Merge_c = 3;
-        } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1094>/stay at step'
-           */
-          rtB.Merge_c = 2;
-        }
-
-        /* End of Switch: '<S1094>/Switch' */
-
-        /* Update for UnitDelay: '<S1109>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S1101>/текущее время в мс'
-         */
-        rtDW.UnitDelay_DSTATE_d = rtDW.t_now;
-
-        /* Update for UnitDelay: '<S1119>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S1107>/текущее время в мс'
-         */
-        rtDW.UnitDelay_DSTATE_nc = rtDW.t_now;
-
-        /* Update for UnitDelay: '<S1114>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S1104>/текущее время в мс'
-         */
-        rtDW.UnitDelay_DSTATE_hs = rtDW.t_now;
-
-        /* Update for UnitDelay: '<S1102>/Cond_prev_private ' */
-        rtDW.Cond_prev_private_DSTATE_i5 = rtb_LogicalOperator1;
-
-        /* End of Outputs for SubSystem: '<S985>/Level 0' */
-        break;
-
-       case 1:
-        /* Outputs for IfAction SubSystem: '<S985>/Level 1' incorporates:
-         *  ActionPort: '<S1095>/Action Port'
-         */
-        /* MATLAB Function: '<S1095>/2 way valve' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read6'
-         */
-        uwayvalve(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1124>/step' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read8'
-         */
-        Dtg_rear(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1124>/time for step' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read8'
-         */
-        timeforstep_jn(rtB.Merge_b, &rtb_Gain2_c);
-
-        /* Switch: '<S1124>/Switch' incorporates:
-         *  Constant: '<S1124>/Constant'
-         *  Constant: '<S1131>/epsilon'
-         *  DataStoreRead: '<S1124>/Текущее значение blower '
-         *  DataStoreRead: '<S1124>/значение auto (в соответствии с логикой)'
-         *  DataStoreRead: '<S1124>/текущее время в мс'
-         *  DataStoreWrite: '<S1095>/Data Store Write10'
-         *  Product: '<S1124>/Product1'
-         *  Product: '<S1124>/change rate (dtg//sec)'
-         *  Product: '<S1124>/скорость в мс'
-         *  Product: '<S1124>/шаг изменения'
-         *  RelationalOperator: '<S1131>/Relational Operator'
-         *  RelationalOperator: '<S1135>/Relational Operator'
-         *  Sum: '<S1124>/Add'
-         *  Sum: '<S1131>/Add'
-         *  Sum: '<S1132>/Subtract'
-         *  Switch: '<S1135>/Switch'
-         *  UnitDelay: '<S1132>/Unit Delay'
-         */
-        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
-          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
-        } else {
-          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
-            /* Switch: '<S1135>/Switch' incorporates:
-             *  Constant: '<S1135>/Constant'
-             */
-            q0 = 1;
-          } else {
-            /* Switch: '<S1135>/Switch' incorporates:
-             *  Constant: '<S1135>/Constant1'
-             */
-            q0 = -1;
-          }
-
-          rtDW.Dtg_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_g) * (double)q0
-            + (double)rtDW.Dtg_RR);
-        }
-
-        /* End of Switch: '<S1124>/Switch' */
-
-        /* MATLAB Function: '<S1095>/incar filter up' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read1'
-         */
-        incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1095>/incar filter down' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read2'
-         */
-        incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* Sum: '<S1141>/Add' incorporates:
-         *  DataStoreRead: '<S1130>/Текущее значение blower '
-         *  DataStoreRead: '<S1130>/значение auto (в соответствии с логикой)'
-         */
-        rtb_Gain2_c = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);
-
-        /* RelationalOperator: '<S1141>/Relational Operator' incorporates:
-         *  Constant: '<S1141>/epsilon'
-         */
-        rtb_LogicalOperator1 = (rtb_Gain2_c <= 0.01);
-
-        /* MATLAB Function: '<S1130>/step' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read5'
-         */
-        step_a(rtB.Merge_b, &rtb_Gain_ge);
-
-        /* MATLAB Function: '<S1130>/time for step' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read5'
-         */
-        timeforstep_h(rtB.Merge_b, &rtb_Gain2_c);
-
-        /* Switch: '<S1130>/Switch' incorporates:
-         *  Constant: '<S1130>/Constant'
-         *  DataStoreRead: '<S1130>/Текущее значение blower '
-         *  DataStoreRead: '<S1130>/значение auto (в соответствии с логикой)'
-         *  DataStoreRead: '<S1130>/текущее время в мс'
-         *  DataStoreWrite: '<S1095>/Data Store Write2'
-         *  Product: '<S1130>/Product1'
-         *  Product: '<S1130>/change rate (step//sec)'
-         *  Product: '<S1130>/скорость в мс'
-         *  Product: '<S1130>/шаг изменения'
-         *  RelationalOperator: '<S1145>/Relational Operator'
-         *  Sum: '<S1130>/Add'
-         *  Sum: '<S1142>/Subtract'
-         *  Switch: '<S1145>/Switch'
-         *  UnitDelay: '<S1142>/Unit Delay'
-         */
-        if (rtb_LogicalOperator1) {
-          rtDW.Mode_RR = rtDW.Mode_logic_RR;
-        } else {
-          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
-            /* Switch: '<S1145>/Switch' incorporates:
-             *  Constant: '<S1145>/Constant'
-             */
-            q0 = 1;
-          } else {
-            /* Switch: '<S1145>/Switch' incorporates:
-             *  Constant: '<S1145>/Constant1'
-             */
-            q0 = -1;
-          }
-
-          rtDW.Mode_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p) * (double)q0
-            + (double)rtDW.Mode_RR);
-        }
-
-        /* End of Switch: '<S1130>/Switch' */
-
-        /* MATLAB Function: '<S1127>/blower step' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read7'
-         */
-        blowerstep_d(rtB.Merge_b, &rtb_out_ee);
-
-        /* MATLAB Function: '<S1127>/blower time for step' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read7'
-         */
-        blowertimeforstep_l(rtB.Merge_b, &rtb_out_bc);
-
-        /* Switch: '<S1127>/Switch' incorporates:
-         *  Constant: '<S1127>/Constant'
-         *  Constant: '<S1136>/epsilon'
-         *  DataStoreRead: '<S1127>/Текущее значение blower '
-         *  DataStoreRead: '<S1127>/значение auto (в соответствии с логикой)'
-         *  DataStoreRead: '<S1127>/текущее время в мс'
-         *  DataStoreWrite: '<S1095>/Data Store Write5'
-         *  Product: '<S1127>/Product1'
-         *  Product: '<S1127>/change rate (step//sec)'
-         *  Product: '<S1127>/скорость в мс'
-         *  Product: '<S1127>/шаг изменения'
-         *  RelationalOperator: '<S1136>/Relational Operator'
-         *  RelationalOperator: '<S1140>/Relational Operator'
-         *  Sum: '<S1127>/Add'
-         *  Sum: '<S1136>/Add'
-         *  Sum: '<S1137>/Subtract'
-         *  Switch: '<S1140>/Switch'
-         *  UnitDelay: '<S1137>/Unit Delay'
-         */
-        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
-          rtDW.Blower_RR = rtDW.Blower_logic_RR;
-        } else {
-          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
-            /* Switch: '<S1140>/Switch' incorporates:
-             *  Constant: '<S1140>/Constant'
-             */
-            q0 = 1;
-          } else {
-            /* Switch: '<S1140>/Switch' incorporates:
-             *  Constant: '<S1140>/Constant1'
-             */
-            q0 = -1;
-          }
-
-          rtDW.Blower_RR = (uint16_t)((double)rtb_out_ee / (double)rtb_out_bc /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_j) * (double)q0
-            + (double)rtDW.Blower_RR);
-        }
-
-        /* End of Switch: '<S1127>/Switch' */
-
-        /* RelationalOperator: '<S1095>/Equal' incorporates:
-         *  DataStoreRead: '<S1095>/current step'
-         */
-        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);
-
-        /* Sum: '<S1125>/Subtract' incorporates:
-         *  DataStoreRead: '<S1125>/Data Store Read4'
-         *  UnitDelay: '<S1125>/t_start_delay_private '
-         */
-        rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_jh;
-
-        /* Switch: '<S1125>/Switch' incorporates:
-         *  DataStoreRead: '<S1125>/Data Store Read4'
-         *  Logic: '<S1125>/Logical Operator3'
-         *  Logic: '<S1125>/Logical Operator4'
-         *  UnitDelay: '<S1125>/Cond_prev_private '
-         *  UnitDelay: '<S1125>/t_start_delay_private '
-         */
-        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_j)) {
-          rtDW.t_start_delay_private_DSTATE_jh = rtDW.t_now;
-        }
-
-        /* End of Switch: '<S1125>/Switch' */
-
-        /* MATLAB Function: '<S1095>/Time goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1095>/Data Store Read4'
-         */
-        Timegotofromstep1tostep2_l(rtB.Merge_b, &Incar_RR);
-
-        /* Switch: '<S1095>/Switch' incorporates:
-         *  Gain: '<S1095>/из сек в мс'
-         *  RelationalOperator: '<S1095>/Relational Operator1'
-         */
-        if (rtb_dt_fa > (uint16_t)(1000 * Incar_RR)) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1095>/go to next step'
-           */
-          rtB.Merge_c = 3;
-        } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1095>/stay at step'
-           */
-          rtB.Merge_c = 2;
-        }
-
-        /* End of Switch: '<S1095>/Switch' */
-
-        /* Update for UnitDelay: '<S1132>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S1124>/текущее время в мс'
-         */
-        rtDW.UnitDelay_DSTATE_g = rtDW.t_now;
-
-        /* Update for UnitDelay: '<S1142>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S1130>/текущее время в мс'
-         */
-        rtDW.UnitDelay_DSTATE_p = rtDW.t_now;
-
-        /* Update for UnitDelay: '<S1137>/Unit Delay' incorporates:
-         *  DataStoreRead: '<S1127>/текущее время в мс'
-         */
-        rtDW.UnitDelay_DSTATE_j = rtDW.t_now;
-
-        /* Update for UnitDelay: '<S1125>/Cond_prev_private ' */
-        rtDW.Cond_prev_private_DSTATE_j = rtb_LogicalOperator1;
-
-        /* End of Outputs for SubSystem: '<S985>/Level 1' */
-        break;
-
-       case 2:
-        /* Outputs for IfAction SubSystem: '<S985>/Level 2' incorporates:
-         *  ActionPort: '<S1096>/Action Port'
-         */
-        /* MATLAB Function: '<S1096>/2 way valve' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read6'
+        /* MATLAB Function: '<S1140>/2 way valve' incorporates:
+         *  DataStoreRead: '<S1140>/Data Store Read6'
          */
         uwayvalve(rtB.Merge_b, &rtb_Gain_ge);
 
         /* MATLAB Function: '<S1147>/step' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read8'
+         *  DataStoreRead: '<S1140>/Data Store Read8'
          */
         Dtg_rear(rtB.Merge_b, &rtb_Gain_ge);
 
         /* MATLAB Function: '<S1147>/time for step' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read8'
+         *  DataStoreRead: '<S1140>/Data Store Read8'
          */
-        timeforstep_jn(rtB.Merge_b, &rtb_Gain2_c);
+        timeforstep_jn(rtB.Merge_b, &rtb_Gain2_hu);
 
         /* Switch: '<S1147>/Switch' incorporates:
          *  Constant: '<S1147>/Constant'
@@ -15856,7 +16258,7 @@ void HVAC_model_step(void)
          *  DataStoreRead: '<S1147>/Текущее значение blower '
          *  DataStoreRead: '<S1147>/значение auto (в соответствии с логикой)'
          *  DataStoreRead: '<S1147>/текущее время в мс'
-         *  DataStoreWrite: '<S1096>/Data Store Write10'
+         *  DataStoreWrite: '<S1140>/Data Store Write10'
          *  Product: '<S1147>/Product1'
          *  Product: '<S1147>/change rate (dtg//sec)'
          *  Product: '<S1147>/скорость в мс'
@@ -15876,28 +16278,28 @@ void HVAC_model_step(void)
             /* Switch: '<S1158>/Switch' incorporates:
              *  Constant: '<S1158>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
             /* Switch: '<S1158>/Switch' incorporates:
              *  Constant: '<S1158>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          rtDW.Dtg_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE) * (double)q0 +
-            (double)rtDW.Dtg_RR);
+          rtDW.Dtg_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_d) * (double)y
+            + (double)rtDW.Dtg_RR);
         }
 
         /* End of Switch: '<S1147>/Switch' */
 
-        /* MATLAB Function: '<S1096>/incar filter up' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read1'
+        /* MATLAB Function: '<S1140>/incar filter up' incorporates:
+         *  DataStoreRead: '<S1140>/Data Store Read1'
          */
         incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
 
-        /* MATLAB Function: '<S1096>/incar filter down' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read2'
+        /* MATLAB Function: '<S1140>/incar filter down' incorporates:
+         *  DataStoreRead: '<S1140>/Data Store Read2'
          */
         incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
 
@@ -15905,29 +16307,29 @@ void HVAC_model_step(void)
          *  DataStoreRead: '<S1153>/Текущее значение blower '
          *  DataStoreRead: '<S1153>/значение auto (в соответствии с логикой)'
          */
-        rtb_Gain2_c = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);
+        rtb_Gain2_hu = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);
 
         /* RelationalOperator: '<S1164>/Relational Operator' incorporates:
          *  Constant: '<S1164>/epsilon'
          */
-        rtb_LogicalOperator1 = (rtb_Gain2_c <= 0.01);
+        rtb_LogicalOperator1 = (rtb_Gain2_hu <= 0.01);
 
         /* MATLAB Function: '<S1153>/step' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read5'
+         *  DataStoreRead: '<S1140>/Data Store Read5'
          */
         step_a(rtB.Merge_b, &rtb_Gain_ge);
 
         /* MATLAB Function: '<S1153>/time for step' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read5'
+         *  DataStoreRead: '<S1140>/Data Store Read5'
          */
-        timeforstep_h(rtB.Merge_b, &rtb_Gain2_c);
+        timeforstep_h(rtB.Merge_b, &rtb_Gain2_hu);
 
         /* Switch: '<S1153>/Switch' incorporates:
          *  Constant: '<S1153>/Constant'
          *  DataStoreRead: '<S1153>/Текущее значение blower '
          *  DataStoreRead: '<S1153>/значение auto (в соответствии с логикой)'
          *  DataStoreRead: '<S1153>/текущее время в мс'
-         *  DataStoreWrite: '<S1096>/Data Store Write2'
+         *  DataStoreWrite: '<S1140>/Data Store Write2'
          *  Product: '<S1153>/Product1'
          *  Product: '<S1153>/change rate (step//sec)'
          *  Product: '<S1153>/скорость в мс'
@@ -15945,30 +16347,30 @@ void HVAC_model_step(void)
             /* Switch: '<S1168>/Switch' incorporates:
              *  Constant: '<S1168>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
             /* Switch: '<S1168>/Switch' incorporates:
              *  Constant: '<S1168>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          rtDW.Mode_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_c /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_h) * (double)q0
+          rtDW.Mode_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_nc) * (double)y
             + (double)rtDW.Mode_RR);
         }
 
         /* End of Switch: '<S1153>/Switch' */
 
         /* MATLAB Function: '<S1150>/blower step' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read7'
+         *  DataStoreRead: '<S1140>/Data Store Read7'
          */
-        blowerstep_d(rtB.Merge_b, &rtb_out_ee);
+        blowerstep_d(rtB.Merge_b, &FIU_SET_RR);
 
         /* MATLAB Function: '<S1150>/blower time for step' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read7'
+         *  DataStoreRead: '<S1140>/Data Store Read7'
          */
-        blowertimeforstep_l(rtB.Merge_b, &rtb_out_bc);
+        blowertimeforstep_l(rtB.Merge_b, &rtb_out_oc);
 
         /* Switch: '<S1150>/Switch' incorporates:
          *  Constant: '<S1150>/Constant'
@@ -15976,7 +16378,7 @@ void HVAC_model_step(void)
          *  DataStoreRead: '<S1150>/Текущее значение blower '
          *  DataStoreRead: '<S1150>/значение auto (в соответствии с логикой)'
          *  DataStoreRead: '<S1150>/текущее время в мс'
-         *  DataStoreWrite: '<S1096>/Data Store Write5'
+         *  DataStoreWrite: '<S1140>/Data Store Write5'
          *  Product: '<S1150>/Product1'
          *  Product: '<S1150>/change rate (step//sec)'
          *  Product: '<S1150>/скорость в мс'
@@ -15996,23 +16398,23 @@ void HVAC_model_step(void)
             /* Switch: '<S1163>/Switch' incorporates:
              *  Constant: '<S1163>/Constant'
              */
-            q0 = 1;
+            y = 1;
           } else {
             /* Switch: '<S1163>/Switch' incorporates:
              *  Constant: '<S1163>/Constant1'
              */
-            q0 = -1;
+            y = -1;
           }
 
-          rtDW.Blower_RR = (uint16_t)((double)rtb_out_ee / (double)rtb_out_bc /
-            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_n) * (double)q0
+          rtDW.Blower_RR = (uint16_t)((double)FIU_SET_RR / (double)rtb_out_oc /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_hs) * (double)y
             + (double)rtDW.Blower_RR);
         }
 
         /* End of Switch: '<S1150>/Switch' */
 
-        /* RelationalOperator: '<S1096>/Equal' incorporates:
-         *  DataStoreRead: '<S1096>/current step'
+        /* RelationalOperator: '<S1140>/Equal' incorporates:
+         *  DataStoreRead: '<S1140>/current step'
          */
         rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);
 
@@ -16020,12 +16422,7 @@ void HVAC_model_step(void)
          *  DataStoreRead: '<S1148>/Data Store Read4'
          *  UnitDelay: '<S1148>/t_start_delay_private '
          */
-        rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_ed;
-
-        /* MATLAB Function: '<S1096>/Time goto from step 1 to step 2 ' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read4'
-         */
-        Timegotofromstep1tostep2_l(rtB.Merge_b, &Incar_RR);
+        rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_fvm;
 
         /* Switch: '<S1148>/Switch' incorporates:
          *  DataStoreRead: '<S1148>/Data Store Read4'
@@ -16034,113 +16431,614 @@ void HVAC_model_step(void)
          *  UnitDelay: '<S1148>/Cond_prev_private '
          *  UnitDelay: '<S1148>/t_start_delay_private '
          */
-        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_ei)) {
-          rtDW.t_start_delay_private_DSTATE_ed = rtDW.t_now;
+        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_i5)) {
+          rtDW.t_start_delay_private_DSTATE_fvm = rtDW.t_now;
         }
 
         /* End of Switch: '<S1148>/Switch' */
 
-        /* Switch: '<S1096>/Switch' incorporates:
-         *  DataStoreRead: '<S1096>/Data Store Read'
-         *  Gain: '<S1096>/из сек в мс'
-         *  Logic: '<S1096>/Logical Operator'
-         *  RelationalOperator: '<S1096>/Relational Operator1'
+        /* MATLAB Function: '<S1140>/Time goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1140>/Data Store Read4'
          */
-        if ((rtb_dt_fa > (uint16_t)(1000 * Incar_RR)) || rtDW.HI_logic_on) {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1096>/go to next step'
+        Timegotofromstep1tostep2_l(rtB.Merge_b, &Incar_RR);
+
+        /* Switch: '<S1140>/Switch' incorporates:
+         *  Gain: '<S1140>/из сек в мс'
+         *  RelationalOperator: '<S1140>/Relational Operator1'
+         */
+        if (rtb_dt_fa > (uint16_t)(1000 * Incar_RR)) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1140>/go to next step'
            */
           rtB.Merge_c = 3;
         } else {
-          /* Merge: '<S721>/Merge' incorporates:
-           *  Constant: '<S1096>/stay at step'
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1140>/stay at step'
            */
           rtB.Merge_c = 2;
         }
 
-        /* End of Switch: '<S1096>/Switch' */
+        /* End of Switch: '<S1140>/Switch' */
 
         /* Update for UnitDelay: '<S1155>/Unit Delay' incorporates:
          *  DataStoreRead: '<S1147>/текущее время в мс'
          */
-        rtDW.UnitDelay_DSTATE = rtDW.t_now;
+        rtDW.UnitDelay_DSTATE_d = rtDW.t_now;
 
         /* Update for UnitDelay: '<S1165>/Unit Delay' incorporates:
          *  DataStoreRead: '<S1153>/текущее время в мс'
          */
-        rtDW.UnitDelay_DSTATE_h = rtDW.t_now;
+        rtDW.UnitDelay_DSTATE_nc = rtDW.t_now;
 
         /* Update for UnitDelay: '<S1160>/Unit Delay' incorporates:
          *  DataStoreRead: '<S1150>/текущее время в мс'
          */
-        rtDW.UnitDelay_DSTATE_n = rtDW.t_now;
+        rtDW.UnitDelay_DSTATE_hs = rtDW.t_now;
 
         /* Update for UnitDelay: '<S1148>/Cond_prev_private ' */
+        rtDW.Cond_prev_private_DSTATE_i5 = rtb_LogicalOperator1;
+
+        /* End of Outputs for SubSystem: '<S1031>/Level 0' */
+        break;
+
+       case 1:
+        /* Outputs for IfAction SubSystem: '<S1031>/Level 1' incorporates:
+         *  ActionPort: '<S1141>/Action Port'
+         */
+        /* MATLAB Function: '<S1141>/2 way valve' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read6'
+         */
+        uwayvalve(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1170>/step' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read8'
+         */
+        Dtg_rear(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1170>/time for step' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read8'
+         */
+        timeforstep_jn(rtB.Merge_b, &rtb_Gain2_hu);
+
+        /* Switch: '<S1170>/Switch' incorporates:
+         *  Constant: '<S1170>/Constant'
+         *  Constant: '<S1177>/epsilon'
+         *  DataStoreRead: '<S1170>/Текущее значение blower '
+         *  DataStoreRead: '<S1170>/значение auto (в соответствии с логикой)'
+         *  DataStoreRead: '<S1170>/текущее время в мс'
+         *  DataStoreWrite: '<S1141>/Data Store Write10'
+         *  Product: '<S1170>/Product1'
+         *  Product: '<S1170>/change rate (dtg//sec)'
+         *  Product: '<S1170>/скорость в мс'
+         *  Product: '<S1170>/шаг изменения'
+         *  RelationalOperator: '<S1177>/Relational Operator'
+         *  RelationalOperator: '<S1181>/Relational Operator'
+         *  Sum: '<S1170>/Add'
+         *  Sum: '<S1177>/Add'
+         *  Sum: '<S1178>/Subtract'
+         *  Switch: '<S1181>/Switch'
+         *  UnitDelay: '<S1178>/Unit Delay'
+         */
+        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
+          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
+        } else {
+          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
+            /* Switch: '<S1181>/Switch' incorporates:
+             *  Constant: '<S1181>/Constant'
+             */
+            y = 1;
+          } else {
+            /* Switch: '<S1181>/Switch' incorporates:
+             *  Constant: '<S1181>/Constant1'
+             */
+            y = -1;
+          }
+
+          rtDW.Dtg_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_g) * (double)y
+            + (double)rtDW.Dtg_RR);
+        }
+
+        /* End of Switch: '<S1170>/Switch' */
+
+        /* MATLAB Function: '<S1141>/incar filter up' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read1'
+         */
+        incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1141>/incar filter down' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read2'
+         */
+        incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* Sum: '<S1187>/Add' incorporates:
+         *  DataStoreRead: '<S1176>/Текущее значение blower '
+         *  DataStoreRead: '<S1176>/значение auto (в соответствии с логикой)'
+         */
+        rtb_Gain2_hu = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);
+
+        /* RelationalOperator: '<S1187>/Relational Operator' incorporates:
+         *  Constant: '<S1187>/epsilon'
+         */
+        rtb_LogicalOperator1 = (rtb_Gain2_hu <= 0.01);
+
+        /* MATLAB Function: '<S1176>/step' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read5'
+         */
+        step_a(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1176>/time for step' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read5'
+         */
+        timeforstep_h(rtB.Merge_b, &rtb_Gain2_hu);
+
+        /* Switch: '<S1176>/Switch' incorporates:
+         *  Constant: '<S1176>/Constant'
+         *  DataStoreRead: '<S1176>/Текущее значение blower '
+         *  DataStoreRead: '<S1176>/значение auto (в соответствии с логикой)'
+         *  DataStoreRead: '<S1176>/текущее время в мс'
+         *  DataStoreWrite: '<S1141>/Data Store Write2'
+         *  Product: '<S1176>/Product1'
+         *  Product: '<S1176>/change rate (step//sec)'
+         *  Product: '<S1176>/скорость в мс'
+         *  Product: '<S1176>/шаг изменения'
+         *  RelationalOperator: '<S1191>/Relational Operator'
+         *  Sum: '<S1176>/Add'
+         *  Sum: '<S1188>/Subtract'
+         *  Switch: '<S1191>/Switch'
+         *  UnitDelay: '<S1188>/Unit Delay'
+         */
+        if (rtb_LogicalOperator1) {
+          rtDW.Mode_RR = rtDW.Mode_logic_RR;
+        } else {
+          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
+            /* Switch: '<S1191>/Switch' incorporates:
+             *  Constant: '<S1191>/Constant'
+             */
+            y = 1;
+          } else {
+            /* Switch: '<S1191>/Switch' incorporates:
+             *  Constant: '<S1191>/Constant1'
+             */
+            y = -1;
+          }
+
+          rtDW.Mode_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p) * (double)y
+            + (double)rtDW.Mode_RR);
+        }
+
+        /* End of Switch: '<S1176>/Switch' */
+
+        /* MATLAB Function: '<S1173>/blower step' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read7'
+         */
+        blowerstep_d(rtB.Merge_b, &FIU_SET_RR);
+
+        /* MATLAB Function: '<S1173>/blower time for step' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read7'
+         */
+        blowertimeforstep_l(rtB.Merge_b, &rtb_out_oc);
+
+        /* Switch: '<S1173>/Switch' incorporates:
+         *  Constant: '<S1173>/Constant'
+         *  Constant: '<S1182>/epsilon'
+         *  DataStoreRead: '<S1173>/Текущее значение blower '
+         *  DataStoreRead: '<S1173>/значение auto (в соответствии с логикой)'
+         *  DataStoreRead: '<S1173>/текущее время в мс'
+         *  DataStoreWrite: '<S1141>/Data Store Write5'
+         *  Product: '<S1173>/Product1'
+         *  Product: '<S1173>/change rate (step//sec)'
+         *  Product: '<S1173>/скорость в мс'
+         *  Product: '<S1173>/шаг изменения'
+         *  RelationalOperator: '<S1182>/Relational Operator'
+         *  RelationalOperator: '<S1186>/Relational Operator'
+         *  Sum: '<S1173>/Add'
+         *  Sum: '<S1182>/Add'
+         *  Sum: '<S1183>/Subtract'
+         *  Switch: '<S1186>/Switch'
+         *  UnitDelay: '<S1183>/Unit Delay'
+         */
+        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
+          rtDW.Blower_RR = rtDW.Blower_logic_RR;
+        } else {
+          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
+            /* Switch: '<S1186>/Switch' incorporates:
+             *  Constant: '<S1186>/Constant'
+             */
+            y = 1;
+          } else {
+            /* Switch: '<S1186>/Switch' incorporates:
+             *  Constant: '<S1186>/Constant1'
+             */
+            y = -1;
+          }
+
+          rtDW.Blower_RR = (uint16_t)((double)FIU_SET_RR / (double)rtb_out_oc /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_j) * (double)y
+            + (double)rtDW.Blower_RR);
+        }
+
+        /* End of Switch: '<S1173>/Switch' */
+
+        /* RelationalOperator: '<S1141>/Equal' incorporates:
+         *  DataStoreRead: '<S1141>/current step'
+         */
+        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);
+
+        /* Sum: '<S1171>/Subtract' incorporates:
+         *  DataStoreRead: '<S1171>/Data Store Read4'
+         *  UnitDelay: '<S1171>/t_start_delay_private '
+         */
+        rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_jh;
+
+        /* Switch: '<S1171>/Switch' incorporates:
+         *  DataStoreRead: '<S1171>/Data Store Read4'
+         *  Logic: '<S1171>/Logical Operator3'
+         *  Logic: '<S1171>/Logical Operator4'
+         *  UnitDelay: '<S1171>/Cond_prev_private '
+         *  UnitDelay: '<S1171>/t_start_delay_private '
+         */
+        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_j)) {
+          rtDW.t_start_delay_private_DSTATE_jh = rtDW.t_now;
+        }
+
+        /* End of Switch: '<S1171>/Switch' */
+
+        /* MATLAB Function: '<S1141>/Time goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1141>/Data Store Read4'
+         */
+        Timegotofromstep1tostep2_l(rtB.Merge_b, &Incar_RR);
+
+        /* Switch: '<S1141>/Switch' incorporates:
+         *  Gain: '<S1141>/из сек в мс'
+         *  RelationalOperator: '<S1141>/Relational Operator1'
+         */
+        if (rtb_dt_fa > (uint16_t)(1000 * Incar_RR)) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1141>/go to next step'
+           */
+          rtB.Merge_c = 3;
+        } else {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1141>/stay at step'
+           */
+          rtB.Merge_c = 2;
+        }
+
+        /* End of Switch: '<S1141>/Switch' */
+
+        /* Update for UnitDelay: '<S1178>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1170>/текущее время в мс'
+         */
+        rtDW.UnitDelay_DSTATE_g = rtDW.t_now;
+
+        /* Update for UnitDelay: '<S1188>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1176>/текущее время в мс'
+         */
+        rtDW.UnitDelay_DSTATE_p = rtDW.t_now;
+
+        /* Update for UnitDelay: '<S1183>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1173>/текущее время в мс'
+         */
+        rtDW.UnitDelay_DSTATE_j = rtDW.t_now;
+
+        /* Update for UnitDelay: '<S1171>/Cond_prev_private ' */
+        rtDW.Cond_prev_private_DSTATE_j = rtb_LogicalOperator1;
+
+        /* End of Outputs for SubSystem: '<S1031>/Level 1' */
+        break;
+
+       case 2:
+        /* Outputs for IfAction SubSystem: '<S1031>/Level 2' incorporates:
+         *  ActionPort: '<S1142>/Action Port'
+         */
+        /* MATLAB Function: '<S1142>/2 way valve' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read6'
+         */
+        uwayvalve(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1193>/step' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read8'
+         */
+        Dtg_rear(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1193>/time for step' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read8'
+         */
+        timeforstep_jn(rtB.Merge_b, &rtb_Gain2_hu);
+
+        /* Switch: '<S1193>/Switch' incorporates:
+         *  Constant: '<S1193>/Constant'
+         *  Constant: '<S1200>/epsilon'
+         *  DataStoreRead: '<S1193>/Текущее значение blower '
+         *  DataStoreRead: '<S1193>/значение auto (в соответствии с логикой)'
+         *  DataStoreRead: '<S1193>/текущее время в мс'
+         *  DataStoreWrite: '<S1142>/Data Store Write10'
+         *  Product: '<S1193>/Product1'
+         *  Product: '<S1193>/change rate (dtg//sec)'
+         *  Product: '<S1193>/скорость в мс'
+         *  Product: '<S1193>/шаг изменения'
+         *  RelationalOperator: '<S1200>/Relational Operator'
+         *  RelationalOperator: '<S1204>/Relational Operator'
+         *  Sum: '<S1193>/Add'
+         *  Sum: '<S1200>/Add'
+         *  Sum: '<S1201>/Subtract'
+         *  Switch: '<S1204>/Switch'
+         *  UnitDelay: '<S1201>/Unit Delay'
+         */
+        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
+          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
+        } else {
+          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
+            /* Switch: '<S1204>/Switch' incorporates:
+             *  Constant: '<S1204>/Constant'
+             */
+            y = 1;
+          } else {
+            /* Switch: '<S1204>/Switch' incorporates:
+             *  Constant: '<S1204>/Constant1'
+             */
+            y = -1;
+          }
+
+          rtDW.Dtg_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE) * (double)y +
+            (double)rtDW.Dtg_RR);
+        }
+
+        /* End of Switch: '<S1193>/Switch' */
+
+        /* MATLAB Function: '<S1142>/incar filter up' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read1'
+         */
+        incarfilterup_i(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1142>/incar filter down' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read2'
+         */
+        incarfilterdown_c(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* Sum: '<S1210>/Add' incorporates:
+         *  DataStoreRead: '<S1199>/Текущее значение blower '
+         *  DataStoreRead: '<S1199>/значение auto (в соответствии с логикой)'
+         */
+        rtb_Gain2_hu = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);
+
+        /* RelationalOperator: '<S1210>/Relational Operator' incorporates:
+         *  Constant: '<S1210>/epsilon'
+         */
+        rtb_LogicalOperator1 = (rtb_Gain2_hu <= 0.01);
+
+        /* MATLAB Function: '<S1199>/step' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read5'
+         */
+        step_a(rtB.Merge_b, &rtb_Gain_ge);
+
+        /* MATLAB Function: '<S1199>/time for step' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read5'
+         */
+        timeforstep_h(rtB.Merge_b, &rtb_Gain2_hu);
+
+        /* Switch: '<S1199>/Switch' incorporates:
+         *  Constant: '<S1199>/Constant'
+         *  DataStoreRead: '<S1199>/Текущее значение blower '
+         *  DataStoreRead: '<S1199>/значение auto (в соответствии с логикой)'
+         *  DataStoreRead: '<S1199>/текущее время в мс'
+         *  DataStoreWrite: '<S1142>/Data Store Write2'
+         *  Product: '<S1199>/Product1'
+         *  Product: '<S1199>/change rate (step//sec)'
+         *  Product: '<S1199>/скорость в мс'
+         *  Product: '<S1199>/шаг изменения'
+         *  RelationalOperator: '<S1214>/Relational Operator'
+         *  Sum: '<S1199>/Add'
+         *  Sum: '<S1211>/Subtract'
+         *  Switch: '<S1214>/Switch'
+         *  UnitDelay: '<S1211>/Unit Delay'
+         */
+        if (rtb_LogicalOperator1) {
+          rtDW.Mode_RR = rtDW.Mode_logic_RR;
+        } else {
+          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
+            /* Switch: '<S1214>/Switch' incorporates:
+             *  Constant: '<S1214>/Constant'
+             */
+            y = 1;
+          } else {
+            /* Switch: '<S1214>/Switch' incorporates:
+             *  Constant: '<S1214>/Constant1'
+             */
+            y = -1;
+          }
+
+          rtDW.Mode_RR = (uint8_t)((double)rtb_Gain_ge / (double)rtb_Gain2_hu /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_h) * (double)y
+            + (double)rtDW.Mode_RR);
+        }
+
+        /* End of Switch: '<S1199>/Switch' */
+
+        /* MATLAB Function: '<S1196>/blower step' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read7'
+         */
+        blowerstep_d(rtB.Merge_b, &FIU_SET_RR);
+
+        /* MATLAB Function: '<S1196>/blower time for step' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read7'
+         */
+        blowertimeforstep_l(rtB.Merge_b, &rtb_out_oc);
+
+        /* Switch: '<S1196>/Switch' incorporates:
+         *  Constant: '<S1196>/Constant'
+         *  Constant: '<S1205>/epsilon'
+         *  DataStoreRead: '<S1196>/Текущее значение blower '
+         *  DataStoreRead: '<S1196>/значение auto (в соответствии с логикой)'
+         *  DataStoreRead: '<S1196>/текущее время в мс'
+         *  DataStoreWrite: '<S1142>/Data Store Write5'
+         *  Product: '<S1196>/Product1'
+         *  Product: '<S1196>/change rate (step//sec)'
+         *  Product: '<S1196>/скорость в мс'
+         *  Product: '<S1196>/шаг изменения'
+         *  RelationalOperator: '<S1205>/Relational Operator'
+         *  RelationalOperator: '<S1209>/Relational Operator'
+         *  Sum: '<S1196>/Add'
+         *  Sum: '<S1205>/Add'
+         *  Sum: '<S1206>/Subtract'
+         *  Switch: '<S1209>/Switch'
+         *  UnitDelay: '<S1206>/Unit Delay'
+         */
+        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
+          rtDW.Blower_RR = rtDW.Blower_logic_RR;
+        } else {
+          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
+            /* Switch: '<S1209>/Switch' incorporates:
+             *  Constant: '<S1209>/Constant'
+             */
+            y = 1;
+          } else {
+            /* Switch: '<S1209>/Switch' incorporates:
+             *  Constant: '<S1209>/Constant1'
+             */
+            y = -1;
+          }
+
+          rtDW.Blower_RR = (uint16_t)((double)FIU_SET_RR / (double)rtb_out_oc /
+            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_n) * (double)y
+            + (double)rtDW.Blower_RR);
+        }
+
+        /* End of Switch: '<S1196>/Switch' */
+
+        /* RelationalOperator: '<S1142>/Equal' incorporates:
+         *  DataStoreRead: '<S1142>/current step'
+         */
+        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);
+
+        /* Sum: '<S1194>/Subtract' incorporates:
+         *  DataStoreRead: '<S1194>/Data Store Read4'
+         *  UnitDelay: '<S1194>/t_start_delay_private '
+         */
+        rtb_dt_fa = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_ed;
+
+        /* MATLAB Function: '<S1142>/Time goto from step 1 to step 2 ' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read4'
+         */
+        Timegotofromstep1tostep2_l(rtB.Merge_b, &Incar_RR);
+
+        /* Switch: '<S1194>/Switch' incorporates:
+         *  DataStoreRead: '<S1194>/Data Store Read4'
+         *  Logic: '<S1194>/Logical Operator3'
+         *  Logic: '<S1194>/Logical Operator4'
+         *  UnitDelay: '<S1194>/Cond_prev_private '
+         *  UnitDelay: '<S1194>/t_start_delay_private '
+         */
+        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_ei)) {
+          rtDW.t_start_delay_private_DSTATE_ed = rtDW.t_now;
+        }
+
+        /* End of Switch: '<S1194>/Switch' */
+
+        /* Switch: '<S1142>/Switch' incorporates:
+         *  DataStoreRead: '<S1142>/Data Store Read'
+         *  Gain: '<S1142>/из сек в мс'
+         *  Logic: '<S1142>/Logical Operator'
+         *  RelationalOperator: '<S1142>/Relational Operator1'
+         */
+        if ((rtb_dt_fa > (uint16_t)(1000 * Incar_RR)) || rtDW.HI_logic_on) {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1142>/go to next step'
+           */
+          rtB.Merge_c = 3;
+        } else {
+          /* Merge: '<S767>/Merge' incorporates:
+           *  Constant: '<S1142>/stay at step'
+           */
+          rtB.Merge_c = 2;
+        }
+
+        /* End of Switch: '<S1142>/Switch' */
+
+        /* Update for UnitDelay: '<S1201>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1193>/текущее время в мс'
+         */
+        rtDW.UnitDelay_DSTATE = rtDW.t_now;
+
+        /* Update for UnitDelay: '<S1211>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1199>/текущее время в мс'
+         */
+        rtDW.UnitDelay_DSTATE_h = rtDW.t_now;
+
+        /* Update for UnitDelay: '<S1206>/Unit Delay' incorporates:
+         *  DataStoreRead: '<S1196>/текущее время в мс'
+         */
+        rtDW.UnitDelay_DSTATE_n = rtDW.t_now;
+
+        /* Update for UnitDelay: '<S1194>/Cond_prev_private ' */
         rtDW.Cond_prev_private_DSTATE_ei = rtb_LogicalOperator1;
 
-        /* End of Outputs for SubSystem: '<S985>/Level 2' */
+        /* End of Outputs for SubSystem: '<S1031>/Level 2' */
         break;
 
        case 3:
-        /* Outputs for IfAction SubSystem: '<S985>/Level 3' incorporates:
-         *  ActionPort: '<S1097>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1031>/Level 3' incorporates:
+         *  ActionPort: '<S1143>/Action Port'
          */
-        Level3_i(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR,
+        Level3_i(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR,
                  &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
-                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Gain2_c,
+                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Gain2_hu,
                  &rtb_Gain_ge, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                  &rtDW.Mode_logic_RR, &rtb_Divide1, &Valve_2_way,
                  &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level3_i0);
 
-        /* End of Outputs for SubSystem: '<S985>/Level 3' */
+        /* End of Outputs for SubSystem: '<S1031>/Level 3' */
         break;
 
        case 4:
-        /* Outputs for IfAction SubSystem: '<S985>/Level 4' incorporates:
-         *  ActionPort: '<S1098>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1031>/Level 4' incorporates:
+         *  ActionPort: '<S1144>/Action Port'
          */
-        Level3_i(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR,
+        Level3_i(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR,
                  &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
-                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Gain2_c,
+                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Gain2_hu,
                  &rtb_Gain_ge, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                  &rtDW.Mode_logic_RR, &rtb_Divide1, &Valve_2_way,
                  &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level4_j);
 
-        /* End of Outputs for SubSystem: '<S985>/Level 4' */
+        /* End of Outputs for SubSystem: '<S1031>/Level 4' */
         break;
 
        case 5:
-        /* Outputs for IfAction SubSystem: '<S985>/Level 5' incorporates:
-         *  ActionPort: '<S1099>/Action Port'
+        /* Outputs for IfAction SubSystem: '<S1031>/Level 5' incorporates:
+         *  ActionPort: '<S1145>/Action Port'
          */
-        Level3_i(&rtB.Merge_c, &rtb_out_ee, &rtDW.Blower_RR,
+        Level3_i(&rtB.Merge_c, &FIU_SET_RR, &rtDW.Blower_RR,
                  &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
-                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Gain2_c,
+                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Gain2_hu,
                  &rtb_Gain_ge, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                  &rtDW.Mode_logic_RR, &rtb_Divide1, &Valve_2_way,
                  &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level5_e);
 
-        /* End of Outputs for SubSystem: '<S985>/Level 5' */
+        /* End of Outputs for SubSystem: '<S1031>/Level 5' */
         break;
       }
 
-      /* End of SwitchCase: '<S985>/Switch Case' */
-      /* End of Outputs for SubSystem: '<S721>/Step 2 R' */
+      /* End of SwitchCase: '<S1031>/Switch Case' */
+      /* End of Outputs for SubSystem: '<S767>/Step 2 R' */
       break;
 
      case 3:
-      /* Outputs for IfAction SubSystem: '<S721>/Step 3 R' incorporates:
-       *  ActionPort: '<S986>/Action Port'
+      /* Outputs for IfAction SubSystem: '<S767>/Step 3 R' incorporates:
+       *  ActionPort: '<S1032>/Action Port'
        */
       Step3F(&rtB.Merge_c, &rtDW.start_control_finished_front);
 
-      /* End of Outputs for SubSystem: '<S721>/Step 3 R' */
+      /* End of Outputs for SubSystem: '<S767>/Step 3 R' */
       break;
     }
 
-    /* End of SwitchCase: '<S721>/Switch Case' */
+    /* End of SwitchCase: '<S767>/Switch Case' */
 
-    /* DataStoreWrite: '<S721>/Data Store Write' */
+    /* DataStoreWrite: '<S767>/Data Store Write' */
     rtDW.step_start_controle_rear = rtB.Merge_c;
 
     /* End of Outputs for SubSystem: '<S8>/Start Control Rear' */
@@ -16233,13 +17131,13 @@ void HVAC_model_initialize(void)
   {
     int32_t i;
     for (i = 0; i < 9; i++) {
-      /* Start for DataStoreMemory: '<S483>/Data Store Memory1' */
+      /* Start for DataStoreMemory: '<S501>/Data Store Memory1' */
       rtDW.ErrorCalibration_private[i] = 1U;
 
-      /* Start for DataStoreMemory: '<S484>/Data Store Memory1' */
+      /* Start for DataStoreMemory: '<S502>/Data Store Memory1' */
       rtDW.ErrorCalibration_private_b[i] = 1U;
 
-      /* Start for DataStoreMemory: '<S485>/Data Store Memory1' */
+      /* Start for DataStoreMemory: '<S503>/Data Store Memory1' */
       rtDW.ErrorCalibration_private_h[i] = 1U;
     }
 
@@ -16261,74 +17159,74 @@ void HVAC_model_initialize(void)
     /* SystemInitialize for MATLAB Function: '<S10>/Log Ambient Lv' */
     rtDW.current_Ambient_Lv_not_empty = false;
 
-    /* SystemInitialize for IfAction SubSystem: '<S483>/Homing' */
-    /* SystemInitialize for IfAction SubSystem: '<S490>/Switch Case Action Subsystem3' */
-    /* SystemInitialize for IfAction SubSystem: '<S509>/If Action Subsystem' */
-    /* Start for DataStoreMemory: '<S524>/Data Store Memory' */
+    /* SystemInitialize for IfAction SubSystem: '<S501>/Homing' */
+    /* SystemInitialize for IfAction SubSystem: '<S508>/Switch Case Action Subsystem3' */
+    /* SystemInitialize for IfAction SubSystem: '<S527>/If Action Subsystem' */
+    /* Start for DataStoreMemory: '<S542>/Data Store Memory' */
     rtDW.Start_timer_i = 1.0;
 
-    /* SystemInitialize for MATLAB Function: '<S524>/MATLAB Function' */
+    /* SystemInitialize for MATLAB Function: '<S542>/MATLAB Function' */
     MATLABFunction_Init(&rtDW.sf_MATLABFunction);
 
-    /* End of SystemInitialize for SubSystem: '<S509>/If Action Subsystem' */
-    /* End of SystemInitialize for SubSystem: '<S490>/Switch Case Action Subsystem3' */
+    /* End of SystemInitialize for SubSystem: '<S527>/If Action Subsystem' */
+    /* End of SystemInitialize for SubSystem: '<S508>/Switch Case Action Subsystem3' */
 
-    /* SystemInitialize for Merge: '<S490>/Merge' */
+    /* SystemInitialize for Merge: '<S508>/Merge' */
     rtB.Merge_h1 = 0;
 
-    /* End of SystemInitialize for SubSystem: '<S483>/Homing' */
+    /* End of SystemInitialize for SubSystem: '<S501>/Homing' */
 
-    /* SystemInitialize for Merge: '<S483>/Merge' */
+    /* SystemInitialize for Merge: '<S501>/Merge' */
     rtB.Merge_l = 0;
 
-    /* SystemInitialize for IfAction SubSystem: '<S484>/Homing' */
-    /* SystemInitialize for IfAction SubSystem: '<S557>/Switch Case Action Subsystem3' */
-    /* SystemInitialize for IfAction SubSystem: '<S576>/If Action Subsystem' */
-    /* Start for DataStoreMemory: '<S591>/Data Store Memory' */
+    /* SystemInitialize for IfAction SubSystem: '<S502>/Homing' */
+    /* SystemInitialize for IfAction SubSystem: '<S578>/Switch Case Action Subsystem3' */
+    /* SystemInitialize for IfAction SubSystem: '<S597>/If Action Subsystem' */
+    /* Start for DataStoreMemory: '<S612>/Data Store Memory' */
     rtDW.Start_timer_l = 1.0;
 
-    /* SystemInitialize for MATLAB Function: '<S591>/MATLAB Function' */
+    /* SystemInitialize for MATLAB Function: '<S612>/MATLAB Function' */
     MATLABFunction_Init(&rtDW.sf_MATLABFunction_i);
 
-    /* End of SystemInitialize for SubSystem: '<S576>/If Action Subsystem' */
-    /* End of SystemInitialize for SubSystem: '<S557>/Switch Case Action Subsystem3' */
+    /* End of SystemInitialize for SubSystem: '<S597>/If Action Subsystem' */
+    /* End of SystemInitialize for SubSystem: '<S578>/Switch Case Action Subsystem3' */
 
-    /* SystemInitialize for Merge: '<S557>/Merge' */
+    /* SystemInitialize for Merge: '<S578>/Merge' */
     rtB.Merge_hu = 0;
 
-    /* End of SystemInitialize for SubSystem: '<S484>/Homing' */
+    /* End of SystemInitialize for SubSystem: '<S502>/Homing' */
 
-    /* SystemInitialize for Merge: '<S484>/Merge' */
+    /* SystemInitialize for Merge: '<S502>/Merge' */
     rtB.Merge_h = 0;
 
-    /* SystemInitialize for IfAction SubSystem: '<S485>/Homing' */
-    /* SystemInitialize for IfAction SubSystem: '<S624>/Switch Case Action Subsystem3' */
-    /* SystemInitialize for IfAction SubSystem: '<S643>/If Action Subsystem' */
-    /* Start for DataStoreMemory: '<S658>/Data Store Memory' */
+    /* SystemInitialize for IfAction SubSystem: '<S503>/Homing' */
+    /* SystemInitialize for IfAction SubSystem: '<S645>/Switch Case Action Subsystem3' */
+    /* SystemInitialize for IfAction SubSystem: '<S664>/If Action Subsystem' */
+    /* Start for DataStoreMemory: '<S679>/Data Store Memory' */
     rtDW.Start_timer = 1.0;
 
-    /* SystemInitialize for MATLAB Function: '<S658>/MATLAB Function' */
+    /* SystemInitialize for MATLAB Function: '<S679>/MATLAB Function' */
     MATLABFunction_Init(&rtDW.sf_MATLABFunction_c);
 
-    /* End of SystemInitialize for SubSystem: '<S643>/If Action Subsystem' */
-    /* End of SystemInitialize for SubSystem: '<S624>/Switch Case Action Subsystem3' */
+    /* End of SystemInitialize for SubSystem: '<S664>/If Action Subsystem' */
+    /* End of SystemInitialize for SubSystem: '<S645>/Switch Case Action Subsystem3' */
 
-    /* SystemInitialize for Merge: '<S624>/Merge' */
+    /* SystemInitialize for Merge: '<S645>/Merge' */
     rtB.Merge_j = 0;
 
-    /* End of SystemInitialize for SubSystem: '<S485>/Homing' */
+    /* End of SystemInitialize for SubSystem: '<S503>/Homing' */
 
-    /* SystemInitialize for Merge: '<S485>/Merge' */
+    /* SystemInitialize for Merge: '<S503>/Merge' */
     rtB.Merge_bj = 0;
 
     /* SystemInitialize for IfAction SubSystem: '<S8>/Start Control Front' */
-    /* SystemInitialize for Merge: '<S720>/Merge' */
+    /* SystemInitialize for Merge: '<S766>/Merge' */
     rtB.Merge_ho = 0;
 
     /* End of SystemInitialize for SubSystem: '<S8>/Start Control Front' */
 
     /* SystemInitialize for IfAction SubSystem: '<S8>/Start Control Rear' */
-    /* SystemInitialize for Merge: '<S721>/Merge' */
+    /* SystemInitialize for Merge: '<S767>/Merge' */
     rtB.Merge_c = 0;
 
     /* End of SystemInitialize for SubSystem: '<S8>/Start Control Rear' */
diff --git a/HVAC_model.h b/HVAC_model.h
index 037b8a2..9fc9f4b 100644
--- a/HVAC_model.h
+++ b/HVAC_model.h
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.866
+ * Model version                  : 1.876
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Tue May  5 14:20:39 2026
+ * C/C++ source code generated on : Wed May  6 14:55:30 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -40,61 +40,61 @@
 /* user code (top of header file) */
 #include <stdio.h>
 
-/* Block states (default storage) for system '<S524>/MATLAB Function' */
+/* Block states (default storage) for system '<S542>/MATLAB Function' */
 typedef struct {
-  double cond_prev;                    /* '<S524>/MATLAB Function' */
-  uint32_t t_start;                    /* '<S524>/MATLAB Function' */
-  bool t_start_not_empty;              /* '<S524>/MATLAB Function' */
+  double cond_prev;                    /* '<S542>/MATLAB Function' */
+  uint32_t t_start;                    /* '<S542>/MATLAB Function' */
+  bool t_start_not_empty;              /* '<S542>/MATLAB Function' */
 } DW_MATLABFunction;
 
-/* Block states (default storage) for system '<S724>/Level 4' */
+/* Block states (default storage) for system '<S770>/Level 4' */
 typedef struct {
-  uint32_t t_start_delay_private_DSTATE;/* '<S801>/t_start_delay_private ' */
-  bool Cond_prev_private_DSTATE;       /* '<S801>/Cond_prev_private ' */
+  uint32_t t_start_delay_private_DSTATE;/* '<S847>/t_start_delay_private ' */
+  bool Cond_prev_private_DSTATE;       /* '<S847>/Cond_prev_private ' */
 } DW_Level4_n;
 
-/* Block states (default storage) for system '<S725>/Level 3' */
+/* Block states (default storage) for system '<S771>/Level 3' */
 typedef struct {
-  uint32_t UnitDelay_DSTATE;           /* '<S901>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_i;         /* '<S906>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_j;         /* '<S916>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_a;         /* '<S911>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE;/* '<S892>/t_start_delay_private ' */
-  bool Cond_prev_private_DSTATE;       /* '<S892>/Cond_prev_private ' */
+  uint32_t UnitDelay_DSTATE;           /* '<S947>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_i;         /* '<S952>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_j;         /* '<S962>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_a;         /* '<S957>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE;/* '<S938>/t_start_delay_private ' */
+  bool Cond_prev_private_DSTATE;       /* '<S938>/Cond_prev_private ' */
 } DW_Level3;
 
-/* Block states (default storage) for system '<S984>/Level 0' */
+/* Block states (default storage) for system '<S1030>/Level 0' */
 typedef struct {
-  uint32_t t_start_delay_private_DSTATE;/* '<S1033>/t_start_delay_private ' */
-  bool Cond_prev_private_DSTATE;       /* '<S1033>/Cond_prev_private ' */
+  uint32_t t_start_delay_private_DSTATE;/* '<S1079>/t_start_delay_private ' */
+  bool Cond_prev_private_DSTATE;       /* '<S1079>/Cond_prev_private ' */
 } DW_Level0_c;
 
-/* Block states (default storage) for system '<S984>/Level 4' */
+/* Block states (default storage) for system '<S1030>/Level 4' */
 typedef struct {
-  uint32_t t_start_delay_private_DSTATE;/* '<S1075>/t_start_delay_private ' */
-  bool Cond_prev_private_DSTATE;       /* '<S1075>/Cond_prev_private ' */
+  uint32_t t_start_delay_private_DSTATE;/* '<S1121>/t_start_delay_private ' */
+  bool Cond_prev_private_DSTATE;       /* '<S1121>/Cond_prev_private ' */
 } DW_Level4_a;
 
-/* Block states (default storage) for system '<S985>/Level 3' */
+/* Block states (default storage) for system '<S1031>/Level 3' */
 typedef struct {
-  uint32_t UnitDelay_DSTATE;           /* '<S1178>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_i;         /* '<S1188>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_e;         /* '<S1183>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE;/* '<S1171>/t_start_delay_private ' */
-  bool Cond_prev_private_DSTATE;       /* '<S1171>/Cond_prev_private ' */
+  uint32_t UnitDelay_DSTATE;           /* '<S1224>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_i;         /* '<S1234>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_e;         /* '<S1229>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE;/* '<S1217>/t_start_delay_private ' */
+  bool Cond_prev_private_DSTATE;       /* '<S1217>/Cond_prev_private ' */
 } DW_Level3_n;
 
 /* Block signals (default storage) */
 typedef struct {
   uint8_t Merge_b;                     /* '<S10>/Merge' */
-  int8_t Merge_l;                      /* '<S483>/Merge' */
-  int8_t Merge_h;                      /* '<S484>/Merge' */
-  int8_t Merge_bj;                     /* '<S485>/Merge' */
-  int8_t Merge_c;                      /* '<S721>/Merge' */
-  int8_t Merge_ho;                     /* '<S720>/Merge' */
-  int8_t Merge_j;                      /* '<S624>/Merge' */
-  int8_t Merge_hu;                     /* '<S557>/Merge' */
-  int8_t Merge_h1;                     /* '<S490>/Merge' */
+  int8_t Merge_l;                      /* '<S501>/Merge' */
+  int8_t Merge_h;                      /* '<S502>/Merge' */
+  int8_t Merge_bj;                     /* '<S503>/Merge' */
+  int8_t Merge_c;                      /* '<S767>/Merge' */
+  int8_t Merge_ho;                     /* '<S766>/Merge' */
+  int8_t Merge_j;                      /* '<S645>/Merge' */
+  int8_t Merge_hu;                     /* '<S578>/Merge' */
+  int8_t Merge_h1;                     /* '<S508>/Merge' */
 } B;
 
 /* Block states (default storage) for system '<Root>' */
@@ -104,18 +104,19 @@ typedef struct {
   CmdCAN_CCU_STAT1_Bus CCU_STAT1_MODEL;/* '<Root>/Data Store Memory105' */
   CmdCAN_FIU_CCU1_Bus FIU_CCU1_MODEL;  /* '<Root>/Data Store Memory43' */
   CmdCAN_FIU_CCU2_Bus FIU_CCU2_MODEL;  /* '<Root>/Data Store Memory44' */
+  dbgCAN_dbg_Logic_Blower_Bus dbgCAN_dbg_Logic_Blower_model;/* '<Root>/Data Store Memory64' */
   double LOGGER_ACP;                   /* '<S2>/Data Store Memory1' */
-  double ErrorHomming_private;         /* '<S483>/Data Store Memory2' */
-  double ErrorHomming_private_j;       /* '<S484>/Data Store Memory2' */
-  double ErrorHomming_private_m;       /* '<S485>/Data Store Memory2' */
+  double ErrorHomming_private;         /* '<S501>/Data Store Memory2' */
+  double ErrorHomming_private_j;       /* '<S502>/Data Store Memory2' */
+  double ErrorHomming_private_m;       /* '<S503>/Data Store Memory2' */
   double LOGGER_LIN;                   /* '<S5>/Data Store Memory1' */
   double SKIPPED_FIRST_SIMULATION_STEP;/* '<Root>/Data Store Memory131' */
   double MODE_DRIVER;                  /* '<Root>/Data Store Memory18' */
   double MODE_RR_passenger;            /* '<Root>/Data Store Memory19' */
   double start_control_finished_rear;  /* '<Root>/SC Rear' */
-  double Start_timer;                  /* '<S658>/Data Store Memory' */
-  double Start_timer_l;                /* '<S591>/Data Store Memory' */
-  double Start_timer_i;                /* '<S524>/Data Store Memory' */
+  double Start_timer;                  /* '<S679>/Data Store Memory' */
+  double Start_timer_l;                /* '<S612>/Data Store Memory' */
+  double Start_timer_i;                /* '<S542>/Data Store Memory' */
   CmdBusPwm PWM_Set_Model;             /* '<Root>/Data Store Memory129' */
   dbgCAN_dbg_Act0_Bus dbgCAN_dbg_Act0_model;/* '<Root>/Data Store Memory79' */
   dbgCAN_dbg_Act1_Bus dbgCAN_dbg_Act1_model;/* '<Root>/Data Store Memory80' */
@@ -140,48 +141,51 @@ typedef struct {
   uint32_t t_start_delay_private_DSTATE_n;/* '<S413>/t_start_delay_private ' */
   uint32_t t_start_delay_private_DSTATE_ew;/* '<S426>/t_start_delay_private ' */
   uint32_t t_start_delay_private_DSTATE_i0;/* '<S427>/t_start_delay_private ' */
-  uint32_t UnitDelay_DSTATE;           /* '<S1155>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_h;         /* '<S1165>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_n;         /* '<S1160>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE_ed;/* '<S1148>/t_start_delay_private ' */
-  uint32_t UnitDelay_DSTATE_g;         /* '<S1132>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_p;         /* '<S1142>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_j;         /* '<S1137>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE_jh;/* '<S1125>/t_start_delay_private ' */
-  uint32_t UnitDelay_DSTATE_d;         /* '<S1109>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_nc;        /* '<S1119>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_hs;        /* '<S1114>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE_fvm;/* '<S1102>/t_start_delay_private ' */
-  uint32_t t_start_delay_private_DSTATE_o;/* '<S1063>/t_start_delay_private ' */
-  uint32_t t_start_delay_private_DSTATE_em;/* '<S1051>/t_start_delay_private ' */
-  uint32_t UnitDelay_DSTATE_f;         /* '<S963>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_pu;        /* '<S968>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_b;         /* '<S978>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_e;         /* '<S973>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE_nr;/* '<S954>/t_start_delay_private ' */
-  uint32_t UnitDelay_DSTATE_m;         /* '<S870>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_gf;        /* '<S875>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_l;         /* '<S885>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_p0;        /* '<S880>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE_mz;/* '<S862>/t_start_delay_private ' */
-  uint32_t UnitDelay_DSTATE_k;         /* '<S840>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_pb;        /* '<S845>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_mk;        /* '<S855>/Unit Delay' */
-  uint32_t UnitDelay_DSTATE_gm;        /* '<S850>/Unit Delay' */
-  uint32_t t_start_delay_private_DSTATE_g;/* '<S832>/t_start_delay_private ' */
-  uint32_t t_start_delay_private_DSTATE_fm;/* '<S787>/t_start_delay_private ' */
-  uint32_t t_start_delay_private_DSTATE_mk;/* '<S776>/t_start_delay_private ' */
-  uint32_t t_start_delay_private_DSTATE_pd;/* '<S765>/t_start_delay_private ' */
+  uint32_t UnitDelay_DSTATE;           /* '<S1201>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_h;         /* '<S1211>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_n;         /* '<S1206>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE_ed;/* '<S1194>/t_start_delay_private ' */
+  uint32_t UnitDelay_DSTATE_g;         /* '<S1178>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_p;         /* '<S1188>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_j;         /* '<S1183>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE_jh;/* '<S1171>/t_start_delay_private ' */
+  uint32_t UnitDelay_DSTATE_d;         /* '<S1155>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_nc;        /* '<S1165>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_hs;        /* '<S1160>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE_fvm;/* '<S1148>/t_start_delay_private ' */
+  uint32_t t_start_delay_private_DSTATE_o;/* '<S1109>/t_start_delay_private ' */
+  uint32_t t_start_delay_private_DSTATE_em;/* '<S1097>/t_start_delay_private ' */
+  uint32_t UnitDelay_DSTATE_f;         /* '<S1009>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_pu;        /* '<S1014>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_b;         /* '<S1024>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_e;         /* '<S1019>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE_nr;/* '<S1000>/t_start_delay_private ' */
+  uint32_t UnitDelay_DSTATE_m;         /* '<S916>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_gf;        /* '<S921>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_l;         /* '<S931>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_p0;        /* '<S926>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE_mz;/* '<S908>/t_start_delay_private ' */
+  uint32_t UnitDelay_DSTATE_k;         /* '<S886>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_pb;        /* '<S891>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_mk;        /* '<S901>/Unit Delay' */
+  uint32_t UnitDelay_DSTATE_gm;        /* '<S896>/Unit Delay' */
+  uint32_t t_start_delay_private_DSTATE_g;/* '<S878>/t_start_delay_private ' */
+  uint32_t t_start_delay_private_DSTATE_fm;/* '<S833>/t_start_delay_private ' */
+  uint32_t t_start_delay_private_DSTATE_mk;/* '<S822>/t_start_delay_private ' */
+  uint32_t t_start_delay_private_DSTATE_pd;/* '<S811>/t_start_delay_private ' */
   uint32_t t_now;                      /* '<Root>/Data Store Memory5' */
-  int16_t MinPositionCh0_private[9];   /* '<S483>/Data Store Memory12' */
-  int16_t MaxPositionCh0_private[9];   /* '<S483>/Data Store Memory13' */
-  int16_t MinPositionCh1_private[9];   /* '<S484>/Data Store Memory12' */
-  int16_t MaxPositionCh1_private[9];   /* '<S484>/Data Store Memory13' */
-  int16_t MinPositionCh2_private[9];   /* '<S485>/Data Store Memory12' */
-  int16_t MaxPositionCh2_private[9];   /* '<S485>/Data Store Memory13' */
-  uint16_t POS_private[9];             /* '<S483>/Data Store Memory3' */
-  uint16_t POS_private_o[9];           /* '<S484>/Data Store Memory3' */
-  uint16_t POS_private_g[9];           /* '<S485>/Data Store Memory3' */
+  int16_t MinPositionCh0_private[9];   /* '<S501>/Data Store Memory12' */
+  int16_t MaxPositionCh0_private[9];   /* '<S501>/Data Store Memory13' */
+  int16_t MinPositionCh1_private[9];   /* '<S502>/Data Store Memory12' */
+  int16_t MaxPositionCh1_private[9];   /* '<S502>/Data Store Memory13' */
+  int16_t MinPositionCh2_private[9];   /* '<S503>/Data Store Memory12' */
+  int16_t MaxPositionCh2_private[9];   /* '<S503>/Data Store Memory13' */
+  uint16_t POS_private[9];             /* '<S501>/Data Store Memory3' */
+  uint16_t POS_private_o[9];           /* '<S502>/Data Store Memory3' */
+  uint16_t POS_private_g[9];           /* '<S503>/Data Store Memory3' */
+  uint16_t valves_front_manual_target[9];/* '<Root>/Data Store Memory133' */
+  uint16_t FIU_SET_FR;                 /* '<Root>/Data Store Memory14' */
+  uint16_t FIU_SET_FL;                 /* '<Root>/Data Store Memory15' */
   uint16_t Blower_FL;                  /* '<Root>/Data Store Memory27' */
   uint16_t Blower_RR;                  /* '<Root>/Data Store Memory32' */
   uint16_t Blower_logic_FL;            /* '<Root>/Data Store Memory37' */
@@ -205,56 +209,56 @@ typedef struct {
   bool Cond_prev_private_DSTATE_gc;    /* '<S413>/Cond_prev_private ' */
   bool Cond_prev_private_DSTATE_ao;    /* '<S426>/Cond_prev_private ' */
   bool Cond_prev_private_DSTATE_ck;    /* '<S427>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_ei;    /* '<S1148>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_j;     /* '<S1125>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_i5;    /* '<S1102>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_aw;    /* '<S1063>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_cp;    /* '<S1051>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_iy;    /* '<S954>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_b3;    /* '<S862>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_m;     /* '<S832>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_f;     /* '<S787>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_h;     /* '<S776>/Cond_prev_private ' */
-  bool Cond_prev_private_DSTATE_gx;    /* '<S765>/Cond_prev_private ' */
-  int8_t stepSig_private;              /* '<S483>/Data Store Memory' */
-  int8_t stepHoming_private;           /* '<S483>/Data Store Memory17' */
-  int8_t stepSig_private_j;            /* '<S484>/Data Store Memory' */
-  int8_t stepHoming_private_p;         /* '<S484>/Data Store Memory17' */
-  int8_t stepSig_private_o;            /* '<S485>/Data Store Memory' */
-  int8_t stepHoming_private_f;         /* '<S485>/Data Store Memory17' */
+  bool Cond_prev_private_DSTATE_ei;    /* '<S1194>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_j;     /* '<S1171>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_i5;    /* '<S1148>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_aw;    /* '<S1109>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_cp;    /* '<S1097>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_iy;    /* '<S1000>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_b3;    /* '<S908>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_m;     /* '<S878>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_f;     /* '<S833>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_h;     /* '<S822>/Cond_prev_private ' */
+  bool Cond_prev_private_DSTATE_gx;    /* '<S811>/Cond_prev_private ' */
+  int8_t stepSig_private;              /* '<S501>/Data Store Memory' */
+  int8_t stepHoming_private;           /* '<S501>/Data Store Memory17' */
+  int8_t stepSig_private_j;            /* '<S502>/Data Store Memory' */
+  int8_t stepHoming_private_p;         /* '<S502>/Data Store Memory17' */
+  int8_t stepSig_private_o;            /* '<S503>/Data Store Memory' */
+  int8_t stepHoming_private_f;         /* '<S503>/Data Store Memory17' */
   int8_t step_start_controle_front;    /* '<S8>/Data Store Memory' */
   int8_t step_start_controle_rear;     /* '<S8>/Data Store Memory1' */
   int8_t start_control_finished_front; /* '<Root>/SC Front' */
-  uint8_t ErrorCalibration_private[9]; /* '<S483>/Data Store Memory1' */
-  uint8_t Speed_private[9];            /* '<S483>/Data Store Memory11' */
-  uint8_t Coils_private[9];            /* '<S483>/Data Store Memory16' */
-  uint8_t ErrorActuator[9];            /* '<S483>/Data Store Memory18' */
-  uint8_t BUS_ADR_private[9];          /* '<S483>/Data Store Memory4' */
-  uint8_t MODE_private[9];             /* '<S483>/Data Store Memory5' */
-  uint8_t COM_private[9];              /* '<S483>/Data Store Memory6' */
-  uint8_t Stall_private[9];            /* '<S483>/Data Store Memory7' */
-  uint8_t Lnoise_private[9];           /* '<S483>/Data Store Memory8' */
-  uint8_t Autos_private[9];            /* '<S483>/Data Store Memory9' */
-  uint8_t ErrorCalibration_private_b[9];/* '<S484>/Data Store Memory1' */
-  uint8_t Speed_private_e[9];          /* '<S484>/Data Store Memory11' */
-  uint8_t Coils_private_e[9];          /* '<S484>/Data Store Memory16' */
-  uint8_t ErrorActuator_c[9];          /* '<S484>/Data Store Memory18' */
-  uint8_t BUS_ADR_private_m[9];        /* '<S484>/Data Store Memory4' */
-  uint8_t MODE_private_a[9];           /* '<S484>/Data Store Memory5' */
-  uint8_t COM_private_n[9];            /* '<S484>/Data Store Memory6' */
-  uint8_t Stall_private_h[9];          /* '<S484>/Data Store Memory7' */
-  uint8_t Lnoise_private_p[9];         /* '<S484>/Data Store Memory8' */
-  uint8_t Autos_private_a[9];          /* '<S484>/Data Store Memory9' */
-  uint8_t ErrorCalibration_private_h[9];/* '<S485>/Data Store Memory1' */
-  uint8_t Speed_private_o[9];          /* '<S485>/Data Store Memory11' */
-  uint8_t Coils_private_m[9];          /* '<S485>/Data Store Memory16' */
-  uint8_t ErrorActuator_o[9];          /* '<S485>/Data Store Memory18' */
-  uint8_t BUS_ADR_private_p[9];        /* '<S485>/Data Store Memory4' */
-  uint8_t MODE_private_p[9];           /* '<S485>/Data Store Memory5' */
-  uint8_t COM_private_b[9];            /* '<S485>/Data Store Memory6' */
-  uint8_t Stall_private_h3[9];         /* '<S485>/Data Store Memory7' */
-  uint8_t Lnoise_private_k[9];         /* '<S485>/Data Store Memory8' */
-  uint8_t Autos_private_k[9];          /* '<S485>/Data Store Memory9' */
+  uint8_t ErrorCalibration_private[9]; /* '<S501>/Data Store Memory1' */
+  uint8_t Speed_private[9];            /* '<S501>/Data Store Memory11' */
+  uint8_t Coils_private[9];            /* '<S501>/Data Store Memory16' */
+  uint8_t ErrorActuator[9];            /* '<S501>/Data Store Memory18' */
+  uint8_t BUS_ADR_private[9];          /* '<S501>/Data Store Memory4' */
+  uint8_t MODE_private[9];             /* '<S501>/Data Store Memory5' */
+  uint8_t COM_private[9];              /* '<S501>/Data Store Memory6' */
+  uint8_t Stall_private[9];            /* '<S501>/Data Store Memory7' */
+  uint8_t Lnoise_private[9];           /* '<S501>/Data Store Memory8' */
+  uint8_t Autos_private[9];            /* '<S501>/Data Store Memory9' */
+  uint8_t ErrorCalibration_private_b[9];/* '<S502>/Data Store Memory1' */
+  uint8_t Speed_private_e[9];          /* '<S502>/Data Store Memory11' */
+  uint8_t Coils_private_e[9];          /* '<S502>/Data Store Memory16' */
+  uint8_t ErrorActuator_c[9];          /* '<S502>/Data Store Memory18' */
+  uint8_t BUS_ADR_private_m[9];        /* '<S502>/Data Store Memory4' */
+  uint8_t MODE_private_a[9];           /* '<S502>/Data Store Memory5' */
+  uint8_t COM_private_n[9];            /* '<S502>/Data Store Memory6' */
+  uint8_t Stall_private_h[9];          /* '<S502>/Data Store Memory7' */
+  uint8_t Lnoise_private_p[9];         /* '<S502>/Data Store Memory8' */
+  uint8_t Autos_private_a[9];          /* '<S502>/Data Store Memory9' */
+  uint8_t ErrorCalibration_private_h[9];/* '<S503>/Data Store Memory1' */
+  uint8_t Speed_private_o[9];          /* '<S503>/Data Store Memory11' */
+  uint8_t Coils_private_m[9];          /* '<S503>/Data Store Memory16' */
+  uint8_t ErrorActuator_o[9];          /* '<S503>/Data Store Memory18' */
+  uint8_t BUS_ADR_private_p[9];        /* '<S503>/Data Store Memory4' */
+  uint8_t MODE_private_p[9];           /* '<S503>/Data Store Memory5' */
+  uint8_t COM_private_b[9];            /* '<S503>/Data Store Memory6' */
+  uint8_t Stall_private_h3[9];         /* '<S503>/Data Store Memory7' */
+  uint8_t Lnoise_private_k[9];         /* '<S503>/Data Store Memory8' */
+  uint8_t Autos_private_k[9];          /* '<S503>/Data Store Memory9' */
   uint8_t CCU_ActuatorErrF_Stat_private;/* '<Root>/Data Store Memory' */
   uint8_t dtc_state_error_model[127];  /* '<Root>/Data Store Memory1' */
   uint8_t FIU_MODE_RL;                 /* '<Root>/Data Store Memory108' */
@@ -275,11 +279,12 @@ typedef struct {
   uint8_t FIU_DeflectorSwFCR;          /* '<Root>/Data Store Memory123' */
   uint8_t FIU_DeflectorSwRRB;          /* '<Root>/Data Store Memory124' */
   uint8_t FIU_REAR_SYNC;               /* '<Root>/Data Store Memory125' */
-  uint8_t PWM_rear;                    /* '<Root>/Data Store Memory126' */
-  uint8_t FIU_SET_FR;                  /* '<Root>/Data Store Memory14' */
-  uint8_t FIU_SET_FL;                  /* '<Root>/Data Store Memory15' */
-  uint8_t FIU_SET_RR;                  /* '<Root>/Data Store Memory16' */
-  uint8_t FIU_SET_RL;                  /* '<Root>/Data Store Memory17' */
+  uint8_t Blower_AF_FL;                /* '<Root>/Data Store Memory126' */
+  uint8_t Blower_AF_FR;                /* '<Root>/Data Store Memory127' */
+  uint8_t Blower_AF_RL;                /* '<Root>/Data Store Memory130' */
+  uint8_t PWM_rear;                    /* '<Root>/Data Store Memory132' */
+  uint8_t PWM_front;                   /* '<Root>/Data Store Memory135' */
+  uint8_t Blower_AF_RR;                /* '<Root>/Data Store Memory136' */
   uint8_t Mode_FL;                     /* '<Root>/Data Store Memory23' */
   uint8_t Dtg_FUL;                     /* '<Root>/Data Store Memory31' */
   uint8_t Dtg_FLL;                     /* '<Root>/Data Store Memory34' */
@@ -290,7 +295,6 @@ typedef struct {
   uint8_t Dtg_RR;                      /* '<Root>/Data Store Memory52' */
   uint8_t Mode_logic_RR;               /* '<Root>/Data Store Memory54' */
   uint8_t Dtg_logic_RR;                /* '<Root>/Data Store Memory58' */
-  uint8_t PWM_front;                   /* '<Root>/Data Store Memory64' */
   uint8_t CCU_ActuatorErrR_Stat_private;/* '<Root>/Data Store Memory67' */
   uint8_t FIU_MODE_FL;                 /* '<Root>/Data Store Memory78' */
   uint8_t FIU_DEF_FL;                  /* '<Root>/Data Store Memory84' */
@@ -308,32 +312,32 @@ typedef struct {
   uint8_t current_Ambient_Lv;          /* '<S10>/Log Ambient Lv' */
   bool HI_logic_on;                    /* '<Root>/Data Store Memory48' */
   bool current_Ambient_Lv_not_empty;   /* '<S10>/Log Ambient Lv' */
-  DW_Level3_n Level5_e;                /* '<S985>/Level 5' */
-  DW_Level3_n Level4_j;                /* '<S985>/Level 4' */
-  DW_Level3_n Level3_i0;               /* '<S985>/Level 3' */
-  DW_Level4_a Level5_f;                /* '<S984>/Level 5' */
-  DW_Level4_a Level4_dp;               /* '<S984>/Level 4' */
-  DW_Level0_c Level1_d3;               /* '<S984>/Level 1' */
-  DW_Level0_c Level0_bc;               /* '<S984>/Level 0' */
-  DW_Level3 Level4_a;                  /* '<S725>/Level 4' */
-  DW_Level3 Level3_l;                  /* '<S725>/Level 3' */
-  DW_Level4_n Level5_g;                /* '<S724>/Level 5' */
-  DW_Level4_n Level4_cw;               /* '<S724>/Level 4' */
-  DW_MATLABFunction sf_MATLABFunction_c;/* '<S658>/MATLAB Function' */
-  DW_MATLABFunction sf_MATLABFunction_i;/* '<S591>/MATLAB Function' */
-  DW_MATLABFunction sf_MATLABFunction; /* '<S524>/MATLAB Function' */
+  DW_Level3_n Level5_e;                /* '<S1031>/Level 5' */
+  DW_Level3_n Level4_j;                /* '<S1031>/Level 4' */
+  DW_Level3_n Level3_i0;               /* '<S1031>/Level 3' */
+  DW_Level4_a Level5_f;                /* '<S1030>/Level 5' */
+  DW_Level4_a Level4_dp;               /* '<S1030>/Level 4' */
+  DW_Level0_c Level1_d3;               /* '<S1030>/Level 1' */
+  DW_Level0_c Level0_bc;               /* '<S1030>/Level 0' */
+  DW_Level3 Level4_a;                  /* '<S771>/Level 4' */
+  DW_Level3 Level3_l;                  /* '<S771>/Level 3' */
+  DW_Level4_n Level5_g;                /* '<S770>/Level 5' */
+  DW_Level4_n Level4_cw;               /* '<S770>/Level 4' */
+  DW_MATLABFunction sf_MATLABFunction_c;/* '<S679>/MATLAB Function' */
+  DW_MATLABFunction sf_MATLABFunction_i;/* '<S612>/MATLAB Function' */
+  DW_MATLABFunction sf_MATLABFunction; /* '<S542>/MATLAB Function' */
 } DW;
 
-/* Invariant block signals for system '<S509>/If Action Subsystem1' */
+/* Invariant block signals for system '<S527>/If Action Subsystem1' */
 typedef struct {
-  const uint8_t DataTypeConversion[9]; /* '<S525>/Data Type Conversion' */
-} ConstB_IfActionSubsystem1_c;
+  const uint8_t DataTypeConversion[9]; /* '<S543>/Data Type Conversion' */
+} ConstB_IfActionSubsystem1;
 
 /* Invariant block signals (default storage) */
 typedef struct {
-  ConstB_IfActionSubsystem1_c IfActionSubsystem1_c;/* '<S643>/If Action Subsystem1' */
-  ConstB_IfActionSubsystem1_c IfActionSubsystem1_n;/* '<S576>/If Action Subsystem1' */
-  ConstB_IfActionSubsystem1_c IfActionSubsystem1_dc;/* '<S509>/If Action Subsystem1' */
+  ConstB_IfActionSubsystem1 IfActionSubsystem1_c;/* '<S664>/If Action Subsystem1' */
+  ConstB_IfActionSubsystem1 IfActionSubsystem1_n;/* '<S597>/If Action Subsystem1' */
+  ConstB_IfActionSubsystem1 IfActionSubsystem1_d;/* '<S527>/If Action Subsystem1' */
 } ConstB;
 
 /* Constant parameters (default storage) */
@@ -389,7 +393,7 @@ typedef struct {
    *   '<S11>/Выбор режима Left'
    *   '<S11>/Выбор режима Right'
    */
-  uint32_t pooled35[2];
+  uint32_t pooled36[2];
 
   /* Computed Parameter: uDLookupTable_tableData_h
    * Referenced by: '<S10>/1-D Lookup Table'
@@ -401,7 +405,7 @@ typedef struct {
    *   '<S11>/Выбор режима Left'
    *   '<S11>/Выбор режима Right'
    */
-  int16_t pooled42[13];
+  int16_t pooled43[13];
 
   /* Pooled Parameter (Expression: [0:4:4092])
    * Referenced by:
@@ -424,35 +428,38 @@ typedef struct {
    *   '<S281>/1-D Lookup Table'
    *   '<S281>/1-D Lookup Table1'
    */
-  uint16_t pooled45[1024];
+  uint16_t pooled47[1024];
 
   /* Computed Parameter: ACT1_Value
-   * Referenced by: '<S505>/ACT1'
+   * Referenced by: '<S523>/ACT1'
    */
   uint16_t ACT1_Value[9];
 
   /* Computed Parameter: ACT1_Value_d
-   * Referenced by: '<S572>/ACT1'
+   * Referenced by: '<S593>/ACT1'
    */
   uint16_t ACT1_Value_d[6];
 
   /* Computed Parameter: ACT1_Value_o
-   * Referenced by: '<S639>/ACT1'
+   * Referenced by: '<S660>/ACT1'
    */
   uint16_t ACT1_Value_o[8];
 
-  /* Computed Parameter: Constant3_Value
-   * Referenced by: '<S487>/Constant3'
+  /* Pooled Parameter (Expression: [1 2 3 4 5 6 7 8 9])
+   * Referenced by:
+   *   '<S505>/Constant3'
+   *   '<S554>/Constant5'
+   *   '<S549>/Constant5'
    */
-  uint8_t Constant3_Value[9];
+  uint8_t pooled76[9];
 
-  /* Computed Parameter: Constant3_Value_i
-   * Referenced by: '<S554>/Constant3'
+  /* Computed Parameter: Constant3_Value
+   * Referenced by: '<S575>/Constant3'
    */
-  uint8_t Constant3_Value_i[6];
+  uint8_t Constant3_Value[6];
 
   /* Computed Parameter: Constant3_Value_j
-   * Referenced by: '<S621>/Constant3'
+   * Referenced by: '<S642>/Constant3'
    */
   uint8_t Constant3_Value_j[8];
 
@@ -461,7 +468,7 @@ typedef struct {
    *   '<S11>/Выбор режима Left'
    *   '<S11>/Выбор режима Right'
    */
-  uint8_t pooled76[6];
+  uint8_t pooled82[6];
 } ConstP;
 
 /* External outputs (root outports fed by signals with default storage) */
@@ -475,6 +482,8 @@ typedef struct {
   CmdBusPWMGet PWM_Get_f;              /* '<Root>/PWM_Get' */
   dbgCAN_dbg_Sen_Duct_Bus dbgCAN_dbg_Sen_Duct_model;/* '<Root>/dbgCAN_dbg_Sen_Duct_model' */
   dbgCAN_dbg_dbg_Sen_Eva_Bus dbgCAN_dbg_Sen_Eva_model;/* '<Root>/dbgCAN_dbg_Sen_Eva_model' */
+  dbgCAN_dbg_Logic_Blower_Bus dbgCAN_dbg_Logic_Blower_model;
+                                    /* '<Root>/dbgCAN_dbg_Logic_Blower_model' */
 } ExtY;
 
 /* Real-time Model Data Structure */
@@ -513,9 +522,9 @@ extern const ConstP rtConstP;
 extern ActuatorCmdBusInput Actuator_Ch0_Status_Model;/* '<Root>/Data Store Memory61' */
 extern ActuatorCmdBusInput Actuator_Ch1_Status_Model;/* '<Root>/Data Store Memory62' */
 extern ActuatorCmdBusInput Actuator_Ch2_Status_Model;/* '<Root>/Data Store Memory63' */
-extern ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S483>/Data Store Memory15' */
-extern ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S484>/Data Store Memory15' */
-extern ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S485>/Data Store Memory15' */
+extern ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S501>/Data Store Memory15' */
+extern ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S502>/Data Store Memory15' */
+extern ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S503>/Data Store Memory15' */
 extern CmdBusStatus Status_Sensor_Model;/* '<S2>/Data Store Memory' */
 extern CmdBusError CCU_Errors_Model;   /* '<Root>/Data Store Memory3' */
 extern CmdBusPWMGet PWM_Get;           /* '<Root>/Data Store Memory128' */
@@ -956,124 +965,117 @@ extern RT_MODEL *const rtM;
  * Block '<S281>/Display1' : Unused code path elimination
  * Block '<S428>/Display' : Unused code path elimination
  * Block '<S428>/Display1' : Unused code path elimination
+ * Block '<S3>/Display' : Unused code path elimination
  * Block '<S468>/Display2' : Unused code path elimination
- * Block '<Root>/Constant' : Unused code path elimination
- * Block '<Root>/Constant1' : Unused code path elimination
- * Block '<Root>/Equal' : Unused code path elimination
- * Block '<Root>/Equal1' : Unused code path elimination
- * Block '<S499>/Display' : Unused code path elimination
- * Block '<S483>/Display1' : Unused code path elimination
- * Block '<S505>/Display1' : Unused code path elimination
- * Block '<S490>/Display1' : Unused code path elimination
- * Block '<S514>/Display' : Unused code path elimination
- * Block '<S515>/Display' : Unused code path elimination
- * Block '<S507>/Display' : Unused code path elimination
- * Block '<S507>/Display1' : Unused code path elimination
- * Block '<S524>/Display' : Unused code path elimination
- * Block '<S524>/Display1' : Unused code path elimination
+ * Block '<S474>/Display' : Unused code path elimination
+ * Block '<S4>/Display' : Unused code path elimination
+ * Block '<S517>/Display' : Unused code path elimination
+ * Block '<S501>/Display1' : Unused code path elimination
+ * Block '<S523>/Display1' : Unused code path elimination
+ * Block '<S508>/Display1' : Unused code path elimination
+ * Block '<S532>/Display' : Unused code path elimination
+ * Block '<S533>/Display' : Unused code path elimination
  * Block '<S525>/Display' : Unused code path elimination
- * Block '<S492>/Display' : Unused code path elimination
- * Block '<S492>/Display3' : Unused code path elimination
- * Block '<S541>/Constant3' : Unused code path elimination
- * Block '<S495>/Display' : Unused code path elimination
- * Block '<S566>/Display' : Unused code path elimination
- * Block '<S484>/Display1' : Unused code path elimination
- * Block '<S572>/Display1' : Unused code path elimination
- * Block '<S557>/Display1' : Unused code path elimination
- * Block '<S581>/Display' : Unused code path elimination
- * Block '<S582>/Display' : Unused code path elimination
- * Block '<S574>/Display' : Unused code path elimination
- * Block '<S574>/Display1' : Unused code path elimination
- * Block '<S591>/Display' : Unused code path elimination
- * Block '<S591>/Display1' : Unused code path elimination
- * Block '<S592>/Display' : Unused code path elimination
- * Block '<S559>/Display' : Unused code path elimination
- * Block '<S559>/Display3' : Unused code path elimination
- * Block '<S562>/Display' : Unused code path elimination
- * Block '<S633>/Display' : Unused code path elimination
- * Block '<S485>/Display1' : Unused code path elimination
- * Block '<S639>/Display1' : Unused code path elimination
- * Block '<S624>/Display1' : Unused code path elimination
- * Block '<S648>/Display' : Unused code path elimination
- * Block '<S649>/Display' : Unused code path elimination
- * Block '<S641>/Display' : Unused code path elimination
- * Block '<S641>/Display1' : Unused code path elimination
- * Block '<S658>/Display' : Unused code path elimination
- * Block '<S658>/Display1' : Unused code path elimination
- * Block '<S659>/Display' : Unused code path elimination
- * Block '<S626>/Display' : Unused code path elimination
- * Block '<S626>/Display3' : Unused code path elimination
- * Block '<S629>/Display' : Unused code path elimination
- * Block '<Root>/Logical Operator' : Unused code path elimination
+ * Block '<S525>/Display1' : Unused code path elimination
+ * Block '<S542>/Display' : Unused code path elimination
+ * Block '<S542>/Display1' : Unused code path elimination
+ * Block '<S543>/Display' : Unused code path elimination
+ * Block '<S510>/Display' : Unused code path elimination
+ * Block '<S510>/Display3' : Unused code path elimination
+ * Block '<S562>/Constant3' : Unused code path elimination
+ * Block '<S513>/Display' : Unused code path elimination
+ * Block '<S587>/Display' : Unused code path elimination
+ * Block '<S502>/Display1' : Unused code path elimination
+ * Block '<S593>/Display1' : Unused code path elimination
+ * Block '<S578>/Display1' : Unused code path elimination
+ * Block '<S602>/Display' : Unused code path elimination
+ * Block '<S603>/Display' : Unused code path elimination
+ * Block '<S595>/Display' : Unused code path elimination
+ * Block '<S595>/Display1' : Unused code path elimination
+ * Block '<S612>/Display' : Unused code path elimination
+ * Block '<S612>/Display1' : Unused code path elimination
+ * Block '<S613>/Display' : Unused code path elimination
+ * Block '<S580>/Display' : Unused code path elimination
+ * Block '<S580>/Display3' : Unused code path elimination
+ * Block '<S583>/Display' : Unused code path elimination
+ * Block '<S654>/Display' : Unused code path elimination
+ * Block '<S503>/Display1' : Unused code path elimination
+ * Block '<S660>/Display1' : Unused code path elimination
+ * Block '<S645>/Display1' : Unused code path elimination
+ * Block '<S669>/Display' : Unused code path elimination
+ * Block '<S670>/Display' : Unused code path elimination
+ * Block '<S662>/Display' : Unused code path elimination
+ * Block '<S662>/Display1' : Unused code path elimination
+ * Block '<S679>/Display' : Unused code path elimination
+ * Block '<S679>/Display1' : Unused code path elimination
+ * Block '<S680>/Display' : Unused code path elimination
+ * Block '<S647>/Display' : Unused code path elimination
+ * Block '<S647>/Display3' : Unused code path elimination
+ * Block '<S650>/Display' : Unused code path elimination
+ * Block '<S709>/Display' : Unused code path elimination
  * Block '<S8>/Display' : Unused code path elimination
  * Block '<S8>/Display1' : Unused code path elimination
- * Block '<S720>/Display' : Unused code path elimination
- * Block '<S720>/Display1' : Unused code path elimination
- * Block '<S722>/Display' : Unused code path elimination
- * Block '<S728>/Display' : Unused code path elimination
- * Block '<S728>/Display1' : Unused code path elimination
- * Block '<S728>/Display2' : Unused code path elimination
- * Block '<S728>/Display3' : Unused code path elimination
- * Block '<S728>/Display4' : Unused code path elimination
- * Block '<S728>/Display5' : Unused code path elimination
- * Block '<S728>/Display6' : Unused code path elimination
- * Block '<S730>/Display' : Unused code path elimination
- * Block '<S730>/Display1' : Unused code path elimination
- * Block '<S730>/Display2' : Unused code path elimination
- * Block '<S755>/Display' : Unused code path elimination
- * Block '<S755>/Display1' : Unused code path elimination
- * Block '<S755>/Display10' : Unused code path elimination
- * Block '<S755>/Display11' : Unused code path elimination
- * Block '<S755>/Display12' : Unused code path elimination
- * Block '<S755>/Display13' : Unused code path elimination
- * Block '<S755>/Display2' : Unused code path elimination
- * Block '<S755>/Display3' : Unused code path elimination
- * Block '<S755>/Display4' : Unused code path elimination
- * Block '<S755>/Display5' : Unused code path elimination
- * Block '<S755>/Display6' : Unused code path elimination
- * Block '<S755>/Display7' : Unused code path elimination
- * Block '<S755>/Display8' : Unused code path elimination
- * Block '<S755>/Display9' : Unused code path elimination
- * Block '<S789>/Display' : Unused code path elimination
- * Block '<S803>/Display' : Unused code path elimination
- * Block '<S816>/Display' : Unused code path elimination
- * Block '<S840>/Display' : Unused code path elimination
- * Block '<S845>/Display' : Unused code path elimination
- * Block '<S850>/Display' : Unused code path elimination
- * Block '<S855>/Display' : Unused code path elimination
- * Block '<S870>/Display' : Unused code path elimination
- * Block '<S875>/Display' : Unused code path elimination
- * Block '<S880>/Display' : Unused code path elimination
- * Block '<S885>/Display' : Unused code path elimination
+ * Block '<S766>/Display' : Unused code path elimination
+ * Block '<S766>/Display1' : Unused code path elimination
+ * Block '<S768>/Display' : Unused code path elimination
+ * Block '<S774>/Display' : Unused code path elimination
+ * Block '<S774>/Display1' : Unused code path elimination
+ * Block '<S774>/Display2' : Unused code path elimination
+ * Block '<S774>/Display3' : Unused code path elimination
+ * Block '<S774>/Display4' : Unused code path elimination
+ * Block '<S774>/Display5' : Unused code path elimination
+ * Block '<S774>/Display6' : Unused code path elimination
+ * Block '<S776>/Display' : Unused code path elimination
+ * Block '<S776>/Display1' : Unused code path elimination
+ * Block '<S776>/Display2' : Unused code path elimination
+ * Block '<S801>/Display' : Unused code path elimination
+ * Block '<S801>/Display1' : Unused code path elimination
+ * Block '<S801>/Display10' : Unused code path elimination
+ * Block '<S801>/Display11' : Unused code path elimination
+ * Block '<S801>/Display12' : Unused code path elimination
+ * Block '<S801>/Display13' : Unused code path elimination
+ * Block '<S801>/Display2' : Unused code path elimination
+ * Block '<S801>/Display3' : Unused code path elimination
+ * Block '<S801>/Display4' : Unused code path elimination
+ * Block '<S801>/Display5' : Unused code path elimination
+ * Block '<S801>/Display6' : Unused code path elimination
+ * Block '<S801>/Display7' : Unused code path elimination
+ * Block '<S801>/Display8' : Unused code path elimination
+ * Block '<S801>/Display9' : Unused code path elimination
+ * Block '<S835>/Display' : Unused code path elimination
+ * Block '<S849>/Display' : Unused code path elimination
+ * Block '<S862>/Display' : Unused code path elimination
+ * Block '<S886>/Display' : Unused code path elimination
+ * Block '<S891>/Display' : Unused code path elimination
+ * Block '<S896>/Display' : Unused code path elimination
  * Block '<S901>/Display' : Unused code path elimination
- * Block '<S906>/Display' : Unused code path elimination
- * Block '<S911>/Display' : Unused code path elimination
  * Block '<S916>/Display' : Unused code path elimination
- * Block '<S932>/Display' : Unused code path elimination
- * Block '<S937>/Display' : Unused code path elimination
- * Block '<S942>/Display' : Unused code path elimination
+ * Block '<S921>/Display' : Unused code path elimination
+ * Block '<S926>/Display' : Unused code path elimination
+ * Block '<S931>/Display' : Unused code path elimination
  * Block '<S947>/Display' : Unused code path elimination
- * Block '<S963>/Display' : Unused code path elimination
- * Block '<S968>/Display' : Unused code path elimination
- * Block '<S973>/Display' : Unused code path elimination
+ * Block '<S952>/Display' : Unused code path elimination
+ * Block '<S957>/Display' : Unused code path elimination
+ * Block '<S962>/Display' : Unused code path elimination
  * Block '<S978>/Display' : Unused code path elimination
- * Block '<S721>/Display' : Unused code path elimination
- * Block '<S721>/Display1' : Unused code path elimination
- * Block '<S982>/Display' : Unused code path elimination
- * Block '<S987>/Display' : Unused code path elimination
- * Block '<S987>/Display1' : Unused code path elimination
- * Block '<S987>/Display2' : Unused code path elimination
- * Block '<S987>/Display3' : Unused code path elimination
- * Block '<S1053>/Display' : Unused code path elimination
- * Block '<S1065>/Display' : Unused code path elimination
- * Block '<S1077>/Display' : Unused code path elimination
- * Block '<S1088>/Display' : Unused code path elimination
- * Block '<S1109>/Display' : Unused code path elimination
- * Block '<S1114>/Display' : Unused code path elimination
- * Block '<S1119>/Display' : Unused code path elimination
- * Block '<S1132>/Display' : Unused code path elimination
- * Block '<S1137>/Display' : Unused code path elimination
- * Block '<S1142>/Display' : Unused code path elimination
+ * Block '<S983>/Display' : Unused code path elimination
+ * Block '<S988>/Display' : Unused code path elimination
+ * Block '<S993>/Display' : Unused code path elimination
+ * Block '<S1009>/Display' : Unused code path elimination
+ * Block '<S1014>/Display' : Unused code path elimination
+ * Block '<S1019>/Display' : Unused code path elimination
+ * Block '<S1024>/Display' : Unused code path elimination
+ * Block '<S767>/Display' : Unused code path elimination
+ * Block '<S767>/Display1' : Unused code path elimination
+ * Block '<S1028>/Display' : Unused code path elimination
+ * Block '<S1033>/Display' : Unused code path elimination
+ * Block '<S1033>/Display1' : Unused code path elimination
+ * Block '<S1033>/Display2' : Unused code path elimination
+ * Block '<S1033>/Display3' : Unused code path elimination
+ * Block '<S1099>/Display' : Unused code path elimination
+ * Block '<S1111>/Display' : Unused code path elimination
+ * Block '<S1123>/Display' : Unused code path elimination
+ * Block '<S1134>/Display' : Unused code path elimination
  * Block '<S1155>/Display' : Unused code path elimination
  * Block '<S1160>/Display' : Unused code path elimination
  * Block '<S1165>/Display' : Unused code path elimination
@@ -1086,61 +1088,75 @@ extern RT_MODEL *const rtM;
  * Block '<S1224>/Display' : Unused code path elimination
  * Block '<S1229>/Display' : Unused code path elimination
  * Block '<S1234>/Display' : Unused code path elimination
+ * Block '<S1247>/Display' : Unused code path elimination
+ * Block '<S1252>/Display' : Unused code path elimination
+ * Block '<S1257>/Display' : Unused code path elimination
+ * Block '<S1270>/Display' : Unused code path elimination
+ * Block '<S1275>/Display' : Unused code path elimination
+ * Block '<S1280>/Display' : Unused code path elimination
  * Block '<S42>/Data Type Conversion' : Eliminate redundant data type conversion
  * Block '<S66>/Data Type Conversion' : Eliminate redundant data type conversion
  * Block '<S151>/Data Type Conversion' : Eliminate redundant data type conversion
  * Block '<S175>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S531>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S532>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S598>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S599>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S665>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S666>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S688>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S688>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S688>/Data Type Conversion2' : Eliminate redundant data type conversion
- * Block '<S688>/Data Type Conversion6' : Eliminate redundant data type conversion
- * Block '<S689>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S689>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S689>/Data Type Conversion2' : Eliminate redundant data type conversion
- * Block '<S689>/Data Type Conversion6' : Eliminate redundant data type conversion
- * Block '<S690>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S690>/Data Type Conversion2' : Eliminate redundant data type conversion
- * Block '<S690>/Data Type Conversion3' : Eliminate redundant data type conversion
- * Block '<S691>/Data Type Conversion1' : Eliminate redundant data type conversion
- * Block '<S691>/Data Type Conversion2' : Eliminate redundant data type conversion
- * Block '<S691>/Data Type Conversion3' : Eliminate redundant data type conversion
- * Block '<S743>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S839>/Abs' : Eliminated since data is unsigned
- * Block '<S844>/Abs' : Eliminated since data is unsigned
- * Block '<S849>/Abs' : Eliminated since data is unsigned
- * Block '<S854>/Abs' : Eliminated since data is unsigned
- * Block '<S869>/Abs' : Eliminated since data is unsigned
- * Block '<S874>/Abs' : Eliminated since data is unsigned
- * Block '<S879>/Abs' : Eliminated since data is unsigned
- * Block '<S884>/Abs' : Eliminated since data is unsigned
+ * Block '<S551>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S552>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S619>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S620>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S686>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S687>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S710>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S710>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S710>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S710>/Data Type Conversion6' : Eliminate redundant data type conversion
+ * Block '<S711>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S711>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S711>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S711>/Data Type Conversion6' : Eliminate redundant data type conversion
+ * Block '<S712>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S712>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S712>/Data Type Conversion3' : Eliminate redundant data type conversion
+ * Block '<S713>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S713>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S713>/Data Type Conversion3' : Eliminate redundant data type conversion
+ * Block '<S737>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S737>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S737>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S737>/Data Type Conversion6' : Eliminate redundant data type conversion
+ * Block '<S738>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S738>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S738>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S738>/Data Type Conversion6' : Eliminate redundant data type conversion
+ * Block '<S739>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S739>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S739>/Data Type Conversion3' : Eliminate redundant data type conversion
+ * Block '<S740>/Data Type Conversion1' : Eliminate redundant data type conversion
+ * Block '<S740>/Data Type Conversion2' : Eliminate redundant data type conversion
+ * Block '<S740>/Data Type Conversion3' : Eliminate redundant data type conversion
+ * Block '<S789>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S885>/Abs' : Eliminated since data is unsigned
+ * Block '<S890>/Abs' : Eliminated since data is unsigned
+ * Block '<S895>/Abs' : Eliminated since data is unsigned
  * Block '<S900>/Abs' : Eliminated since data is unsigned
- * Block '<S905>/Abs' : Eliminated since data is unsigned
- * Block '<S910>/Abs' : Eliminated since data is unsigned
  * Block '<S915>/Abs' : Eliminated since data is unsigned
- * Block '<S931>/Abs' : Eliminated since data is unsigned
- * Block '<S936>/Abs' : Eliminated since data is unsigned
- * Block '<S941>/Abs' : Eliminated since data is unsigned
+ * Block '<S920>/Abs' : Eliminated since data is unsigned
+ * Block '<S925>/Abs' : Eliminated since data is unsigned
+ * Block '<S930>/Abs' : Eliminated since data is unsigned
  * Block '<S946>/Abs' : Eliminated since data is unsigned
- * Block '<S962>/Abs' : Eliminated since data is unsigned
- * Block '<S967>/Abs' : Eliminated since data is unsigned
- * Block '<S972>/Abs' : Eliminated since data is unsigned
+ * Block '<S951>/Abs' : Eliminated since data is unsigned
+ * Block '<S956>/Abs' : Eliminated since data is unsigned
+ * Block '<S961>/Abs' : Eliminated since data is unsigned
  * Block '<S977>/Abs' : Eliminated since data is unsigned
- * Block '<S1008>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S1009>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S1010>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S1011>/Data Type Conversion' : Eliminate redundant data type conversion
- * Block '<S1108>/Abs' : Eliminated since data is unsigned
- * Block '<S1113>/Abs' : Eliminated since data is unsigned
- * Block '<S1118>/Abs' : Eliminated since data is unsigned
- * Block '<S1131>/Abs' : Eliminated since data is unsigned
- * Block '<S1136>/Abs' : Eliminated since data is unsigned
- * Block '<S1141>/Abs' : Eliminated since data is unsigned
+ * Block '<S982>/Abs' : Eliminated since data is unsigned
+ * Block '<S987>/Abs' : Eliminated since data is unsigned
+ * Block '<S992>/Abs' : Eliminated since data is unsigned
+ * Block '<S1008>/Abs' : Eliminated since data is unsigned
+ * Block '<S1013>/Abs' : Eliminated since data is unsigned
+ * Block '<S1018>/Abs' : Eliminated since data is unsigned
+ * Block '<S1023>/Abs' : Eliminated since data is unsigned
+ * Block '<S1054>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S1055>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S1056>/Data Type Conversion' : Eliminate redundant data type conversion
+ * Block '<S1057>/Data Type Conversion' : Eliminate redundant data type conversion
  * Block '<S1154>/Abs' : Eliminated since data is unsigned
  * Block '<S1159>/Abs' : Eliminated since data is unsigned
  * Block '<S1164>/Abs' : Eliminated since data is unsigned
@@ -1153,6 +1169,12 @@ extern RT_MODEL *const rtM;
  * Block '<S1223>/Abs' : Eliminated since data is unsigned
  * Block '<S1228>/Abs' : Eliminated since data is unsigned
  * Block '<S1233>/Abs' : Eliminated since data is unsigned
+ * Block '<S1246>/Abs' : Eliminated since data is unsigned
+ * Block '<S1251>/Abs' : Eliminated since data is unsigned
+ * Block '<S1256>/Abs' : Eliminated since data is unsigned
+ * Block '<S1269>/Abs' : Eliminated since data is unsigned
+ * Block '<S1274>/Abs' : Eliminated since data is unsigned
+ * Block '<S1279>/Abs' : Eliminated since data is unsigned
  */
 
 /*-
@@ -1175,7 +1197,7 @@ extern RT_MODEL *const rtM;
  * '<S3>'   : 'HVAC_model/CAN INPUT'
  * '<S4>'   : 'HVAC_model/CAN OUTPUT'
  * '<S5>'   : 'HVAC_model/LIN'
- * '<S6>'   : 'HVAC_model/PWM and valves in manual'
+ * '<S6>'   : 'HVAC_model/PWM and valves in manual1'
  * '<S7>'   : 'HVAC_model/PWN'
  * '<S8>'   : 'HVAC_model/Start control'
  * '<S9>'   : 'HVAC_model/dbg CAN'
@@ -1652,764 +1674,811 @@ extern RT_MODEL *const rtM;
  * '<S480>' : 'HVAC_model/CAN INPUT/Subsystem3/Subsystem'
  * '<S481>' : 'HVAC_model/CAN INPUT/Subsystem5/Subsystem'
  * '<S482>' : 'HVAC_model/CAN INPUT/Subsystem6/Subsystem1'
- * '<S483>' : 'HVAC_model/LIN/CHANEL0'
- * '<S484>' : 'HVAC_model/LIN/CHANEL1'
- * '<S485>' : 'HVAC_model/LIN/CHANEL2'
- * '<S486>' : 'HVAC_model/LIN/CHANEL0/Actuator_Ch0_Command_Model'
- * '<S487>' : 'HVAC_model/LIN/CHANEL0/COM = 0'
- * '<S488>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max'
- * '<S489>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min'
- * '<S490>' : 'HVAC_model/LIN/CHANEL0/Homing'
- * '<S491>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max'
- * '<S492>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min'
- * '<S493>' : 'HVAC_model/LIN/CHANEL0/Move to position Max'
- * '<S494>' : 'HVAC_model/LIN/CHANEL0/Move to position Min'
- * '<S495>' : 'HVAC_model/LIN/CHANEL0/Normal Mode'
- * '<S496>' : 'HVAC_model/LIN/CHANEL0/Stop Mode'
- * '<S497>' : 'HVAC_model/LIN/CHANEL0/steps to percents'
- * '<S498>' : 'HVAC_model/LIN/CHANEL0/COM = 0/Compare To Constant'
- * '<S499>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max/If Action Subsystem2'
- * '<S500>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max/If Action Subsystem3'
- * '<S501>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max/If Action Subsystem2/Write'
- * '<S502>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min/If Action Subsystem2'
- * '<S503>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min/If Action Subsystem3'
- * '<S504>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min/If Action Subsystem2/Write'
- * '<S505>' : 'HVAC_model/LIN/CHANEL0/Homing/Count step actuator'
- * '<S506>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem'
- * '<S507>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1'
- * '<S508>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2'
- * '<S509>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3'
- * '<S510>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem4'
- * '<S511>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/Compare To Constant'
- * '<S512>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/Compare To Constant1'
- * '<S513>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/MAX POSITION'
- * '<S514>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/Subsystem'
- * '<S515>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/CAN ERROR'
- * '<S516>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/Compare To Constant'
- * '<S517>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/MAX POSITION'
- * '<S518>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/Subsystem'
- * '<S519>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/UDS ERROR'
- * '<S520>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/CAN ERROR/Write ERROR'
- * '<S521>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2/Compare To Constant3'
- * '<S522>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2/Compare To Constant4'
- * '<S523>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2/MAX POSITION'
- * '<S524>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem'
- * '<S525>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1'
- * '<S526>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/MAX POSITION'
- * '<S527>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem'
- * '<S528>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1'
- * '<S529>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/MATLAB Function'
- * '<S530>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/MAX POSITION'
- * '<S531>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR'
- * '<S532>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1/UDS ERROR'
- * '<S533>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR/Write ERROR'
- * '<S534>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem4/MAX POSITION'
- * '<S535>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max/If Action Subsystem2'
- * '<S536>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max/If Action Subsystem3'
- * '<S537>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max/If Action Subsystem2/Write'
- * '<S538>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min/If Action Subsystem'
- * '<S539>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min/If Action Subsystem3'
- * '<S540>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min/If Action Subsystem/Write'
- * '<S541>' : 'HVAC_model/LIN/CHANEL0/Move to position Max/If Action Subsystem2'
- * '<S542>' : 'HVAC_model/LIN/CHANEL0/Move to position Max/If Action Subsystem3'
- * '<S543>' : 'HVAC_model/LIN/CHANEL0/Move to position Max/If Action Subsystem2/Write'
- * '<S544>' : 'HVAC_model/LIN/CHANEL0/Move to position Min/If Action Subsystem2'
- * '<S545>' : 'HVAC_model/LIN/CHANEL0/Move to position Min/If Action Subsystem3'
- * '<S546>' : 'HVAC_model/LIN/CHANEL0/Move to position Min/If Action Subsystem2/Write'
- * '<S547>' : 'HVAC_model/LIN/CHANEL0/Normal Mode/If Action Subsystem2'
- * '<S548>' : 'HVAC_model/LIN/CHANEL0/Normal Mode/If Action Subsystem3'
- * '<S549>' : 'HVAC_model/LIN/CHANEL0/Normal Mode/If Action Subsystem2/Write'
- * '<S550>' : 'HVAC_model/LIN/CHANEL0/Stop Mode/If Action Subsystem2'
- * '<S551>' : 'HVAC_model/LIN/CHANEL0/Stop Mode/If Action Subsystem3'
- * '<S552>' : 'HVAC_model/LIN/CHANEL0/Stop Mode/If Action Subsystem2/Write'
- * '<S553>' : 'HVAC_model/LIN/CHANEL1/Actuator_Ch1_Command_Model'
- * '<S554>' : 'HVAC_model/LIN/CHANEL1/COM = 0'
- * '<S555>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max'
- * '<S556>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min'
- * '<S557>' : 'HVAC_model/LIN/CHANEL1/Homing'
- * '<S558>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max'
- * '<S559>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min'
- * '<S560>' : 'HVAC_model/LIN/CHANEL1/Move to position Max'
- * '<S561>' : 'HVAC_model/LIN/CHANEL1/Move to position Min'
- * '<S562>' : 'HVAC_model/LIN/CHANEL1/Normal Mode'
- * '<S563>' : 'HVAC_model/LIN/CHANEL1/Stop Mode'
- * '<S564>' : 'HVAC_model/LIN/CHANEL1/stepr to percents'
- * '<S565>' : 'HVAC_model/LIN/CHANEL1/COM = 0/Compare To Constant'
- * '<S566>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max/If Action Subsystem2'
- * '<S567>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max/If Action Subsystem3'
- * '<S568>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max/If Action Subsystem2/Write'
- * '<S569>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min/If Action Subsystem2'
- * '<S570>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min/If Action Subsystem3'
- * '<S571>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min/If Action Subsystem2/Write'
- * '<S572>' : 'HVAC_model/LIN/CHANEL1/Homing/Count step actuator'
- * '<S573>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem'
- * '<S574>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1'
- * '<S575>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2'
- * '<S576>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3'
- * '<S577>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem4'
- * '<S578>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/Compare To Constant'
- * '<S579>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/Compare To Constant1'
- * '<S580>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/MAX POSITION'
- * '<S581>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/Subsystem'
- * '<S582>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/CAN ERROR'
- * '<S583>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/Compare To Constant'
- * '<S584>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/MAX POSITION'
- * '<S585>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/Subsystem'
- * '<S586>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/UDS ERROR'
- * '<S587>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/CAN ERROR/Write ERROR'
- * '<S588>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2/Compare To Constant3'
- * '<S589>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2/Compare To Constant4'
- * '<S590>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2/MAX POSITION'
- * '<S591>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem'
- * '<S592>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1'
- * '<S593>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/MAX POSITION'
- * '<S594>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem'
- * '<S595>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1'
- * '<S596>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/MATLAB Function'
- * '<S597>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/MAX POSITION'
- * '<S598>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR'
- * '<S599>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1/UDS ERROR'
- * '<S600>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR/Write ERROR'
- * '<S601>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem4/MAX POSITION'
- * '<S602>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max/If Action Subsystem2'
- * '<S603>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max/If Action Subsystem3'
- * '<S604>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max/If Action Subsystem2/Write'
- * '<S605>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min/If Action Subsystem'
- * '<S606>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min/If Action Subsystem3'
- * '<S607>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min/If Action Subsystem/Write'
- * '<S608>' : 'HVAC_model/LIN/CHANEL1/Move to position Max/If Action Subsystem2'
- * '<S609>' : 'HVAC_model/LIN/CHANEL1/Move to position Max/If Action Subsystem3'
- * '<S610>' : 'HVAC_model/LIN/CHANEL1/Move to position Max/If Action Subsystem2/Write'
- * '<S611>' : 'HVAC_model/LIN/CHANEL1/Move to position Min/If Action Subsystem2'
- * '<S612>' : 'HVAC_model/LIN/CHANEL1/Move to position Min/If Action Subsystem3'
- * '<S613>' : 'HVAC_model/LIN/CHANEL1/Move to position Min/If Action Subsystem2/Write'
- * '<S614>' : 'HVAC_model/LIN/CHANEL1/Normal Mode/If Action Subsystem2'
- * '<S615>' : 'HVAC_model/LIN/CHANEL1/Normal Mode/If Action Subsystem3'
- * '<S616>' : 'HVAC_model/LIN/CHANEL1/Normal Mode/If Action Subsystem2/Write'
- * '<S617>' : 'HVAC_model/LIN/CHANEL1/Stop Mode/If Action Subsystem2'
- * '<S618>' : 'HVAC_model/LIN/CHANEL1/Stop Mode/If Action Subsystem3'
- * '<S619>' : 'HVAC_model/LIN/CHANEL1/Stop Mode/If Action Subsystem2/Write'
- * '<S620>' : 'HVAC_model/LIN/CHANEL2/Actuator_Ch1_Command_Model'
- * '<S621>' : 'HVAC_model/LIN/CHANEL2/COM = 0'
- * '<S622>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max'
- * '<S623>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min'
- * '<S624>' : 'HVAC_model/LIN/CHANEL2/Homing'
- * '<S625>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max'
- * '<S626>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min'
- * '<S627>' : 'HVAC_model/LIN/CHANEL2/Move to position Max'
- * '<S628>' : 'HVAC_model/LIN/CHANEL2/Move to position Min'
- * '<S629>' : 'HVAC_model/LIN/CHANEL2/Normal Mode'
- * '<S630>' : 'HVAC_model/LIN/CHANEL2/Stop Mode'
- * '<S631>' : 'HVAC_model/LIN/CHANEL2/stepr to percents'
- * '<S632>' : 'HVAC_model/LIN/CHANEL2/COM = 0/Compare To Constant'
- * '<S633>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max/If Action Subsystem2'
- * '<S634>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max/If Action Subsystem3'
- * '<S635>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max/If Action Subsystem2/Write'
- * '<S636>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min/If Action Subsystem2'
- * '<S637>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min/If Action Subsystem3'
- * '<S638>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min/If Action Subsystem2/Write'
- * '<S639>' : 'HVAC_model/LIN/CHANEL2/Homing/Count step actuator'
- * '<S640>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem'
- * '<S641>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1'
- * '<S642>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2'
- * '<S643>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3'
- * '<S644>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem4'
- * '<S645>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/Compare To Constant'
- * '<S646>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/Compare To Constant1'
- * '<S647>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/MAX POSITION'
- * '<S648>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/Subsystem'
- * '<S649>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/CAN ERROR'
- * '<S650>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/Compare To Constant'
- * '<S651>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/MAX POSITION'
- * '<S652>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/Subsystem'
- * '<S653>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/UDS ERROR'
- * '<S654>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/CAN ERROR/Write ERROR'
- * '<S655>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2/Compare To Constant3'
- * '<S656>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2/Compare To Constant4'
- * '<S657>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2/MAX POSITION'
- * '<S658>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem'
- * '<S659>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1'
- * '<S660>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/MAX POSITION'
- * '<S661>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem'
- * '<S662>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1'
- * '<S663>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/MATLAB Function'
- * '<S664>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/MAX POSITION'
- * '<S665>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR'
- * '<S666>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1/UDS ERROR'
- * '<S667>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR/Write ERROR'
- * '<S668>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem4/MAX POSITION'
- * '<S669>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max/If Action Subsystem2'
- * '<S670>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max/If Action Subsystem3'
- * '<S671>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max/If Action Subsystem2/Write'
- * '<S672>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min/If Action Subsystem'
- * '<S673>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min/If Action Subsystem3'
- * '<S674>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min/If Action Subsystem/Write'
- * '<S675>' : 'HVAC_model/LIN/CHANEL2/Move to position Max/If Action Subsystem2'
- * '<S676>' : 'HVAC_model/LIN/CHANEL2/Move to position Max/If Action Subsystem3'
- * '<S677>' : 'HVAC_model/LIN/CHANEL2/Move to position Max/If Action Subsystem2/Write'
- * '<S678>' : 'HVAC_model/LIN/CHANEL2/Move to position Min/If Action Subsystem2'
- * '<S679>' : 'HVAC_model/LIN/CHANEL2/Move to position Min/If Action Subsystem3'
- * '<S680>' : 'HVAC_model/LIN/CHANEL2/Move to position Min/If Action Subsystem2/Write'
- * '<S681>' : 'HVAC_model/LIN/CHANEL2/Normal Mode/If Action Subsystem2'
- * '<S682>' : 'HVAC_model/LIN/CHANEL2/Normal Mode/If Action Subsystem3'
- * '<S683>' : 'HVAC_model/LIN/CHANEL2/Normal Mode/If Action Subsystem2/Write'
- * '<S684>' : 'HVAC_model/LIN/CHANEL2/Stop Mode/If Action Subsystem2'
- * '<S685>' : 'HVAC_model/LIN/CHANEL2/Stop Mode/If Action Subsystem3'
- * '<S686>' : 'HVAC_model/LIN/CHANEL2/Stop Mode/If Action Subsystem2/Write'
- * '<S687>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode'
- * '<S688>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions'
- * '<S689>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions'
- * '<S690>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Left AF - manual directions'
- * '<S691>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Right AF - manual directions'
- * '<S692>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Write'
- * '<S693>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Write1'
- * '<S694>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Write2'
- * '<S695>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Bi Level'
- * '<S696>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Def'
- * '<S697>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Foor + Def'
- * '<S698>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Foot'
- * '<S699>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Hi_Level'
- * '<S700>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Tri-Level'
- * '<S701>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Left AF - manual directions/AF for Vent mode'
- * '<S702>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Bi Level'
- * '<S703>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Def'
- * '<S704>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Foor + Def'
- * '<S705>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Foot'
- * '<S706>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Hi_Level'
- * '<S707>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Tri-Level'
- * '<S708>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Front Right AF - manual directions/AF for Vent mode'
- * '<S709>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Left AF - manual directions/AF for Bi Level R'
- * '<S710>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Left AF - manual directions/AF for Foot R'
- * '<S711>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Left AF - manual directions/AF for Vent mode R'
- * '<S712>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Right AF - manual directions/AF for Bi Level R'
- * '<S713>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Right AF - manual directions/AF for Foot R'
- * '<S714>' : 'HVAC_model/PWM and valves in manual/PWM in manual mode/Rear Right AF - manual directions/AF for Vent mode R'
- * '<S715>' : 'HVAC_model/PWN/Write'
- * '<S716>' : 'HVAC_model/PWN/Write1'
- * '<S717>' : 'HVAC_model/PWN/Write2'
- * '<S718>' : 'HVAC_model/PWN/Write3'
- * '<S719>' : 'HVAC_model/Start control/If Action Subsystem'
- * '<S720>' : 'HVAC_model/Start control/Start Control Front'
- * '<S721>' : 'HVAC_model/Start control/Start Control Rear'
- * '<S722>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)'
- * '<S723>' : 'HVAC_model/Start control/Start Control Front/Step 0 F'
- * '<S724>' : 'HVAC_model/Start control/Start Control Front/Step 1 F'
- * '<S725>' : 'HVAC_model/Start control/Start Control Front/Step 2 F'
- * '<S726>' : 'HVAC_model/Start control/Start Control Front/Step 3 F'
- * '<S727>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 0'
- * '<S728>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 1'
- * '<S729>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 2'
- * '<S730>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 3'
- * '<S731>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 4'
- * '<S732>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 5'
- * '<S733>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 0/g_assSTART_ENTER_INCAR'
- * '<S734>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 0/g_ausSTART_ENTER_SETTEMP'
- * '<S735>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 1/g_assSTART_ENTER_INCAR'
- * '<S736>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 1/g_ausSTART_ENTER_SETTEMP'
- * '<S737>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 3/g_assSTART_ENTER_COOLANT '
- * '<S738>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 4/g_assSTART_ENTER_COOLANT '
- * '<S739>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 5/g_assSTART_ENTER_COOLANT '
- * '<S740>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 0'
- * '<S741>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 1'
- * '<S742>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 2'
- * '<S743>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3'
- * '<S744>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4'
- * '<S745>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5'
- * '<S746>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S747>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3/incar filter down'
- * '<S748>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3/incar filter up'
- * '<S749>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S750>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4/incar filter down'
- * '<S751>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4/incar filter up'
- * '<S752>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S753>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5/incar filter down'
- * '<S754>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5/incar filter up'
- * '<S755>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0'
- * '<S756>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1'
- * '<S757>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 2'
- * '<S758>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3'
- * '<S759>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4'
- * '<S760>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5'
- * '<S761>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/3 way valve status'
- * '<S762>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Dtg_FrontLower_X'
- * '<S763>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Dtg_FrontUpper_X'
- * '<S764>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Incar temp goto from step 1 to step 2 '
- * '<S765>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/RealTime_Timer'
- * '<S766>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Time goto from step 1 to step 2 '
- * '<S767>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/blower FR'
- * '<S768>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/incar filter down'
- * '<S769>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/incar filter up'
- * '<S770>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/mode FR step 1'
- * '<S771>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/window heating'
- * '<S772>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/3 way valve status'
- * '<S773>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Dtg_FrontLower_X'
- * '<S774>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Dtg_FrontUpper_X'
- * '<S775>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Incar temp goto from step 1 to step 2 '
- * '<S776>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/RealTime_Timer'
- * '<S777>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Time goto from step 1 to step 2 '
- * '<S778>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/blower FR'
- * '<S779>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/incar filter down'
- * '<S780>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/incar filter up'
- * '<S781>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/mode FR step 1'
- * '<S782>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/window heating'
- * '<S783>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/3 way valve status'
- * '<S784>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Dtg_FrontLower_X'
- * '<S785>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Dtg_FrontUpper_X'
- * '<S786>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Incar temp goto from step 1 to step 2 '
- * '<S787>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/RealTime_Timer'
- * '<S788>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Time goto from step 1 to step 2 '
- * '<S789>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/blower в зависимости от ECT'
- * '<S790>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/g_assSTART_COOLANT_TO_STEP2 '
- * '<S791>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/incar filter down'
- * '<S792>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/incar filter up'
- * '<S793>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/mode FR step 1'
- * '<S794>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/window heating'
- * '<S795>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/blower в зависимости от ECT/ECT min max'
- * '<S796>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/blower в зависимости от ECT/blower min max'
- * '<S797>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/3 way valve status'
- * '<S798>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Dtg_FrontLower_X'
- * '<S799>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Dtg_FrontUpper_X'
- * '<S800>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Incar temp goto from step 1 to step 2 '
- * '<S801>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/RealTime_Timer'
- * '<S802>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Time goto from step 1 to step 2 '
- * '<S803>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/blower в зависимости от ECT'
- * '<S804>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/incar filter down'
- * '<S805>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/incar filter up'
- * '<S806>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/mode FR step 1'
- * '<S807>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/window heating'
- * '<S808>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/blower в зависимости от ECT/ECT min max'
- * '<S809>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/blower в зависимости от ECT/blower min max'
- * '<S810>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/3 way valve status'
- * '<S811>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Dtg_FrontLower_X'
- * '<S812>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Dtg_FrontUpper_X'
- * '<S813>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Incar temp goto from step 1 to step 2 '
- * '<S814>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/RealTime_Timer'
- * '<S815>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Time goto from step 1 to step 2 '
- * '<S816>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/blower в зависимости от ECT'
- * '<S817>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/incar filter down'
- * '<S818>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/incar filter up'
- * '<S819>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/mode FR step 1'
- * '<S820>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/window heating'
- * '<S821>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/blower в зависимости от ECT/ECT min max'
- * '<S822>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/blower в зависимости от ECT/blower min max'
- * '<S823>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0'
- * '<S824>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1'
- * '<S825>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 2'
- * '<S826>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3'
- * '<S827>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4'
- * '<S828>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5'
- * '<S829>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/3 way valve status'
- * '<S830>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO'
- * '<S831>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO'
- * '<S832>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/RealTime_Timer'
- * '<S833>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/Time goto from step 2 to step 3 '
- * '<S834>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO'
- * '<S835>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/incar filter down'
- * '<S836>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/incar filter up'
- * '<S837>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO'
- * '<S838>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/window heating'
- * '<S839>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/Almost equal'
- * '<S840>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/Calculate delta time'
- * '<S841>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/step'
- * '<S842>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/time for step'
- * '<S843>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S844>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/Almost equal'
- * '<S845>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/Calculate delta time'
- * '<S846>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/step'
- * '<S847>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/time for step'
- * '<S848>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S849>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/Almost equal'
- * '<S850>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/Calculate delta time'
- * '<S851>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/blower step'
- * '<S852>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/blower time for step'
- * '<S853>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S854>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/Almost equal'
- * '<S855>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/Calculate delta time'
- * '<S856>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/step'
- * '<S857>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/time for step'
- * '<S858>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S859>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/3 way valve status'
- * '<S860>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO'
- * '<S861>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO'
- * '<S862>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/RealTime_Timer'
- * '<S863>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/Time goto from step 2 to step 3 '
- * '<S864>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO'
- * '<S865>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/incar filter down'
- * '<S866>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/incar filter up'
- * '<S867>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO'
- * '<S868>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/window heating'
- * '<S869>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/Almost equal'
- * '<S870>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/Calculate delta time'
- * '<S871>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/step'
- * '<S872>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/time for step'
- * '<S873>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S874>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/Almost equal'
- * '<S875>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/Calculate delta time'
- * '<S876>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/step'
- * '<S877>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/time for step'
- * '<S878>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S879>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/Almost equal'
- * '<S880>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/Calculate delta time'
- * '<S881>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/blower step'
- * '<S882>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/blower time for step'
- * '<S883>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S884>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/Almost equal'
- * '<S885>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/Calculate delta time'
- * '<S886>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/step'
- * '<S887>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/time for step'
- * '<S888>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S889>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/3 way valve status'
- * '<S890>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO'
- * '<S891>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO'
- * '<S892>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/RealTime_Timer'
- * '<S893>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/Time goto from step 2 to step 3 '
- * '<S894>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/autodemist (autodefog)'
- * '<S895>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO'
- * '<S896>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/incar filter down'
- * '<S897>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/incar filter up'
- * '<S898>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO'
- * '<S899>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/window heating'
- * '<S900>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/Almost equal'
- * '<S901>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/Calculate delta time'
- * '<S902>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/step'
- * '<S903>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/time for step'
- * '<S904>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S905>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/Almost equal'
- * '<S906>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/Calculate delta time'
- * '<S907>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/step'
- * '<S908>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/time for step'
- * '<S909>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S910>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/Almost equal'
- * '<S911>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/Calculate delta time'
- * '<S912>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/blower step'
- * '<S913>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/blower time for step'
- * '<S914>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S915>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/Almost equal'
- * '<S916>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/Calculate delta time'
- * '<S917>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/step'
- * '<S918>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/time for step'
- * '<S919>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S920>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/3 way valve status'
- * '<S921>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO'
- * '<S922>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO'
- * '<S923>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/RealTime_Timer'
- * '<S924>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/Time goto from step 2 to step 3 '
- * '<S925>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/autodemist (autodefog)'
- * '<S926>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO'
- * '<S927>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/incar filter down'
- * '<S928>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/incar filter up'
- * '<S929>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO'
- * '<S930>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/window heating'
- * '<S931>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/Almost equal'
- * '<S932>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/Calculate delta time'
- * '<S933>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/step'
- * '<S934>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/time for step'
- * '<S935>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S936>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/Almost equal'
- * '<S937>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/Calculate delta time'
- * '<S938>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/step'
- * '<S939>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/time for step'
- * '<S940>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S941>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/Almost equal'
- * '<S942>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/Calculate delta time'
- * '<S943>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/blower step'
- * '<S944>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/blower time for step'
- * '<S945>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S946>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/Almost equal'
- * '<S947>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/Calculate delta time'
- * '<S948>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/step'
- * '<S949>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/time for step'
- * '<S950>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S951>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/3 way valve status'
- * '<S952>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO'
- * '<S953>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO'
- * '<S954>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/RealTime_Timer'
- * '<S955>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/Time goto from step 2 to step 3 '
- * '<S956>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/autodemist (autodefog)'
- * '<S957>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO'
- * '<S958>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/incar filter down'
- * '<S959>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/incar filter up'
- * '<S960>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO'
- * '<S961>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/window heating'
- * '<S962>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/Almost equal'
- * '<S963>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/Calculate delta time'
- * '<S964>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/step'
- * '<S965>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/time for step'
- * '<S966>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S967>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/Almost equal'
- * '<S968>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/Calculate delta time'
- * '<S969>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/step'
- * '<S970>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/time for step'
- * '<S971>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S972>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/Almost equal'
- * '<S973>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/Calculate delta time'
- * '<S974>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/blower step'
- * '<S975>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/blower time for step'
- * '<S976>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S977>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/Almost equal'
- * '<S978>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/Calculate delta time'
- * '<S979>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/step'
- * '<S980>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/time for step'
- * '<S981>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S982>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)'
- * '<S983>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R'
- * '<S984>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R'
- * '<S985>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R'
- * '<S986>' : 'HVAC_model/Start control/Start Control Rear/Step 3 R'
- * '<S987>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 0'
- * '<S988>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 1'
- * '<S989>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 2'
- * '<S990>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3'
- * '<S991>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 4'
- * '<S992>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 5'
- * '<S993>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 0/g_assSTART_ENTER_INCAR'
- * '<S994>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 0/g_ausSTART_ENTER_SETTEMP'
- * '<S995>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 1/g_assSTART_ENTER_INCAR'
- * '<S996>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 1/g_ausSTART_ENTER_SETTEMP'
- * '<S997>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 2/g_assSTART_ENTER_INCAR'
- * '<S998>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 2/g_ausSTART_ENTER_SETTEMP'
- * '<S999>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3/g_assSTART_ENTER_COOLANT '
- * '<S1000>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3/g_assSTART_ENTER_INCAR'
- * '<S1001>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3/g_ausSTART_ENTER_SETTEMP'
- * '<S1002>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 4/g_assSTART_ENTER_COOLANT '
- * '<S1003>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 4/g_assSTART_ENTER_INCAR'
- * '<S1004>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 5/g_assSTART_ENTER_COOLANT '
- * '<S1005>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 5/g_assSTART_ENTER_INCAR'
- * '<S1006>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 0'
- * '<S1007>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 1'
- * '<S1008>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2'
- * '<S1009>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3'
- * '<S1010>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4'
- * '<S1011>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5'
- * '<S1012>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S1013>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2/incar filter down'
- * '<S1014>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2/incar filter up'
- * '<S1015>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S1016>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3/incar filter down'
- * '<S1017>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3/incar filter up'
- * '<S1018>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S1019>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4/incar filter down'
- * '<S1020>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4/incar filter up'
- * '<S1021>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5/g_assSTART_COOLANT_STEP0_TO_1 '
- * '<S1022>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5/incar filter down'
- * '<S1023>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5/incar filter up'
- * '<S1024>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0'
- * '<S1025>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1'
- * '<S1026>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2'
- * '<S1027>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3'
- * '<S1028>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4'
- * '<S1029>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5'
- * '<S1030>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/2 way valve'
- * '<S1031>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/Dtg_rear'
- * '<S1032>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/Incar temp goto from step 1 to step 2 '
- * '<S1033>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/RealTime_Timer'
- * '<S1034>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/Time goto from step 1 to step 2 '
- * '<S1035>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/blower rear'
- * '<S1036>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/incar filter down'
- * '<S1037>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/incar filter up'
- * '<S1038>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/mode rear step 1'
- * '<S1039>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/2 way valve'
- * '<S1040>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/Dtg_rear'
- * '<S1041>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/Incar temp goto from step 1 to step 2 '
- * '<S1042>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/RealTime_Timer'
- * '<S1043>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/Time goto from step 1 to step 2 '
- * '<S1044>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/blower rear'
- * '<S1045>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/incar filter down'
- * '<S1046>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/incar filter up'
- * '<S1047>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/mode rear step 1'
- * '<S1048>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/2 way valve'
- * '<S1049>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/Dtg_rear'
- * '<S1050>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/Incar temp goto from step 1 to step 2 '
- * '<S1051>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/RealTime_Timer'
- * '<S1052>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/Time goto from step 1 to step 2 '
- * '<S1053>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/blower в зависимости от ECT'
- * '<S1054>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/g_assSTART_COOLANT_TO_STEP2 '
- * '<S1055>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/incar filter down'
- * '<S1056>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/incar filter up'
- * '<S1057>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/mode rear step 1'
- * '<S1058>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/blower в зависимости от ECT/ECT min max'
- * '<S1059>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/blower в зависимости от ECT/blower start finish'
- * '<S1060>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/2 way valve'
- * '<S1061>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/Dtg_rear'
- * '<S1062>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/Incar temp goto from step 1 to step 2 '
- * '<S1063>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/RealTime_Timer'
- * '<S1064>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/Time goto from step 1 to step 2 '
- * '<S1065>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/blower в зависимости от ECT'
- * '<S1066>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/g_assSTART_COOLANT_TO_STEP2 '
- * '<S1067>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/incar filter down'
- * '<S1068>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/incar filter up'
- * '<S1069>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/mode rear step 1'
- * '<S1070>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/blower в зависимости от ECT/ECT min max'
- * '<S1071>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/blower в зависимости от ECT/blower start finish'
- * '<S1072>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/2 way valve'
- * '<S1073>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/Dtg_rear'
- * '<S1074>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/Incar temp goto from step 1 to step 2 '
- * '<S1075>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/RealTime_Timer'
- * '<S1076>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/Time goto from step 1 to step 2 '
- * '<S1077>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/blower в зависимости от ECT'
- * '<S1078>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/incar filter down'
- * '<S1079>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/incar filter up'
- * '<S1080>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/mode rear step 1'
- * '<S1081>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/blower в зависимости от ECT/ECT min max'
- * '<S1082>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/blower в зависимости от ECT/blower start finish'
- * '<S1083>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/2 way valve'
- * '<S1084>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/Dtg_rear'
- * '<S1085>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/Incar temp goto from step 1 to step 2 '
- * '<S1086>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/RealTime_Timer'
- * '<S1087>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/Time goto from step 1 to step 2 '
- * '<S1088>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/blower в зависимости от ECT'
- * '<S1089>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/incar filter down'
- * '<S1090>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/incar filter up'
- * '<S1091>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/mode rear step 1'
- * '<S1092>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/blower в зависимости от ECT/ECT min max'
- * '<S1093>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/blower в зависимости от ECT/blower start finish'
- * '<S1094>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0'
- * '<S1095>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1'
- * '<S1096>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2'
- * '<S1097>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3'
- * '<S1098>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4'
- * '<S1099>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5'
- * '<S1100>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/2 way valve'
- * '<S1101>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO'
- * '<S1102>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/RealTime_Timer'
- * '<S1103>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/Time goto from step 1 to step 2 '
- * '<S1104>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO'
- * '<S1105>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/incar filter down'
- * '<S1106>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/incar filter up'
- * '<S1107>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO'
- * '<S1108>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/Almost equal'
- * '<S1109>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/Calculate delta time'
- * '<S1110>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/step'
- * '<S1111>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/time for step'
- * '<S1112>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1113>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/Almost equal'
- * '<S1114>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/Calculate delta time'
- * '<S1115>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/blower step'
- * '<S1116>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/blower time for step'
- * '<S1117>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1118>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/Almost equal'
- * '<S1119>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/Calculate delta time'
- * '<S1120>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/step'
- * '<S1121>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/time for step'
- * '<S1122>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1123>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/2 way valve'
- * '<S1124>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO'
- * '<S1125>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/RealTime_Timer'
- * '<S1126>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/Time goto from step 1 to step 2 '
- * '<S1127>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO'
- * '<S1128>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/incar filter down'
- * '<S1129>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/incar filter up'
- * '<S1130>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO'
- * '<S1131>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/Almost equal'
- * '<S1132>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/Calculate delta time'
- * '<S1133>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/step'
- * '<S1134>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/time for step'
- * '<S1135>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1136>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/Almost equal'
- * '<S1137>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/Calculate delta time'
- * '<S1138>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/blower step'
- * '<S1139>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/blower time for step'
- * '<S1140>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1141>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/Almost equal'
- * '<S1142>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/Calculate delta time'
- * '<S1143>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/step'
- * '<S1144>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/time for step'
- * '<S1145>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1146>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/2 way valve'
- * '<S1147>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO'
- * '<S1148>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/RealTime_Timer'
- * '<S1149>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/Time goto from step 1 to step 2 '
- * '<S1150>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO'
- * '<S1151>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/incar filter down'
- * '<S1152>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/incar filter up'
- * '<S1153>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO'
- * '<S1154>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/Almost equal'
- * '<S1155>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/Calculate delta time'
- * '<S1156>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/step'
- * '<S1157>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/time for step'
- * '<S1158>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1159>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/Almost equal'
- * '<S1160>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/Calculate delta time'
- * '<S1161>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/blower step'
- * '<S1162>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/blower time for step'
- * '<S1163>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1164>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/Almost equal'
- * '<S1165>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/Calculate delta time'
- * '<S1166>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/step'
- * '<S1167>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/time for step'
- * '<S1168>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1169>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/2 way valve'
- * '<S1170>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO'
- * '<S1171>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/RealTime_Timer'
- * '<S1172>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/Time goto from step 1 to step 2 '
- * '<S1173>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO'
- * '<S1174>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/incar filter down'
- * '<S1175>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/incar filter up'
- * '<S1176>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO'
- * '<S1177>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/Almost equal'
- * '<S1178>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/Calculate delta time'
- * '<S1179>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/step'
- * '<S1180>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/time for step'
- * '<S1181>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1182>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/Almost equal'
- * '<S1183>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/Calculate delta time'
- * '<S1184>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/blower step'
- * '<S1185>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/blower time for step'
- * '<S1186>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1187>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/Almost equal'
- * '<S1188>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/Calculate delta time'
- * '<S1189>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/step'
- * '<S1190>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/time for step'
- * '<S1191>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1192>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/2 way valve'
- * '<S1193>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO'
- * '<S1194>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/RealTime_Timer'
- * '<S1195>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/Time goto from step 1 to step 2 '
- * '<S1196>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO'
- * '<S1197>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/incar filter down'
- * '<S1198>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/incar filter up'
- * '<S1199>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO'
- * '<S1200>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/Almost equal'
- * '<S1201>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/Calculate delta time'
- * '<S1202>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/step'
- * '<S1203>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/time for step'
- * '<S1204>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1205>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/Almost equal'
- * '<S1206>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/Calculate delta time'
- * '<S1207>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/blower step'
- * '<S1208>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/blower time for step'
- * '<S1209>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1210>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/Almost equal'
- * '<S1211>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/Calculate delta time'
- * '<S1212>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/step'
- * '<S1213>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/time for step'
- * '<S1214>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1215>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/2 way valve'
- * '<S1216>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO'
- * '<S1217>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/RealTime_Timer'
- * '<S1218>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/Time goto from step 1 to step 2 '
- * '<S1219>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO'
- * '<S1220>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/incar filter down'
- * '<S1221>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/incar filter up'
- * '<S1222>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO'
- * '<S1223>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/Almost equal'
- * '<S1224>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/Calculate delta time'
- * '<S1225>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/step'
- * '<S1226>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/time for step'
- * '<S1227>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1228>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/Almost equal'
- * '<S1229>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/Calculate delta time'
- * '<S1230>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/blower step'
- * '<S1231>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/blower time for step'
- * '<S1232>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1233>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/Almost equal'
- * '<S1234>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/Calculate delta time'
- * '<S1235>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/step'
- * '<S1236>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/time for step'
- * '<S1237>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/знак для изменения (+//-)'
- * '<S1238>' : 'HVAC_model/dbg CAN/ACP (duct sensors) to dbg'
- * '<S1239>' : 'HVAC_model/dbg CAN/actuators to dbg'
- * '<S1240>' : 'HVAC_model/dbg CAN/sen_eva (evaporator) to dbg'
+ * '<S483>' : 'HVAC_model/CAN OUTPUT/Subsystem'
+ * '<S484>' : 'HVAC_model/CAN OUTPUT/Subsystem1'
+ * '<S485>' : 'HVAC_model/CAN OUTPUT/Subsystem10'
+ * '<S486>' : 'HVAC_model/CAN OUTPUT/Subsystem11'
+ * '<S487>' : 'HVAC_model/CAN OUTPUT/Subsystem12'
+ * '<S488>' : 'HVAC_model/CAN OUTPUT/Subsystem13'
+ * '<S489>' : 'HVAC_model/CAN OUTPUT/Subsystem14'
+ * '<S490>' : 'HVAC_model/CAN OUTPUT/Subsystem15'
+ * '<S491>' : 'HVAC_model/CAN OUTPUT/Subsystem16'
+ * '<S492>' : 'HVAC_model/CAN OUTPUT/Subsystem17'
+ * '<S493>' : 'HVAC_model/CAN OUTPUT/Subsystem2'
+ * '<S494>' : 'HVAC_model/CAN OUTPUT/Subsystem3'
+ * '<S495>' : 'HVAC_model/CAN OUTPUT/Subsystem4'
+ * '<S496>' : 'HVAC_model/CAN OUTPUT/Subsystem5'
+ * '<S497>' : 'HVAC_model/CAN OUTPUT/Subsystem6'
+ * '<S498>' : 'HVAC_model/CAN OUTPUT/Subsystem7'
+ * '<S499>' : 'HVAC_model/CAN OUTPUT/Subsystem8'
+ * '<S500>' : 'HVAC_model/CAN OUTPUT/Subsystem9'
+ * '<S501>' : 'HVAC_model/LIN/CHANEL0'
+ * '<S502>' : 'HVAC_model/LIN/CHANEL1'
+ * '<S503>' : 'HVAC_model/LIN/CHANEL2'
+ * '<S504>' : 'HVAC_model/LIN/CHANEL0/Actuator_Ch0_Command_Model'
+ * '<S505>' : 'HVAC_model/LIN/CHANEL0/COM = 0'
+ * '<S506>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max'
+ * '<S507>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min'
+ * '<S508>' : 'HVAC_model/LIN/CHANEL0/Homing'
+ * '<S509>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max'
+ * '<S510>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min'
+ * '<S511>' : 'HVAC_model/LIN/CHANEL0/Move to position Max'
+ * '<S512>' : 'HVAC_model/LIN/CHANEL0/Move to position Min'
+ * '<S513>' : 'HVAC_model/LIN/CHANEL0/Normal Mode'
+ * '<S514>' : 'HVAC_model/LIN/CHANEL0/Stop Mode'
+ * '<S515>' : 'HVAC_model/LIN/CHANEL0/steps to percents'
+ * '<S516>' : 'HVAC_model/LIN/CHANEL0/COM = 0/Compare To Constant'
+ * '<S517>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max/If Action Subsystem2'
+ * '<S518>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max/If Action Subsystem3'
+ * '<S519>' : 'HVAC_model/LIN/CHANEL0/Check Stall Max/If Action Subsystem2/Write'
+ * '<S520>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min/If Action Subsystem2'
+ * '<S521>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min/If Action Subsystem3'
+ * '<S522>' : 'HVAC_model/LIN/CHANEL0/Check Stall Min/If Action Subsystem2/Write'
+ * '<S523>' : 'HVAC_model/LIN/CHANEL0/Homing/Count step actuator'
+ * '<S524>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem'
+ * '<S525>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1'
+ * '<S526>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2'
+ * '<S527>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3'
+ * '<S528>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem4'
+ * '<S529>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/Compare To Constant'
+ * '<S530>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/Compare To Constant1'
+ * '<S531>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/MAX POSITION'
+ * '<S532>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem/Subsystem'
+ * '<S533>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/CAN ERROR'
+ * '<S534>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/Compare To Constant'
+ * '<S535>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/MAX POSITION'
+ * '<S536>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/Subsystem'
+ * '<S537>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/UDS ERROR'
+ * '<S538>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem1/CAN ERROR/Write ERROR'
+ * '<S539>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2/Compare To Constant3'
+ * '<S540>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2/Compare To Constant4'
+ * '<S541>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem2/MAX POSITION'
+ * '<S542>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem'
+ * '<S543>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1'
+ * '<S544>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/MAX POSITION'
+ * '<S545>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem'
+ * '<S546>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1'
+ * '<S547>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/MATLAB Function'
+ * '<S548>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/MAX POSITION'
+ * '<S549>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1/Send position'
+ * '<S550>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1/Send position/percents to steps'
+ * '<S551>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR'
+ * '<S552>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1/UDS ERROR'
+ * '<S553>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR/Write ERROR'
+ * '<S554>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem4/Send position'
+ * '<S555>' : 'HVAC_model/LIN/CHANEL0/Homing/Switch Case Action Subsystem4/Send position/percents to steps'
+ * '<S556>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max/If Action Subsystem2'
+ * '<S557>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max/If Action Subsystem3'
+ * '<S558>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Max/If Action Subsystem2/Write'
+ * '<S559>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min/If Action Subsystem'
+ * '<S560>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min/If Action Subsystem3'
+ * '<S561>' : 'HVAC_model/LIN/CHANEL0/Initial CPOS Min/If Action Subsystem/Write'
+ * '<S562>' : 'HVAC_model/LIN/CHANEL0/Move to position Max/If Action Subsystem2'
+ * '<S563>' : 'HVAC_model/LIN/CHANEL0/Move to position Max/If Action Subsystem3'
+ * '<S564>' : 'HVAC_model/LIN/CHANEL0/Move to position Max/If Action Subsystem2/Write'
+ * '<S565>' : 'HVAC_model/LIN/CHANEL0/Move to position Min/If Action Subsystem2'
+ * '<S566>' : 'HVAC_model/LIN/CHANEL0/Move to position Min/If Action Subsystem3'
+ * '<S567>' : 'HVAC_model/LIN/CHANEL0/Move to position Min/If Action Subsystem2/Write'
+ * '<S568>' : 'HVAC_model/LIN/CHANEL0/Normal Mode/If Action Subsystem2'
+ * '<S569>' : 'HVAC_model/LIN/CHANEL0/Normal Mode/If Action Subsystem3'
+ * '<S570>' : 'HVAC_model/LIN/CHANEL0/Normal Mode/If Action Subsystem2/Write'
+ * '<S571>' : 'HVAC_model/LIN/CHANEL0/Stop Mode/If Action Subsystem2'
+ * '<S572>' : 'HVAC_model/LIN/CHANEL0/Stop Mode/If Action Subsystem3'
+ * '<S573>' : 'HVAC_model/LIN/CHANEL0/Stop Mode/If Action Subsystem2/Write'
+ * '<S574>' : 'HVAC_model/LIN/CHANEL1/Actuator_Ch1_Command_Model'
+ * '<S575>' : 'HVAC_model/LIN/CHANEL1/COM = 0'
+ * '<S576>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max'
+ * '<S577>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min'
+ * '<S578>' : 'HVAC_model/LIN/CHANEL1/Homing'
+ * '<S579>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max'
+ * '<S580>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min'
+ * '<S581>' : 'HVAC_model/LIN/CHANEL1/Move to position Max'
+ * '<S582>' : 'HVAC_model/LIN/CHANEL1/Move to position Min'
+ * '<S583>' : 'HVAC_model/LIN/CHANEL1/Normal Mode'
+ * '<S584>' : 'HVAC_model/LIN/CHANEL1/Stop Mode'
+ * '<S585>' : 'HVAC_model/LIN/CHANEL1/stepr to percents'
+ * '<S586>' : 'HVAC_model/LIN/CHANEL1/COM = 0/Compare To Constant'
+ * '<S587>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max/If Action Subsystem2'
+ * '<S588>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max/If Action Subsystem3'
+ * '<S589>' : 'HVAC_model/LIN/CHANEL1/Check Stall Max/If Action Subsystem2/Write'
+ * '<S590>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min/If Action Subsystem2'
+ * '<S591>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min/If Action Subsystem3'
+ * '<S592>' : 'HVAC_model/LIN/CHANEL1/Check Stall Min/If Action Subsystem2/Write'
+ * '<S593>' : 'HVAC_model/LIN/CHANEL1/Homing/Count step actuator'
+ * '<S594>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem'
+ * '<S595>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1'
+ * '<S596>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2'
+ * '<S597>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3'
+ * '<S598>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem4'
+ * '<S599>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/Compare To Constant'
+ * '<S600>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/Compare To Constant1'
+ * '<S601>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/MAX POSITION'
+ * '<S602>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem/Subsystem'
+ * '<S603>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/CAN ERROR'
+ * '<S604>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/Compare To Constant'
+ * '<S605>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/MAX POSITION'
+ * '<S606>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/Subsystem'
+ * '<S607>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/UDS ERROR'
+ * '<S608>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem1/CAN ERROR/Write ERROR'
+ * '<S609>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2/Compare To Constant3'
+ * '<S610>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2/Compare To Constant4'
+ * '<S611>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem2/MAX POSITION'
+ * '<S612>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem'
+ * '<S613>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1'
+ * '<S614>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/MAX POSITION'
+ * '<S615>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem'
+ * '<S616>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1'
+ * '<S617>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/MATLAB Function'
+ * '<S618>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem/MAX POSITION'
+ * '<S619>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR'
+ * '<S620>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1/UDS ERROR'
+ * '<S621>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR/Write ERROR'
+ * '<S622>' : 'HVAC_model/LIN/CHANEL1/Homing/Switch Case Action Subsystem4/MAX POSITION'
+ * '<S623>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max/If Action Subsystem2'
+ * '<S624>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max/If Action Subsystem3'
+ * '<S625>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Max/If Action Subsystem2/Write'
+ * '<S626>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min/If Action Subsystem'
+ * '<S627>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min/If Action Subsystem3'
+ * '<S628>' : 'HVAC_model/LIN/CHANEL1/Initial CPOS Min/If Action Subsystem/Write'
+ * '<S629>' : 'HVAC_model/LIN/CHANEL1/Move to position Max/If Action Subsystem2'
+ * '<S630>' : 'HVAC_model/LIN/CHANEL1/Move to position Max/If Action Subsystem3'
+ * '<S631>' : 'HVAC_model/LIN/CHANEL1/Move to position Max/If Action Subsystem2/Write'
+ * '<S632>' : 'HVAC_model/LIN/CHANEL1/Move to position Min/If Action Subsystem2'
+ * '<S633>' : 'HVAC_model/LIN/CHANEL1/Move to position Min/If Action Subsystem3'
+ * '<S634>' : 'HVAC_model/LIN/CHANEL1/Move to position Min/If Action Subsystem2/Write'
+ * '<S635>' : 'HVAC_model/LIN/CHANEL1/Normal Mode/If Action Subsystem2'
+ * '<S636>' : 'HVAC_model/LIN/CHANEL1/Normal Mode/If Action Subsystem3'
+ * '<S637>' : 'HVAC_model/LIN/CHANEL1/Normal Mode/If Action Subsystem2/Write'
+ * '<S638>' : 'HVAC_model/LIN/CHANEL1/Stop Mode/If Action Subsystem2'
+ * '<S639>' : 'HVAC_model/LIN/CHANEL1/Stop Mode/If Action Subsystem3'
+ * '<S640>' : 'HVAC_model/LIN/CHANEL1/Stop Mode/If Action Subsystem2/Write'
+ * '<S641>' : 'HVAC_model/LIN/CHANEL2/Actuator_Ch1_Command_Model'
+ * '<S642>' : 'HVAC_model/LIN/CHANEL2/COM = 0'
+ * '<S643>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max'
+ * '<S644>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min'
+ * '<S645>' : 'HVAC_model/LIN/CHANEL2/Homing'
+ * '<S646>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max'
+ * '<S647>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min'
+ * '<S648>' : 'HVAC_model/LIN/CHANEL2/Move to position Max'
+ * '<S649>' : 'HVAC_model/LIN/CHANEL2/Move to position Min'
+ * '<S650>' : 'HVAC_model/LIN/CHANEL2/Normal Mode'
+ * '<S651>' : 'HVAC_model/LIN/CHANEL2/Stop Mode'
+ * '<S652>' : 'HVAC_model/LIN/CHANEL2/stepr to percents'
+ * '<S653>' : 'HVAC_model/LIN/CHANEL2/COM = 0/Compare To Constant'
+ * '<S654>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max/If Action Subsystem2'
+ * '<S655>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max/If Action Subsystem3'
+ * '<S656>' : 'HVAC_model/LIN/CHANEL2/Check Stall Max/If Action Subsystem2/Write'
+ * '<S657>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min/If Action Subsystem2'
+ * '<S658>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min/If Action Subsystem3'
+ * '<S659>' : 'HVAC_model/LIN/CHANEL2/Check Stall Min/If Action Subsystem2/Write'
+ * '<S660>' : 'HVAC_model/LIN/CHANEL2/Homing/Count step actuator'
+ * '<S661>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem'
+ * '<S662>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1'
+ * '<S663>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2'
+ * '<S664>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3'
+ * '<S665>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem4'
+ * '<S666>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/Compare To Constant'
+ * '<S667>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/Compare To Constant1'
+ * '<S668>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/MAX POSITION'
+ * '<S669>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem/Subsystem'
+ * '<S670>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/CAN ERROR'
+ * '<S671>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/Compare To Constant'
+ * '<S672>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/MAX POSITION'
+ * '<S673>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/Subsystem'
+ * '<S674>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/UDS ERROR'
+ * '<S675>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem1/CAN ERROR/Write ERROR'
+ * '<S676>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2/Compare To Constant3'
+ * '<S677>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2/Compare To Constant4'
+ * '<S678>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem2/MAX POSITION'
+ * '<S679>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem'
+ * '<S680>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1'
+ * '<S681>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/MAX POSITION'
+ * '<S682>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem'
+ * '<S683>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/If Action Subsystem1'
+ * '<S684>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/MATLAB Function'
+ * '<S685>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem/MAX POSITION'
+ * '<S686>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR'
+ * '<S687>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1/UDS ERROR'
+ * '<S688>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem3/If Action Subsystem1/CAN ERROR/Write ERROR'
+ * '<S689>' : 'HVAC_model/LIN/CHANEL2/Homing/Switch Case Action Subsystem4/MAX POSITION'
+ * '<S690>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max/If Action Subsystem2'
+ * '<S691>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max/If Action Subsystem3'
+ * '<S692>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Max/If Action Subsystem2/Write'
+ * '<S693>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min/If Action Subsystem'
+ * '<S694>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min/If Action Subsystem3'
+ * '<S695>' : 'HVAC_model/LIN/CHANEL2/Initial CPOS Min/If Action Subsystem/Write'
+ * '<S696>' : 'HVAC_model/LIN/CHANEL2/Move to position Max/If Action Subsystem2'
+ * '<S697>' : 'HVAC_model/LIN/CHANEL2/Move to position Max/If Action Subsystem3'
+ * '<S698>' : 'HVAC_model/LIN/CHANEL2/Move to position Max/If Action Subsystem2/Write'
+ * '<S699>' : 'HVAC_model/LIN/CHANEL2/Move to position Min/If Action Subsystem2'
+ * '<S700>' : 'HVAC_model/LIN/CHANEL2/Move to position Min/If Action Subsystem3'
+ * '<S701>' : 'HVAC_model/LIN/CHANEL2/Move to position Min/If Action Subsystem2/Write'
+ * '<S702>' : 'HVAC_model/LIN/CHANEL2/Normal Mode/If Action Subsystem2'
+ * '<S703>' : 'HVAC_model/LIN/CHANEL2/Normal Mode/If Action Subsystem3'
+ * '<S704>' : 'HVAC_model/LIN/CHANEL2/Normal Mode/If Action Subsystem2/Write'
+ * '<S705>' : 'HVAC_model/LIN/CHANEL2/Stop Mode/If Action Subsystem2'
+ * '<S706>' : 'HVAC_model/LIN/CHANEL2/Stop Mode/If Action Subsystem3'
+ * '<S707>' : 'HVAC_model/LIN/CHANEL2/Stop Mode/If Action Subsystem2/Write'
+ * '<S708>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode'
+ * '<S709>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode '
+ * '<S710>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions'
+ * '<S711>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions'
+ * '<S712>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Left AF - manual directions'
+ * '<S713>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Right AF - manual directions'
+ * '<S714>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Write'
+ * '<S715>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Write1'
+ * '<S716>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Write2'
+ * '<S717>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Bi Level'
+ * '<S718>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Def'
+ * '<S719>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Foor + Def'
+ * '<S720>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Foot'
+ * '<S721>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Hi_Level'
+ * '<S722>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Tri-Level'
+ * '<S723>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Left AF - manual directions/AF for Vent mode'
+ * '<S724>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Bi Level'
+ * '<S725>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Def'
+ * '<S726>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Foor + Def'
+ * '<S727>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Foot'
+ * '<S728>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Hi_Level'
+ * '<S729>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Tri-Level'
+ * '<S730>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Front Right AF - manual directions/AF for Vent mode'
+ * '<S731>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Left AF - manual directions/AF for Bi Level R'
+ * '<S732>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Left AF - manual directions/AF for Foot R'
+ * '<S733>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Left AF - manual directions/AF for Vent mode R'
+ * '<S734>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Right AF - manual directions/AF for Bi Level R'
+ * '<S735>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Right AF - manual directions/AF for Foot R'
+ * '<S736>' : 'HVAC_model/PWM and valves in manual1/PWM in manual mode/Rear Right AF - manual directions/AF for Vent mode R'
+ * '<S737>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions'
+ * '<S738>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions'
+ * '<S739>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Left AF - manual directions'
+ * '<S740>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Right AF - manual directions'
+ * '<S741>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Bi Level'
+ * '<S742>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Def'
+ * '<S743>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Foot'
+ * '<S744>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Foot + Def'
+ * '<S745>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Hi_Level'
+ * '<S746>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Tri-Level'
+ * '<S747>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Left Valves - manual directions/Valves for Vent mode'
+ * '<S748>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Bi Level'
+ * '<S749>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Def'
+ * '<S750>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Foot'
+ * '<S751>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Foot + Def'
+ * '<S752>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Hi_Level'
+ * '<S753>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Tri-Level'
+ * '<S754>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Front Right Valves - manual directions/Valves for Vent mode'
+ * '<S755>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Left AF - manual directions/AF for Bi Level'
+ * '<S756>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Left AF - manual directions/AF for Foot'
+ * '<S757>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Left AF - manual directions/valves for Vent mode'
+ * '<S758>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Right AF - manual directions/AF for Bi Level'
+ * '<S759>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Right AF - manual directions/AF for Foot'
+ * '<S760>' : 'HVAC_model/PWM and valves in manual1/valves in manual mode /Rear Right AF - manual directions/valves for Vent mode'
+ * '<S761>' : 'HVAC_model/PWN/Write'
+ * '<S762>' : 'HVAC_model/PWN/Write1'
+ * '<S763>' : 'HVAC_model/PWN/Write2'
+ * '<S764>' : 'HVAC_model/PWN/Write3'
+ * '<S765>' : 'HVAC_model/Start control/If Action Subsystem'
+ * '<S766>' : 'HVAC_model/Start control/Start Control Front'
+ * '<S767>' : 'HVAC_model/Start control/Start Control Rear'
+ * '<S768>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)'
+ * '<S769>' : 'HVAC_model/Start control/Start Control Front/Step 0 F'
+ * '<S770>' : 'HVAC_model/Start control/Start Control Front/Step 1 F'
+ * '<S771>' : 'HVAC_model/Start control/Start Control Front/Step 2 F'
+ * '<S772>' : 'HVAC_model/Start control/Start Control Front/Step 3 F'
+ * '<S773>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 0'
+ * '<S774>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 1'
+ * '<S775>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 2'
+ * '<S776>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 3'
+ * '<S777>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 4'
+ * '<S778>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 5'
+ * '<S779>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 0/g_assSTART_ENTER_INCAR'
+ * '<S780>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 0/g_ausSTART_ENTER_SETTEMP'
+ * '<S781>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 1/g_assSTART_ENTER_INCAR'
+ * '<S782>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 1/g_ausSTART_ENTER_SETTEMP'
+ * '<S783>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 3/g_assSTART_ENTER_COOLANT '
+ * '<S784>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 4/g_assSTART_ENTER_COOLANT '
+ * '<S785>' : 'HVAC_model/Start control/Start Control Front/Step -1 F (Entry Condition)/Level 5/g_assSTART_ENTER_COOLANT '
+ * '<S786>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 0'
+ * '<S787>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 1'
+ * '<S788>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 2'
+ * '<S789>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3'
+ * '<S790>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4'
+ * '<S791>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5'
+ * '<S792>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S793>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3/incar filter down'
+ * '<S794>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 3/incar filter up'
+ * '<S795>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S796>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4/incar filter down'
+ * '<S797>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 4/incar filter up'
+ * '<S798>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S799>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5/incar filter down'
+ * '<S800>' : 'HVAC_model/Start control/Start Control Front/Step 0 F/Level 5/incar filter up'
+ * '<S801>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0'
+ * '<S802>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1'
+ * '<S803>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 2'
+ * '<S804>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3'
+ * '<S805>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4'
+ * '<S806>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5'
+ * '<S807>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/3 way valve status'
+ * '<S808>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Dtg_FrontLower_X'
+ * '<S809>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Dtg_FrontUpper_X'
+ * '<S810>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Incar temp goto from step 1 to step 2 '
+ * '<S811>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/RealTime_Timer'
+ * '<S812>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/Time goto from step 1 to step 2 '
+ * '<S813>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/blower FR'
+ * '<S814>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/incar filter down'
+ * '<S815>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/incar filter up'
+ * '<S816>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/mode FR step 1'
+ * '<S817>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 0/window heating'
+ * '<S818>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/3 way valve status'
+ * '<S819>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Dtg_FrontLower_X'
+ * '<S820>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Dtg_FrontUpper_X'
+ * '<S821>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Incar temp goto from step 1 to step 2 '
+ * '<S822>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/RealTime_Timer'
+ * '<S823>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/Time goto from step 1 to step 2 '
+ * '<S824>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/blower FR'
+ * '<S825>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/incar filter down'
+ * '<S826>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/incar filter up'
+ * '<S827>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/mode FR step 1'
+ * '<S828>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 1/window heating'
+ * '<S829>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/3 way valve status'
+ * '<S830>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Dtg_FrontLower_X'
+ * '<S831>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Dtg_FrontUpper_X'
+ * '<S832>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Incar temp goto from step 1 to step 2 '
+ * '<S833>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/RealTime_Timer'
+ * '<S834>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/Time goto from step 1 to step 2 '
+ * '<S835>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/blower в зависимости от ECT'
+ * '<S836>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/g_assSTART_COOLANT_TO_STEP2 '
+ * '<S837>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/incar filter down'
+ * '<S838>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/incar filter up'
+ * '<S839>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/mode FR step 1'
+ * '<S840>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/window heating'
+ * '<S841>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/blower в зависимости от ECT/ECT min max'
+ * '<S842>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 3/blower в зависимости от ECT/blower min max'
+ * '<S843>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/3 way valve status'
+ * '<S844>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Dtg_FrontLower_X'
+ * '<S845>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Dtg_FrontUpper_X'
+ * '<S846>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Incar temp goto from step 1 to step 2 '
+ * '<S847>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/RealTime_Timer'
+ * '<S848>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/Time goto from step 1 to step 2 '
+ * '<S849>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/blower в зависимости от ECT'
+ * '<S850>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/incar filter down'
+ * '<S851>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/incar filter up'
+ * '<S852>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/mode FR step 1'
+ * '<S853>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/window heating'
+ * '<S854>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/blower в зависимости от ECT/ECT min max'
+ * '<S855>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 4/blower в зависимости от ECT/blower min max'
+ * '<S856>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/3 way valve status'
+ * '<S857>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Dtg_FrontLower_X'
+ * '<S858>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Dtg_FrontUpper_X'
+ * '<S859>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Incar temp goto from step 1 to step 2 '
+ * '<S860>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/RealTime_Timer'
+ * '<S861>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/Time goto from step 1 to step 2 '
+ * '<S862>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/blower в зависимости от ECT'
+ * '<S863>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/incar filter down'
+ * '<S864>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/incar filter up'
+ * '<S865>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/mode FR step 1'
+ * '<S866>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/window heating'
+ * '<S867>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/blower в зависимости от ECT/ECT min max'
+ * '<S868>' : 'HVAC_model/Start control/Start Control Front/Step 1 F/Level 5/blower в зависимости от ECT/blower min max'
+ * '<S869>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0'
+ * '<S870>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1'
+ * '<S871>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 2'
+ * '<S872>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3'
+ * '<S873>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4'
+ * '<S874>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5'
+ * '<S875>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/3 way valve status'
+ * '<S876>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO'
+ * '<S877>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO'
+ * '<S878>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/RealTime_Timer'
+ * '<S879>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/Time goto from step 2 to step 3 '
+ * '<S880>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO'
+ * '<S881>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/incar filter down'
+ * '<S882>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/incar filter up'
+ * '<S883>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO'
+ * '<S884>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/window heating'
+ * '<S885>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/Almost equal'
+ * '<S886>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/Calculate delta time'
+ * '<S887>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/step'
+ * '<S888>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/time for step'
+ * '<S889>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S890>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/Almost equal'
+ * '<S891>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/Calculate delta time'
+ * '<S892>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/step'
+ * '<S893>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/time for step'
+ * '<S894>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S895>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/Almost equal'
+ * '<S896>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S897>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/blower step'
+ * '<S898>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/blower time for step'
+ * '<S899>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S900>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/Almost equal'
+ * '<S901>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S902>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/step'
+ * '<S903>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/time for step'
+ * '<S904>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 0/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S905>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/3 way valve status'
+ * '<S906>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO'
+ * '<S907>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO'
+ * '<S908>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/RealTime_Timer'
+ * '<S909>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/Time goto from step 2 to step 3 '
+ * '<S910>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO'
+ * '<S911>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/incar filter down'
+ * '<S912>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/incar filter up'
+ * '<S913>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO'
+ * '<S914>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/window heating'
+ * '<S915>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/Almost equal'
+ * '<S916>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/Calculate delta time'
+ * '<S917>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/step'
+ * '<S918>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/time for step'
+ * '<S919>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S920>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/Almost equal'
+ * '<S921>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/Calculate delta time'
+ * '<S922>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/step'
+ * '<S923>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/time for step'
+ * '<S924>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S925>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/Almost equal'
+ * '<S926>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S927>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/blower step'
+ * '<S928>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/blower time for step'
+ * '<S929>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S930>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/Almost equal'
+ * '<S931>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S932>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/step'
+ * '<S933>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/time for step'
+ * '<S934>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 1/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S935>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/3 way valve status'
+ * '<S936>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO'
+ * '<S937>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO'
+ * '<S938>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/RealTime_Timer'
+ * '<S939>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/Time goto from step 2 to step 3 '
+ * '<S940>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/autodemist (autodefog)'
+ * '<S941>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO'
+ * '<S942>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/incar filter down'
+ * '<S943>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/incar filter up'
+ * '<S944>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO'
+ * '<S945>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/window heating'
+ * '<S946>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/Almost equal'
+ * '<S947>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/Calculate delta time'
+ * '<S948>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/step'
+ * '<S949>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/time for step'
+ * '<S950>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S951>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/Almost equal'
+ * '<S952>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/Calculate delta time'
+ * '<S953>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/step'
+ * '<S954>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/time for step'
+ * '<S955>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S956>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/Almost equal'
+ * '<S957>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S958>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/blower step'
+ * '<S959>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/blower time for step'
+ * '<S960>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S961>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/Almost equal'
+ * '<S962>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S963>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/step'
+ * '<S964>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/time for step'
+ * '<S965>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 3/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S966>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/3 way valve status'
+ * '<S967>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO'
+ * '<S968>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO'
+ * '<S969>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/RealTime_Timer'
+ * '<S970>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/Time goto from step 2 to step 3 '
+ * '<S971>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/autodemist (autodefog)'
+ * '<S972>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO'
+ * '<S973>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/incar filter down'
+ * '<S974>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/incar filter up'
+ * '<S975>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO'
+ * '<S976>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/window heating'
+ * '<S977>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/Almost equal'
+ * '<S978>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/Calculate delta time'
+ * '<S979>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/step'
+ * '<S980>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/time for step'
+ * '<S981>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S982>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/Almost equal'
+ * '<S983>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/Calculate delta time'
+ * '<S984>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/step'
+ * '<S985>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/time for step'
+ * '<S986>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S987>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/Almost equal'
+ * '<S988>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S989>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/blower step'
+ * '<S990>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/blower time for step'
+ * '<S991>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S992>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/Almost equal'
+ * '<S993>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S994>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/step'
+ * '<S995>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/time for step'
+ * '<S996>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 4/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S997>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/3 way valve status'
+ * '<S998>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO'
+ * '<S999>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO'
+ * '<S1000>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/RealTime_Timer'
+ * '<S1001>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/Time goto from step 2 to step 3 '
+ * '<S1002>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/autodemist (autodefog)'
+ * '<S1003>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO'
+ * '<S1004>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/incar filter down'
+ * '<S1005>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/incar filter up'
+ * '<S1006>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO'
+ * '<S1007>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/window heating'
+ * '<S1008>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/Almost equal'
+ * '<S1009>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/Calculate delta time'
+ * '<S1010>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/step'
+ * '<S1011>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/time for step'
+ * '<S1012>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Lower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1013>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/Almost equal'
+ * '<S1014>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/Calculate delta time'
+ * '<S1015>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/step'
+ * '<S1016>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/time for step'
+ * '<S1017>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/DTG F Upper, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1018>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/Almost equal'
+ * '<S1019>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1020>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/blower step'
+ * '<S1021>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/blower time for step'
+ * '<S1022>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1023>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/Almost equal'
+ * '<S1024>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1025>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/step'
+ * '<S1026>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/time for step'
+ * '<S1027>' : 'HVAC_model/Start control/Start Control Front/Step 2 F/Level 5/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1028>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)'
+ * '<S1029>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R'
+ * '<S1030>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R'
+ * '<S1031>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R'
+ * '<S1032>' : 'HVAC_model/Start control/Start Control Rear/Step 3 R'
+ * '<S1033>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 0'
+ * '<S1034>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 1'
+ * '<S1035>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 2'
+ * '<S1036>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3'
+ * '<S1037>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 4'
+ * '<S1038>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 5'
+ * '<S1039>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 0/g_assSTART_ENTER_INCAR'
+ * '<S1040>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 0/g_ausSTART_ENTER_SETTEMP'
+ * '<S1041>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 1/g_assSTART_ENTER_INCAR'
+ * '<S1042>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 1/g_ausSTART_ENTER_SETTEMP'
+ * '<S1043>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 2/g_assSTART_ENTER_INCAR'
+ * '<S1044>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 2/g_ausSTART_ENTER_SETTEMP'
+ * '<S1045>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3/g_assSTART_ENTER_COOLANT '
+ * '<S1046>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3/g_assSTART_ENTER_INCAR'
+ * '<S1047>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 3/g_ausSTART_ENTER_SETTEMP'
+ * '<S1048>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 4/g_assSTART_ENTER_COOLANT '
+ * '<S1049>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 4/g_assSTART_ENTER_INCAR'
+ * '<S1050>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 5/g_assSTART_ENTER_COOLANT '
+ * '<S1051>' : 'HVAC_model/Start control/Start Control Rear/Step -1 R (Entry Condition)/Level 5/g_assSTART_ENTER_INCAR'
+ * '<S1052>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 0'
+ * '<S1053>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 1'
+ * '<S1054>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2'
+ * '<S1055>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3'
+ * '<S1056>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4'
+ * '<S1057>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5'
+ * '<S1058>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S1059>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2/incar filter down'
+ * '<S1060>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 2/incar filter up'
+ * '<S1061>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S1062>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3/incar filter down'
+ * '<S1063>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 3/incar filter up'
+ * '<S1064>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S1065>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4/incar filter down'
+ * '<S1066>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 4/incar filter up'
+ * '<S1067>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5/g_assSTART_COOLANT_STEP0_TO_1 '
+ * '<S1068>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5/incar filter down'
+ * '<S1069>' : 'HVAC_model/Start control/Start Control Rear/Step 0 R/Level 5/incar filter up'
+ * '<S1070>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0'
+ * '<S1071>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1'
+ * '<S1072>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2'
+ * '<S1073>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3'
+ * '<S1074>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4'
+ * '<S1075>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5'
+ * '<S1076>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/2 way valve'
+ * '<S1077>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/Dtg_rear'
+ * '<S1078>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/Incar temp goto from step 1 to step 2 '
+ * '<S1079>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/RealTime_Timer'
+ * '<S1080>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/Time goto from step 1 to step 2 '
+ * '<S1081>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/blower rear'
+ * '<S1082>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/incar filter down'
+ * '<S1083>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/incar filter up'
+ * '<S1084>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 0/mode rear step 1'
+ * '<S1085>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/2 way valve'
+ * '<S1086>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/Dtg_rear'
+ * '<S1087>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/Incar temp goto from step 1 to step 2 '
+ * '<S1088>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/RealTime_Timer'
+ * '<S1089>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/Time goto from step 1 to step 2 '
+ * '<S1090>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/blower rear'
+ * '<S1091>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/incar filter down'
+ * '<S1092>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/incar filter up'
+ * '<S1093>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 1/mode rear step 1'
+ * '<S1094>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/2 way valve'
+ * '<S1095>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/Dtg_rear'
+ * '<S1096>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/Incar temp goto from step 1 to step 2 '
+ * '<S1097>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/RealTime_Timer'
+ * '<S1098>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/Time goto from step 1 to step 2 '
+ * '<S1099>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/blower в зависимости от ECT'
+ * '<S1100>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/g_assSTART_COOLANT_TO_STEP2 '
+ * '<S1101>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/incar filter down'
+ * '<S1102>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/incar filter up'
+ * '<S1103>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/mode rear step 1'
+ * '<S1104>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/blower в зависимости от ECT/ECT min max'
+ * '<S1105>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 2/blower в зависимости от ECT/blower start finish'
+ * '<S1106>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/2 way valve'
+ * '<S1107>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/Dtg_rear'
+ * '<S1108>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/Incar temp goto from step 1 to step 2 '
+ * '<S1109>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/RealTime_Timer'
+ * '<S1110>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/Time goto from step 1 to step 2 '
+ * '<S1111>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/blower в зависимости от ECT'
+ * '<S1112>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/g_assSTART_COOLANT_TO_STEP2 '
+ * '<S1113>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/incar filter down'
+ * '<S1114>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/incar filter up'
+ * '<S1115>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/mode rear step 1'
+ * '<S1116>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/blower в зависимости от ECT/ECT min max'
+ * '<S1117>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 3/blower в зависимости от ECT/blower start finish'
+ * '<S1118>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/2 way valve'
+ * '<S1119>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/Dtg_rear'
+ * '<S1120>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/Incar temp goto from step 1 to step 2 '
+ * '<S1121>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/RealTime_Timer'
+ * '<S1122>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/Time goto from step 1 to step 2 '
+ * '<S1123>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/blower в зависимости от ECT'
+ * '<S1124>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/incar filter down'
+ * '<S1125>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/incar filter up'
+ * '<S1126>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/mode rear step 1'
+ * '<S1127>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/blower в зависимости от ECT/ECT min max'
+ * '<S1128>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 4/blower в зависимости от ECT/blower start finish'
+ * '<S1129>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/2 way valve'
+ * '<S1130>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/Dtg_rear'
+ * '<S1131>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/Incar temp goto from step 1 to step 2 '
+ * '<S1132>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/RealTime_Timer'
+ * '<S1133>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/Time goto from step 1 to step 2 '
+ * '<S1134>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/blower в зависимости от ECT'
+ * '<S1135>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/incar filter down'
+ * '<S1136>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/incar filter up'
+ * '<S1137>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/mode rear step 1'
+ * '<S1138>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/blower в зависимости от ECT/ECT min max'
+ * '<S1139>' : 'HVAC_model/Start control/Start Control Rear/Step 1 R/Level 5/blower в зависимости от ECT/blower start finish'
+ * '<S1140>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0'
+ * '<S1141>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1'
+ * '<S1142>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2'
+ * '<S1143>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3'
+ * '<S1144>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4'
+ * '<S1145>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5'
+ * '<S1146>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/2 way valve'
+ * '<S1147>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO'
+ * '<S1148>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/RealTime_Timer'
+ * '<S1149>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/Time goto from step 1 to step 2 '
+ * '<S1150>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO'
+ * '<S1151>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/incar filter down'
+ * '<S1152>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/incar filter up'
+ * '<S1153>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO'
+ * '<S1154>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/Almost equal'
+ * '<S1155>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/Calculate delta time'
+ * '<S1156>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/step'
+ * '<S1157>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/time for step'
+ * '<S1158>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1159>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/Almost equal'
+ * '<S1160>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1161>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/blower step'
+ * '<S1162>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/blower time for step'
+ * '<S1163>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1164>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/Almost equal'
+ * '<S1165>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1166>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/step'
+ * '<S1167>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/time for step'
+ * '<S1168>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 0/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1169>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/2 way valve'
+ * '<S1170>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO'
+ * '<S1171>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/RealTime_Timer'
+ * '<S1172>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/Time goto from step 1 to step 2 '
+ * '<S1173>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO'
+ * '<S1174>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/incar filter down'
+ * '<S1175>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/incar filter up'
+ * '<S1176>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO'
+ * '<S1177>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/Almost equal'
+ * '<S1178>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/Calculate delta time'
+ * '<S1179>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/step'
+ * '<S1180>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/time for step'
+ * '<S1181>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1182>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/Almost equal'
+ * '<S1183>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1184>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/blower step'
+ * '<S1185>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/blower time for step'
+ * '<S1186>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1187>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/Almost equal'
+ * '<S1188>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1189>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/step'
+ * '<S1190>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/time for step'
+ * '<S1191>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 1/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1192>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/2 way valve'
+ * '<S1193>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO'
+ * '<S1194>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/RealTime_Timer'
+ * '<S1195>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/Time goto from step 1 to step 2 '
+ * '<S1196>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO'
+ * '<S1197>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/incar filter down'
+ * '<S1198>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/incar filter up'
+ * '<S1199>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO'
+ * '<S1200>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/Almost equal'
+ * '<S1201>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/Calculate delta time'
+ * '<S1202>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/step'
+ * '<S1203>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/time for step'
+ * '<S1204>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1205>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/Almost equal'
+ * '<S1206>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1207>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/blower step'
+ * '<S1208>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/blower time for step'
+ * '<S1209>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1210>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/Almost equal'
+ * '<S1211>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1212>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/step'
+ * '<S1213>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/time for step'
+ * '<S1214>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 2/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1215>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/2 way valve'
+ * '<S1216>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO'
+ * '<S1217>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/RealTime_Timer'
+ * '<S1218>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/Time goto from step 1 to step 2 '
+ * '<S1219>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO'
+ * '<S1220>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/incar filter down'
+ * '<S1221>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/incar filter up'
+ * '<S1222>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO'
+ * '<S1223>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/Almost equal'
+ * '<S1224>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/Calculate delta time'
+ * '<S1225>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/step'
+ * '<S1226>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/time for step'
+ * '<S1227>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1228>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/Almost equal'
+ * '<S1229>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1230>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/blower step'
+ * '<S1231>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/blower time for step'
+ * '<S1232>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1233>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/Almost equal'
+ * '<S1234>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1235>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/step'
+ * '<S1236>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/time for step'
+ * '<S1237>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 3/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1238>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/2 way valve'
+ * '<S1239>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO'
+ * '<S1240>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/RealTime_Timer'
+ * '<S1241>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/Time goto from step 1 to step 2 '
+ * '<S1242>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO'
+ * '<S1243>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/incar filter down'
+ * '<S1244>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/incar filter up'
+ * '<S1245>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO'
+ * '<S1246>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/Almost equal'
+ * '<S1247>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/Calculate delta time'
+ * '<S1248>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/step'
+ * '<S1249>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/time for step'
+ * '<S1250>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1251>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/Almost equal'
+ * '<S1252>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1253>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/blower step'
+ * '<S1254>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/blower time for step'
+ * '<S1255>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1256>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/Almost equal'
+ * '<S1257>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1258>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/step'
+ * '<S1259>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/time for step'
+ * '<S1260>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 4/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1261>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/2 way valve'
+ * '<S1262>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO'
+ * '<S1263>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/RealTime_Timer'
+ * '<S1264>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/Time goto from step 1 to step 2 '
+ * '<S1265>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO'
+ * '<S1266>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/incar filter down'
+ * '<S1267>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/incar filter up'
+ * '<S1268>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO'
+ * '<S1269>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/Almost equal'
+ * '<S1270>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/Calculate delta time'
+ * '<S1271>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/step'
+ * '<S1272>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/time for step'
+ * '<S1273>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/DTG Rear, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1274>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/Almost equal'
+ * '<S1275>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/Calculate delta time'
+ * '<S1276>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/blower step'
+ * '<S1277>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/blower time for step'
+ * '<S1278>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/blower, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1279>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/Almost equal'
+ * '<S1280>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/Calculate delta time'
+ * '<S1281>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/step'
+ * '<S1282>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/time for step'
+ * '<S1283>' : 'HVAC_model/Start control/Start Control Rear/Step 2 R/Level 5/mode, стремящийся к AUTO/знак для изменения (+//-)'
+ * '<S1284>' : 'HVAC_model/dbg CAN/ACP (duct sensors) to dbg'
+ * '<S1285>' : 'HVAC_model/dbg CAN/actuators to dbg'
+ * '<S1286>' : 'HVAC_model/dbg CAN/blower to dbg'
+ * '<S1287>' : 'HVAC_model/dbg CAN/sen_eva (evaporator) to dbg'
  */
 #endif                                 /* HVAC_model_h_ */
 
diff --git a/HVAC_model_data.c b/HVAC_model_data.c
index f36b47b..cf90938 100644
--- a/HVAC_model_data.c
+++ b/HVAC_model_data.c
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.866
+ * Model version                  : 1.876
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Tue May  5 14:20:39 2026
+ * C/C++ source code generated on : Wed May  6 14:55:30 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -19,27 +19,27 @@
 
 /* Invariant block signals (default storage) */
 const ConstB rtConstB = {
-  /* Start of '<S643>/If Action Subsystem1' */
+  /* Start of '<S664>/If Action Subsystem1' */
   {
-    { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }/* '<S659>/Data Type Conversion' */
+    { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }/* '<S680>/Data Type Conversion' */
   }
   ,
 
-  /* End of '<S643>/If Action Subsystem1' */
+  /* End of '<S664>/If Action Subsystem1' */
 
-  /* Start of '<S576>/If Action Subsystem1' */
+  /* Start of '<S597>/If Action Subsystem1' */
   {
-    { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }/* '<S592>/Data Type Conversion' */
+    { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }/* '<S613>/Data Type Conversion' */
   }
   ,
 
-  /* End of '<S576>/If Action Subsystem1' */
+  /* End of '<S597>/If Action Subsystem1' */
 
-  /* Start of '<S509>/If Action Subsystem1' */
+  /* Start of '<S527>/If Action Subsystem1' */
   {
-    { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }/* '<S525>/Data Type Conversion' */
+    { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }/* '<S543>/Data Type Conversion' */
   }
-  /* End of '<S509>/If Action Subsystem1' */
+  /* End of '<S527>/If Action Subsystem1' */
 };
 
 /* Constant parameters (default storage) */
@@ -757,32 +757,35 @@ const ConstP rtConstP = {
     4080U, 4084U, 4088U, 4092U },
 
   /* Computed Parameter: ACT1_Value
-   * Referenced by: '<S505>/ACT1'
+   * Referenced by: '<S523>/ACT1'
    */
-  { 1050U, 1250U, 1195U, 1315U, 1300U, 1485U, 1440U, 1195U, 1175U },
+  { 1050U, 1250U, 1175U, 1195U, 1315U, 1300U, 1485U, 1440U, 1195U },
 
   /* Computed Parameter: ACT1_Value_d
-   * Referenced by: '<S572>/ACT1'
+   * Referenced by: '<S593>/ACT1'
    */
-  { 1225U, 1320U, 1270U, 1485U, 1480U, 1175U },
+  { 1225U, 1320U, 1270U, 1540U, 1480U, 1175U },
 
   /* Computed Parameter: ACT1_Value_o
-   * Referenced by: '<S639>/ACT1'
+   * Referenced by: '<S660>/ACT1'
    */
-  { 3075U, 3075U, 1605U, 1840U, 1650U, 1635U, 1820U, 1605U },
+  { 3075U, 3075U, 1605U, 1840U, 1650U, 1635U, 1820U, 1650U },
 
-  /* Computed Parameter: Constant3_Value
-   * Referenced by: '<S487>/Constant3'
+  /* Pooled Parameter (Expression: [1 2 3 4 5 6 7 8 9])
+   * Referenced by:
+   *   '<S505>/Constant3'
+   *   '<S554>/Constant5'
+   *   '<S549>/Constant5'
    */
   { 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U },
 
-  /* Computed Parameter: Constant3_Value_i
-   * Referenced by: '<S554>/Constant3'
+  /* Computed Parameter: Constant3_Value
+   * Referenced by: '<S575>/Constant3'
    */
   { 1U, 2U, 3U, 4U, 5U, 6U },
 
   /* Computed Parameter: Constant3_Value_j
-   * Referenced by: '<S621>/Constant3'
+   * Referenced by: '<S642>/Constant3'
    */
   { 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U },
 
diff --git a/HVAC_model_private.h b/HVAC_model_private.h
index ff6f710..8c35b3d 100644
--- a/HVAC_model_private.h
+++ b/HVAC_model_private.h
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.866
+ * Model version                  : 1.876
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Tue May  5 14:20:39 2026
+ * C/C++ source code generated on : Wed May  6 14:55:30 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -111,15 +111,15 @@ extern void Afoot_Summer(int16_t rtu_Amb_Fb, uint8_t rtu_LVL, uint16_t rty_Out1
 extern void left(uint8_t rtu_idx, uint16_t rty_vals[9]);
 extern void IfActionSubsystem(int8_t *rty_Out1, double *rtd_ErrorHomming_private,
   double *rtd_Start_timer_i, int8_t *rtd_stepSig_private);
-extern void IfActionSubsystem1(int8_t *rty_Out1, double *rtd_Start_timer_i);
 extern void MATLABFunction_Init(DW_MATLABFunction *localDW);
 extern void MATLABFunction(double rtu_cond, uint32_t rtu_t_now, uint32_t *rty_dt,
   DW_MATLABFunction *localDW);
-extern void IfActionSubsystem1_d(int8_t *rty_Output, uint8_t
+extern void IfActionSubsystem1(int8_t *rty_Output, uint8_t
   *rtd_CCU_ActuatorErrF_Stat_private, uint8_t rtd_COM_private[9], uint8_t
   rtd_ErrorActuator[9], uint8_t rtd_ErrorCalibration_private[9], const double
   *rtd_LOGGER_LIN, uint8_t rtd_MODE_private[9], uint8_t
   rtd_dtc_state_error_model[127]);
+extern void IfActionSubsystem1_l(int8_t *rty_Out1, double *rtd_Start_timer_l);
 extern void AFforBiLevel(uint8_t rtu_blower_speed, uint16_t *rty_out);
 extern void AFforDef(uint8_t rtu_blower_speed, uint16_t *rty_out);
 extern void AFforFoorDef(uint8_t rtu_blower_speed, uint16_t *rty_out);
@@ -130,6 +130,16 @@ extern void AFforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out);
 extern void AFforBiLevelR(uint8_t rtu_blower_speed, uint16_t *rty_out);
 extern void AFforFootR(uint8_t rtu_blower_speed, uint16_t *rty_out);
 extern void AFforVentmodeR(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforBiLevel(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforDef(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforFoot(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforFootDef(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforHi_Level(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforTriLevel(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void ValvesforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void AFforBiLevel_m(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void AFforFoot_p(uint8_t rtu_blower_speed, uint16_t *rty_out);
+extern void valvesforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out);
 extern void g_assSTART_ENTER_INCAR_j(uint8_t rtu_LVL, int16_t *rty_out);
 extern void g_assSTART_ENTER_COOLANT_p(uint8_t rtu_LVL, int16_t *rty_out);
 extern void Level4(int8_t *rty_step1, const uint16_t *rtd_ECT, const uint8_t
diff --git a/HVAC_model_types.h b/HVAC_model_types.h
index bd54ec4..2d35d8b 100644
--- a/HVAC_model_types.h
+++ b/HVAC_model_types.h
@@ -3,9 +3,9 @@
  *
  * Code generated for Simulink model 'HVAC_model'.
  *
- * Model version                  : 1.866
+ * Model version                  : 1.876
  * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
- * C/C++ source code generated on : Tue May  5 14:20:39 2026
+ * C/C++ source code generated on : Wed May  6 14:55:30 2026
  *
  * Target selection: ert.tlc
  * Embedded hardware selection: ARM Compatible->ARM Cortex-M
@@ -252,6 +252,24 @@ typedef struct {
 
 #endif
 
+#ifndef DEFINED_TYPEDEF_FOR_dbgCAN_dbg_Logic_Blower_Bus_
+#define DEFINED_TYPEDEF_FOR_dbgCAN_dbg_Logic_Blower_Bus_
+
+typedef struct {
+  uint8_t Logic_Blower_Step_FL;
+  uint8_t Logic_Blower_Step_FR;
+  uint8_t Logic_Blower_Step_RL;
+  uint8_t Logic_Blower_Step_RR;
+  uint8_t Logic_Blower_Pwm_Front;
+  uint8_t Logic_Blower_Pwm_Rear;
+  uint8_t Logic_Blower_AF_FL;
+  uint8_t Logic_Blower_AF_FR;
+  uint8_t Logic_Blower_AF_RL;
+  uint8_t Logic_Blower_AF_RR;
+} dbgCAN_dbg_Logic_Blower_Bus;
+
+#endif
+
 #ifndef DEFINED_TYPEDEF_FOR_dbgCAN_dbg_Act0_Bus_
 #define DEFINED_TYPEDEF_FOR_dbgCAN_dbg_Act0_Bus_