/*
 * File: HVAC_model.c
 *
 * Code generated for Simulink model 'HVAC_model'.
 *
 * Model version                  : 1.760
 * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
 * C/C++ source code generated on : Fri Apr  3 18:15:49 2026
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: ARM Compatible->ARM Cortex-M
 * Emulation hardware selection:
 *    Differs from embedded hardware (MATLAB Host)
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "HVAC_model.h"
#include <stdint.h>
#include <stdbool.h>
#include "HVAC_model_private.h"
#include <math.h>
#include "HVAC_model_types.h"
#include "Rs_Cal_Base.h"

/* Named constants for Test Sequence: '<Root>/Test Sequence' */
#define IN_step_1                      ((uint8_t)1U)
#define IN_step_2                      ((uint8_t)2U)
#define IN_step_3                      ((uint8_t)3U)

/* Exported block states */
ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S381>/Data Store Memory15' */
ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S382>/Data Store Memory15' */
ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S383>/Data Store Memory15' */
CmdBusStatus Status_Sensor_Model;      /* '<S2>/Data Store Memory' */
CmdBusError CCU_Errors_Model;          /* '<Root>/Data Store Memory3' */
CmdBusPWMGet PWM_Get;                  /* '<S5>/Data Store Memory1' */

/* Block signals (default storage) */
B rtB;

/* Block states (default storage) */
DW rtDW;

/* External outputs (root outports fed by signals with default storage) */
ExtY rtY;

/* Real-time model */
static RT_MODEL rtM_;
RT_MODEL *const rtM = &rtM_;
uint16_t look1_iu16bs16lu64n32_binlcse(uint16_t u0, const int16_t bp0[], const
  uint16_t table[], uint32_t maxIndex)
{
  uint64_t frac;
  uint32_t iLeft;
  uint16_t y;
  uint16_t yL_0d0;
  uint16_t yR_0d0;

  /* Column-major Lookup 1-D
     Search method: 'binary'
     Use previous index: 'off'
     Interpolation method: 'Linear point-slope'
     Extrapolation method: 'Clip'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
     Rounding mode: 'simplest'
   */
  /* Prelookup - Index and Fraction
     Index Search method: 'binary'
     Extrapolation method: 'Clip'
     Use previous index: 'off'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
     Rounding mode: 'simplest'
   */
  yR_0d0 = u0;
  if (u0 > 32767) {
    yR_0d0 = 32767U;
  }

  if (u0 < bp0[0U]) {
    iLeft = 0U;
    frac = 0ULL;
  } else if ((int16_t)yR_0d0 < bp0[maxIndex]) {
    uint32_t bpIdx;
    uint32_t iRght;

    /* Binary Search */
    bpIdx = maxIndex >> 1U;
    iLeft = 0U;
    iRght = maxIndex;
    while (iRght - iLeft > 1U) {
      if ((int16_t)yR_0d0 < bp0[bpIdx]) {
        iRght = bpIdx;
      } else {
        iLeft = bpIdx;
      }

      bpIdx = (iRght + iLeft) >> 1U;
    }

    frac = ((uint64_t)(u0 - (uint32_t)bp0[iLeft]) << 32) / (uint32_t)(bp0[iLeft
      + 1U] - bp0[iLeft]);
  } else {
    iLeft = maxIndex - 1U;
    frac = 4294967296ULL;
  }

  /* Column-major Interpolation 1-D
     Interpolation method: 'Linear point-slope'
     Use last breakpoint for index at or above upper limit: 'off'
     Rounding mode: 'simplest'
     Overflow mode: 'wrapping'
   */
  yR_0d0 = table[iLeft + 1U];
  yL_0d0 = table[iLeft];
  if (yR_0d0 >= yL_0d0) {
    y = (uint16_t)((uint32_t)(uint16_t)(((uint16_t)((uint32_t)yR_0d0 - yL_0d0) *
      frac) >> 32) + yL_0d0);
  } else {
    y = (uint16_t)((uint32_t)yL_0d0 - (uint16_t)(((uint16_t)((uint32_t)yL_0d0 -
      yR_0d0) * frac) >> 32));
  }

  return y;
}

uint32_t binsearch_u32s16(int16_t u, const int16_t bp[], uint32_t startIndex,
  uint32_t maxIndex)
{
  uint32_t bpIdx;
  uint32_t bpIndex;
  uint32_t iRght;

  /* Binary Search */
  bpIdx = startIndex;
  bpIndex = 0U;
  iRght = maxIndex;
  while (iRght - bpIndex > 1U) {
    if (u < bp[bpIdx]) {
      iRght = bpIdx;
    } else {
      bpIndex = bpIdx;
    }

    bpIdx = (iRght + bpIndex) >> 1U;
  }

  return bpIndex;
}

uint8_t look2_iu8bu8s16lu64n32_binlcse(uint8_t u0, uint8_t u1, const uint8_t
  bp0[], const int16_t bp1[], const uint8_t table[], const uint32_t maxIndex[],
  uint32_t stride)
{
  uint64_t fractions[2];
  uint64_t frac;
  uint32_t bpIndices[2];
  uint32_t bpIdx;
  uint32_t iLeft;
  uint32_t iRght;
  uint8_t bpLeftVar;
  uint8_t y;
  uint8_t yL_0d0;
  uint8_t yL_1d;

  /* Column-major Lookup 2-D
     Search method: 'binary'
     Use previous index: 'off'
     Interpolation method: 'Linear point-slope'
     Extrapolation method: 'Clip'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
     Rounding mode: 'simplest'
   */
  /* Prelookup - Index and Fraction
     Index Search method: 'binary'
     Extrapolation method: 'Clip'
     Use previous index: 'off'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
     Rounding mode: 'simplest'
   */
  if (u0 <= bp0[0U]) {
    iLeft = 0U;
    frac = 0ULL;
  } else if (u0 < bp0[maxIndex[0U]]) {
    /* Binary Search */
    bpIdx = maxIndex[0U] >> 1U;
    iLeft = 0U;
    iRght = maxIndex[0U];
    while (iRght - iLeft > 1U) {
      if (u0 < bp0[bpIdx]) {
        iRght = bpIdx;
      } else {
        iLeft = bpIdx;
      }

      bpIdx = (iRght + iLeft) >> 1U;
    }

    bpLeftVar = bp0[iLeft];
    frac = ((uint64_t)((uint32_t)u0 - bpLeftVar) << 32) / ((uint32_t)bp0[iLeft +
      1U] - bpLeftVar);
  } else {
    iLeft = maxIndex[0U] - 1U;
    frac = 4294967296ULL;
  }

  fractions[0U] = frac;
  bpIndices[0U] = iLeft;

  /* Prelookup - Index and Fraction
     Index Search method: 'binary'
     Extrapolation method: 'Clip'
     Use previous index: 'off'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
     Rounding mode: 'simplest'
   */
  if (u1 < bp1[0U]) {
    iLeft = 0U;
    frac = 0ULL;
  } else if (u1 < bp1[maxIndex[1U]]) {
    /* Binary Search */
    bpIdx = maxIndex[1U] >> 1U;
    iLeft = 0U;
    iRght = maxIndex[1U];
    while (iRght - iLeft > 1U) {
      if (u1 < bp1[bpIdx]) {
        iRght = bpIdx;
      } else {
        iLeft = bpIdx;
      }

      bpIdx = (iRght + iLeft) >> 1U;
    }

    frac = ((uint64_t)(u1 - (uint32_t)bp1[iLeft]) << 32) / (uint32_t)(bp1[iLeft
      + 1U] - bp1[iLeft]);
  } else {
    iLeft = maxIndex[1U] - 1U;
    frac = 4294967296ULL;
  }

  /* Column-major Interpolation 2-D
     Interpolation method: 'Linear point-slope'
     Use last breakpoint for index at or above upper limit: 'off'
     Rounding mode: 'simplest'
     Overflow mode: 'wrapping'
   */
  bpIdx = iLeft * stride + bpIndices[0U];
  bpLeftVar = table[bpIdx + 1U];
  yL_0d0 = table[bpIdx];
  if (bpLeftVar >= yL_0d0) {
    yL_1d = (uint8_t)((uint32_t)(uint8_t)(((uint8_t)((uint32_t)bpLeftVar -
      yL_0d0) * fractions[0U]) >> 32) + yL_0d0);
  } else {
    yL_1d = (uint8_t)((uint32_t)yL_0d0 - (uint8_t)(((uint8_t)((uint32_t)yL_0d0 -
      bpLeftVar) * fractions[0U]) >> 32));
  }

  bpIdx += stride;
  bpLeftVar = table[bpIdx + 1U];
  yL_0d0 = table[bpIdx];
  if (bpLeftVar >= yL_0d0) {
    bpLeftVar = (uint8_t)((uint32_t)(uint8_t)(((uint8_t)((uint32_t)bpLeftVar -
      yL_0d0) * fractions[0U]) >> 32) + yL_0d0);
  } else {
    bpLeftVar = (uint8_t)((uint32_t)yL_0d0 - (uint8_t)(((uint8_t)((uint32_t)
      yL_0d0 - bpLeftVar) * fractions[0U]) >> 32));
  }

  if (bpLeftVar >= yL_1d) {
    y = (uint8_t)((uint32_t)(uint8_t)(((uint8_t)((uint32_t)bpLeftVar - yL_1d) *
      frac) >> 32) + yL_1d);
  } else {
    y = (uint8_t)((uint32_t)yL_1d - (uint8_t)(((uint8_t)((uint32_t)yL_1d -
      bpLeftVar) * frac) >> 32));
  }

  return y;
}

int16_t look1_iu16tdIs16_binlcs(uint16_t u0, const uint16_t bp0[], const double
  table[], uint32_t maxIndex)
{
  double frac;
  double yL_0d0;
  int32_t tmp_1;
  uint32_t iLeft;
  int16_t tmp;
  int16_t tmp_0;

  /* Column-major Lookup 1-D
     Search method: 'binary'
     Use previous index: 'off'
     Interpolation method: 'Linear point-slope'
     Extrapolation method: 'Clip'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
   */
  /* Prelookup - Index and Fraction
     Index Search method: 'binary'
     Extrapolation method: 'Clip'
     Use previous index: 'off'
     Use last breakpoint for index at or above upper limit: 'off'
     Remove protection against out-of-range input in generated code: 'off'
   */
  if (u0 <= bp0[0U]) {
    iLeft = 0U;
    frac = 0.0;
  } else if (u0 < bp0[maxIndex]) {
    uint32_t bpIdx;
    uint32_t iRght;

    /* Binary Search */
    bpIdx = maxIndex >> 1U;
    iLeft = 0U;
    iRght = maxIndex;
    while (iRght - iLeft > 1U) {
      if (u0 < bp0[bpIdx]) {
        iRght = bpIdx;
      } else {
        iLeft = bpIdx;
      }

      bpIdx = (iRght + iLeft) >> 1U;
    }

    uint16_t bpLeftVar;
    bpLeftVar = bp0[iLeft];
    frac = (double)((uint32_t)u0 - bpLeftVar) / (double)((uint32_t)bp0[iLeft +
      1U] - bpLeftVar);
  } else {
    iLeft = maxIndex - 1U;
    frac = 1.0;
  }

  /* Column-major Interpolation 1-D
     Interpolation method: 'Linear point-slope'
     Use last breakpoint for index at or above upper limit: 'off'
     Overflow mode: 'saturate'
   */
  yL_0d0 = table[iLeft];
  if (yL_0d0 < 32768.0) {
    if (yL_0d0 >= -32768.0) {
      tmp = (int16_t)yL_0d0;
    } else {
      tmp = INT16_MIN;
    }
  } else {
    tmp = INT16_MAX;
  }

  frac *= table[iLeft + 1U] - yL_0d0;
  if (frac < 32768.0) {
    if (frac >= -32768.0) {
      tmp_0 = (int16_t)frac;
    } else {
      tmp_0 = INT16_MIN;
    }
  } else {
    tmp_0 = INT16_MAX;
  }

  tmp_1 = tmp + tmp_0;
  if (tmp_1 > 32767) {
    tmp_1 = 32767;
  } else if (tmp_1 < -32768) {
    tmp_1 = -32768;
  }

  return (int16_t)tmp_1;
}

uint32_t plook_u32s16_bincka(int16_t u, const int16_t bp[], uint32_t maxIndex)
{
  uint32_t bpIndex;

  /* Prelookup - Index only
     Index Search method: 'binary'
     Extrapolation method: 'Clip'
     Use previous index: 'off'
     Use last breakpoint for index at or above upper limit: 'on'
     Remove protection against out-of-range input in generated code: 'off'
   */
  if (u <= bp[0U]) {
    bpIndex = 0U;
  } else if (u < bp[maxIndex]) {
    bpIndex = binsearch_u32s16(u, bp, maxIndex >> 1U, maxIndex);
  } else {
    bpIndex = maxIndex;
  }

  return bpIndex;
}

/*
 * Output and update for atomic system:
 *    '<S91>/get_tg_FLL_for_LVL'
 *    '<S119>/get_tg_FLL_for_LVL'
 *    '<S67>/get_tg_for_LVL'
 *    '<S200>/get_tg_FLL_for_LVL'
 *    '<S228>/get_tg_FLL_for_LVL'
 *    '<S176>/get_tg_for_LVL'
 */
void get_tg_FLL_for_LVL(uint8_t rtu_ambient_Lvl, uint8_t rtu_set_tmp, int16_t
  *rty_vals)
{
  int32_t i;
  uint32_t qY;
  int16_t tmp[78];

  /* :  table = [ */
  /* :          g_assTG_FLL_LV0; */
  /* :          g_assTG_FLL_LV1; */
  /* :          g_assTG_FLL_LV2; */
  /* :          g_assTG_FLL_LV3; */
  /* :          g_assTG_FLL_LV4; */
  /* :          g_assTG_FLL_LV5 */
  /* :      ]; */
  /* :  vals = table(ambient_Lvl + 1, set_tmp - 16); */
  for (i = 0; i < 13; i++) {
    tmp[6 * i] = g_assTG_FLL_LV0[i];
    tmp[6 * i + 1] = g_assTG_FLL_LV1[i];
    tmp[6 * i + 2] = g_assTG_FLL_LV2[i];
    tmp[6 * i + 3] = g_assTG_FLL_LV3[i];
    tmp[6 * i + 4] = g_assTG_FLL_LV4[i];
    tmp[6 * i + 5] = g_assTG_FLL_LV5[i];
  }

  i = (int32_t)(rtu_ambient_Lvl + 1U);
  if (rtu_ambient_Lvl + 1U > 255U) {
    i = 255;
  }

  /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
  qY = rtu_set_tmp - 16U;

  /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
  if (rtu_set_tmp - 16U > rtu_set_tmp) {
    qY = 0U;
  }

  *rty_vals = tmp[(((int32_t)qY - 1) * 6 + i) - 1];
}

/*
 * Output and update for atomic system:
 *    '<S98>/get_tg_FLL_for_LVL'
 *    '<S126>/get_tg_FLL_for_LVL'
 *    '<S73>/get_tg_FLL_for_LVL'
 *    '<S207>/get_tg_FLL_for_LVL'
 *    '<S235>/get_tg_FLL_for_LVL'
 *    '<S182>/get_tg_FLL_for_LVL'
 */
void get_tg_FLL_for_LVL_j(uint8_t rtu_ambient_Lvl, uint8_t rtu_set_tmp, int16_t *
  rty_vals)
{
  int32_t i;
  uint32_t qY;
  int16_t tmp[78];

  /* :  table = [ */
  /* :          g_assTG_FRL_LV0; */
  /* :          g_assTG_FRL_LV1; */
  /* :          g_assTG_FRL_LV2; */
  /* :          g_assTG_FRL_LV3; */
  /* :          g_assTG_FRL_LV4; */
  /* :          g_assTG_FRL_LV5 */
  /* :      ]; */
  /* :  vals = table(ambient_Lvl + 1, set_tmp - 16); */
  for (i = 0; i < 13; i++) {
    tmp[6 * i] = g_assTG_FRL_LV0[i];
    tmp[6 * i + 1] = g_assTG_FRL_LV1[i];
    tmp[6 * i + 2] = g_assTG_FRL_LV2[i];
    tmp[6 * i + 3] = g_assTG_FRL_LV3[i];
    tmp[6 * i + 4] = g_assTG_FRL_LV4[i];
    tmp[6 * i + 5] = g_assTG_FRL_LV5[i];
  }

  i = (int32_t)(rtu_ambient_Lvl + 1U);
  if (rtu_ambient_Lvl + 1U > 255U) {
    i = 255;
  }

  /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
  qY = rtu_set_tmp - 16U;

  /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
  if (rtu_set_tmp - 16U > rtu_set_tmp) {
    qY = 0U;
  }

  *rty_vals = tmp[(((int32_t)qY - 1) * 6 + i) - 1];
}

/*
 * Output and update for atomic system:
 *    '<S88>/g_assFLOW_BI_AMB_TGT'
 *    '<S89>/g_assFLOW_BI_AMB_TGT'
 *    '<S197>/g_assFLOW_BI_AMB_TGT'
 *    '<S198>/g_assFLOW_BI_AMB_TGT'
 */
void g_assFLOW_BI_AMB_TGT_n(uint8_t rtu_LVL, int16_t *rty_c_g_assFLOW_BI_AMB_TGT)
{
  int32_t tmp;

  /* :  c_g_assFLOW_BI_AMB_TGT = g_assFLOW_BI_AMB_TGT(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_c_g_assFLOW_BI_AMB_TGT = g_assFLOW_BI_AMB_TGT[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S29>/Bilevel'
 *    '<S30>/Bilevel'
 */
void Bilevel(int16_t rtu_Amb_Fb, uint8_t rtu_LVL, uint16_t rty_Out1[9], uint8_t
             rtu_setTempFL, uint8_t rtu_setTempFR)
{
  int32_t tmp;
  int32_t tmp_0;
  int16_t rtb_u_eg;
  uint16_t rtb_FLF_NEW;
  uint16_t rtb_FRF_NEW;
  uint16_t rtb_Switch2_a_idx_0;
  uint16_t rtb_Switch2_a_idx_1;
  uint16_t rtb_Switch2_c_0;
  int8_t rtb_X;
  uint8_t rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN;
  uint8_t rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX;
  uint8_t rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX_n;
  uint8_t rtb_c_g_aucFLOW_BI_FOOT_VALVE_MIN;
  uint8_t rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX;
  uint8_t rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX_h;
  uint8_t rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN;
  uint8_t rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN_a;

  /* MATLAB Function: '<S91>/get_tg_FLL_for_LVL' */
  /* :  c_g_assFLOW_BI_TEMP_TGT = g_assFLOW_BI_TEMP_TGT(LVL + 1); */
  get_tg_FLL_for_LVL(rtu_LVL, rtu_setTempFL, &rtb_u_eg);

  /* MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT' */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* Sum: '<S91>/ 1' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  rtb_u_eg = (int16_t)(g_assFLOW_BI_TEMP_TGT[tmp_0 - 1] - rtb_u_eg);

  /* Gain: '<S91>/Gain6' */
  tmp_0 = 13107 * rtb_u_eg;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S86>/Switch1' incorporates:
   *  Gain: '<S86>/Gain6'
   *  Sum: '<S86>/Add'
   */
  /* :  c_g_aucFLOW_BI_FOOT_PLUS = g_aucFLOW_BI_FOOT_PLUS(LVL + 1); */
  if (rtb_X >= 0) {
    rtb_FLF_NEW = rty_Out1[4];
  } else {
    /* MATLAB Function: '<S86>/g_aucFLOW_BI_FOOT_PLUS_LEFT' incorporates:
     *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S86>/Gain6' incorporates:
     *  MATLAB Function: '<S86>/g_aucFLOW_BI_FOOT_PLUS_LEFT'
     *  Product: '<S86>/Product3'
     */
    tmp_0 = g_aucFLOW_BI_FOOT_PLUS[tmp_0 - 1] * rtb_X * 13107;
    rtb_FLF_NEW = (uint16_t)((int16_t)rty_Out1[4] - (int8_t)(((((uint32_t)tmp_0
      & 65536U) != 0U) && (((uint32_t)tmp_0 & 65535U) != 0U)) + (tmp_0 >> 17)));
  }

  /* End of Switch: '<S86>/Switch1' */

  /* MATLAB Function: '<S86>/g_aucFLOW_BI_FOOT_VALVE_MAX1' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_FOOT_VALVE_MAX = g_aucFLOW_BI_FOOT_VALVE_MAX(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX_n = g_aucFLOW_BI_FOOT_VALVE_MAX[tmp_0 - 1];

  /* End of MATLAB Function: '<S86>/g_aucFLOW_BI_FOOT_VALVE_MAX1' */

  /* MATLAB Function: '<S86>/g_aucFLOW_BI_FOOT_VALVE_MIN1' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_VALVE_MIN = g_aucFLOW_BI_FOOT_VALVE_MIN(LVL +1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN = g_aucFLOW_BI_FOOT_VALVE_MIN[tmp_0 - 1];

  /* End of MATLAB Function: '<S86>/g_aucFLOW_BI_FOOT_VALVE_MIN1' */

  /* MATLAB Function: '<S98>/get_tg_FLL_for_LVL' */
  /* :  c_g_assFLOW_BI_TEMP_TGT = g_assFLOW_BI_TEMP_TGT(LVL + 1 + 6); */
  get_tg_FLL_for_LVL_j(rtu_LVL, rtu_setTempFR, &rtb_u_eg);

  /* MATLAB Function: '<S98>/g_assFLOW_BI_TEMP_TGT_RIGHT' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  /* Sum: '<S98>/ 1' incorporates:
   *  MATLAB Function: '<S98>/g_assFLOW_BI_TEMP_TGT_RIGHT'
   */
  rtb_u_eg = (int16_t)(g_assFLOW_BI_TEMP_TGT[tmp - 1] - rtb_u_eg);

  /* Gain: '<S98>/Gain6' */
  tmp_0 = 13107 * rtb_u_eg;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S87>/Switch3' incorporates:
   *  Gain: '<S87>/Gain7'
   *  Sum: '<S87>/Add1'
   */
  /* :  c_g_aucFLOW_BI_FOOT_PLUS = g_aucFLOW_BI_FOOT_PLUS(LVL + 1 + 6); */
  if (rtb_X >= 0) {
    rtb_FRF_NEW = rty_Out1[6];
  } else {
    /* MATLAB Function: '<S87>/g_aucFLOW_BI_FOOT_PLUS_RIGHT' incorporates:
     *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    tmp = (int32_t)((uint32_t)tmp_0 + 6U);
    if ((uint32_t)tmp_0 + 6U > 255U) {
      tmp = 255;
    }

    /* Gain: '<S87>/Gain7' incorporates:
     *  MATLAB Function: '<S87>/g_aucFLOW_BI_FOOT_PLUS_RIGHT'
     *  Product: '<S87>/Product4'
     */
    tmp_0 = g_aucFLOW_BI_FOOT_PLUS[tmp - 1] * rtb_X * 13107;
    rtb_FRF_NEW = (uint16_t)((int16_t)rty_Out1[6] - (int8_t)(((((uint32_t)tmp_0
      & 65536U) != 0U) && (((uint32_t)tmp_0 & 65535U) != 0U)) + (tmp_0 >> 17)));
  }

  /* End of Switch: '<S87>/Switch3' */

  /* MATLAB Function: '<S87>/g_aucFLOW_BI_FOOT_VALVE_MAX2' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_FOOT_VALVE_MAX = g_aucFLOW_BI_FOOT_VALVE_MAX(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX = g_aucFLOW_BI_FOOT_VALVE_MAX[tmp - 1];

  /* End of MATLAB Function: '<S87>/g_aucFLOW_BI_FOOT_VALVE_MAX2' */

  /* MATLAB Function: '<S87>/g_aucFLOW_BI_FOOT_VALVE_MIN2' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_FOOT_VALVE_MIN = g_aucFLOW_BI_FOOT_VALVE_MIN(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI_FOOT_VALVE_MIN = g_aucFLOW_BI_FOOT_VALVE_MIN[tmp - 1];

  /* End of MATLAB Function: '<S87>/g_aucFLOW_BI_FOOT_VALVE_MIN2' */

  /* MATLAB Function: '<S88>/g_assFLOW_BI_AMB_TGT' */
  /* :  c_g_aucFLOW_BI_VENT_PLUS = g_aucFLOW_BI_VENT_PLUS(LVL + 1); */
  g_assFLOW_BI_AMB_TGT_n(rtu_LVL, &rtb_u_eg);

  /* MATLAB Function: '<S88>/g_aucFLOW_BI_VENT_PLUS' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* Gain: '<S88>/Gain2' incorporates:
   *  Sum: '<S88>/deg'
   */
  tmp = (int16_t)(rtb_u_eg - rtu_Amb_Fb) * 13107;

  /* Product: '<S88>/Умножили' incorporates:
   *  Gain: '<S88>/Gain'
   *  Gain: '<S88>/Gain2'
   *  MATLAB Function: '<S88>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_eg = (int16_t)((int8_t)(((((uint32_t)tmp & 65536U) != 0U) &&
    ((((uint32_t)tmp & 65535U) != 0U) || (tmp > 0))) + (tmp >> 17)) * (int32_t)
                       ((g_aucFLOW_BI_VENT_PLUS[tmp_0 - 1] * 205U + 1024U) >> 11));

  /* DataTypeConversion: '<S88>/Data Type Conversion' incorporates:
   *  Sum: '<S88>/ '
   *  Switch: '<S104>/Switch2'
   */
  rtb_Switch2_a_idx_0 = (uint16_t)((uint16_t)((rty_Out1[0] - rtb_u_eg) >> 1) <<
    1);
  rtb_Switch2_a_idx_1 = (uint16_t)((uint16_t)((rty_Out1[1] - rtb_u_eg) >> 1) <<
    1);

  /* MATLAB Function: '<S88>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_VENT_VALVE_MAX = g_aucFLOW_BI_VENT_VALVE_MAX(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX_h = g_aucFLOW_BI_VENT_VALVE_MAX[tmp_0 - 1];

  /* End of MATLAB Function: '<S88>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S88>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_VENT_VALVE_MIN = g_aucFLOW_BI_VENT_VALVE_MIN(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN_a = g_aucFLOW_BI_VENT_VALVE_MIN[tmp_0 - 1];

  /* End of MATLAB Function: '<S88>/g_aucFLOW_BI_VENT_VALVE_MIN' */

  /* MATLAB Function: '<S89>/g_assFLOW_BI_AMB_TGT' */
  /* :  c_g_aucFLOW_BI_VENT_PLUS = g_aucFLOW_BI_VENT_PLUS(LVL + 1 + 6); */
  g_assFLOW_BI_AMB_TGT_n(rtu_LVL, &rtb_u_eg);

  /* MATLAB Function: '<S89>/g_aucFLOW_BI_VENT_PLUS' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  /* Gain: '<S89>/Gain2' incorporates:
   *  Sum: '<S89>/deg'
   */
  tmp_0 = (int16_t)(rtb_u_eg - rtu_Amb_Fb) * 13107;

  /* Product: '<S89>/Умножили' incorporates:
   *  Gain: '<S89>/Gain'
   *  Gain: '<S89>/Gain2'
   *  MATLAB Function: '<S89>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_eg = (int16_t)((int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) &&
    ((((uint32_t)tmp_0 & 65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17)) *
                       (int32_t)((g_aucFLOW_BI_VENT_PLUS[tmp - 1] * 205U + 1024U)
    >> 11));

  /* MATLAB Function: '<S89>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_VENT_VALVE_MAX = g_aucFLOW_BI_VENT_VALVE_MAX(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX = g_aucFLOW_BI_VENT_VALVE_MAX[tmp - 1];

  /* End of MATLAB Function: '<S89>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S89>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S91>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI_VENT_VALVE_MIN = g_aucFLOW_BI_VENT_VALVE_MIN(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN = g_aucFLOW_BI_VENT_VALVE_MIN[tmp - 1];

  /* End of MATLAB Function: '<S89>/g_aucFLOW_BI_VENT_VALVE_MIN' */

  /* DataTypeConversion: '<S89>/Data Type Conversion' incorporates:
   *  Sum: '<S89>/ '
   *  Switch: '<S109>/Switch2'
   */
  rtb_Switch2_c_0 = (uint16_t)((uint16_t)((rty_Out1[0] - rtb_u_eg) >> 1) << 1);

  /* Switch: '<S104>/Switch2' incorporates:
   *  RelationalOperator: '<S104>/LowerRelop1'
   *  RelationalOperator: '<S104>/UpperRelop'
   *  Switch: '<S104>/Switch'
   */
  if (rtb_Switch2_a_idx_0 > rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX_h) {
    /* Assignment: '<S35>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[0] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX_h;
  } else if (rtb_Switch2_a_idx_0 < rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN_a) {
    /* Switch: '<S104>/Switch' incorporates:
     *  Assignment: '<S35>/Присваивание в [1-2]'
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[0] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN_a;
  } else {
    /* Assignment: '<S35>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     *  Switch: '<S104>/Switch'
     */
    rty_Out1[0] = rtb_Switch2_a_idx_0;
  }

  /* Switch: '<S109>/Switch2' incorporates:
   *  RelationalOperator: '<S109>/LowerRelop1'
   *  RelationalOperator: '<S109>/UpperRelop'
   *  Switch: '<S109>/Switch'
   */
  if (rtb_Switch2_c_0 > rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX) {
    /* Assignment: '<S35>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[2] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX;
  } else if (rtb_Switch2_c_0 < rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN) {
    /* Switch: '<S109>/Switch' incorporates:
     *  Assignment: '<S35>/Присваивание в [3-4]'
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[2] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN;
  } else {
    /* Assignment: '<S35>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     *  Switch: '<S109>/Switch'
     */
    rty_Out1[2] = rtb_Switch2_c_0;
  }

  /* DataTypeConversion: '<S89>/Data Type Conversion' incorporates:
   *  Sum: '<S89>/ '
   *  Switch: '<S109>/Switch2'
   */
  rtb_Switch2_c_0 = (uint16_t)((uint16_t)((rty_Out1[1] - rtb_u_eg) >> 1) << 1);

  /* Switch: '<S104>/Switch2' incorporates:
   *  RelationalOperator: '<S104>/LowerRelop1'
   *  RelationalOperator: '<S104>/UpperRelop'
   *  Switch: '<S104>/Switch'
   */
  if (rtb_Switch2_a_idx_1 > rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX_h) {
    /* Assignment: '<S35>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[1] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX_h;
  } else if (rtb_Switch2_a_idx_1 < rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN_a) {
    /* Switch: '<S104>/Switch' incorporates:
     *  Assignment: '<S35>/Присваивание в [1-2]'
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[1] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN_a;
  } else {
    /* Assignment: '<S35>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     *  Switch: '<S104>/Switch'
     */
    rty_Out1[1] = rtb_Switch2_a_idx_1;
  }

  /* Switch: '<S109>/Switch2' incorporates:
   *  RelationalOperator: '<S109>/LowerRelop1'
   *  RelationalOperator: '<S109>/UpperRelop'
   *  Switch: '<S109>/Switch'
   */
  if (rtb_Switch2_c_0 > rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX) {
    /* Assignment: '<S35>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[3] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MAX;
  } else if (rtb_Switch2_c_0 < rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN) {
    /* Switch: '<S109>/Switch' incorporates:
     *  Assignment: '<S35>/Присваивание в [3-4]'
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[3] = rtb_c_g_aucFLOW_BI_VENT_VALVE_MIN;
  } else {
    /* Assignment: '<S35>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     *  Switch: '<S109>/Switch'
     */
    rty_Out1[3] = rtb_Switch2_c_0;
  }

  /* Switch: '<S90>/Switch2' incorporates:
   *  RelationalOperator: '<S90>/LowerRelop1'
   *  RelationalOperator: '<S90>/UpperRelop'
   *  Switch: '<S90>/Switch'
   */
  if (rtb_FLF_NEW > rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX_n) {
    /* Assignment: '<S35>/Присваивание в [5]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[4] = rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX_n;
  } else if (rtb_FLF_NEW < rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN) {
    /* Switch: '<S90>/Switch' incorporates:
     *  Assignment: '<S35>/Присваивание в [5]'
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[4] = rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN;
  } else {
    /* Assignment: '<S35>/Присваивание в [5]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     *  Switch: '<S90>/Switch'
     */
    rty_Out1[4] = rtb_FLF_NEW;
  }

  /* End of Switch: '<S90>/Switch2' */

  /* Switch: '<S97>/Switch2' incorporates:
   *  RelationalOperator: '<S97>/LowerRelop1'
   *  RelationalOperator: '<S97>/UpperRelop'
   *  Switch: '<S97>/Switch'
   */
  if (rtb_FRF_NEW > rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX) {
    /* Assignment: '<S35>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[6] = rtb_c_g_aucFLOW_BI_FOOT_VALVE_MAX;
  } else if (rtb_FRF_NEW < rtb_c_g_aucFLOW_BI_FOOT_VALVE_MIN) {
    /* Switch: '<S97>/Switch' incorporates:
     *  Assignment: '<S35>/Присваивание в [7]'
     *  SignalConversion generated from: '<S35>/Out1'
     */
    rty_Out1[6] = rtb_c_g_aucFLOW_BI_FOOT_VALVE_MIN;
  } else {
    /* Assignment: '<S35>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S35>/Out1'
     *  Switch: '<S97>/Switch'
     */
    rty_Out1[6] = rtb_FRF_NEW;
  }

  /* End of Switch: '<S97>/Switch2' */
}

/*
 * Output and update for atomic system:
 *    '<S116>/g_assFLOW_BI_AMB_TGT'
 *    '<S117>/g_assFLOW_BI_AMB_TGT'
 *    '<S225>/g_assFLOW_BI_AMB_TGT'
 *    '<S226>/g_assFLOW_BI_AMB_TGT'
 */
void g_assFLOW_BI_AMB_TGT_e(uint8_t rtu_LVL, int16_t
  *rty_c_g_assFLOW_BI2_AMB_TGT)
{
  int32_t tmp;

  /* :  c_g_assFLOW_BI2_AMB_TGT = g_assFLOW_B2I_AMB_TGT(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_c_g_assFLOW_BI2_AMB_TGT = g_assFLOW_B2I_AMB_TGT[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S29>/Bilevel2'
 *    '<S30>/Bilevel2'
 */
void Bilevel2(int16_t rtu_Amb_Fb, uint8_t rtu_LVL, uint16_t rty_Out1[9], uint8_t
              rtu_setTempFL, uint8_t rtu_setTempFR)
{
  int32_t tmp;
  int32_t tmp_0;
  int16_t rtb_u_abl;
  uint16_t rtb_FLF_NEW;
  uint16_t rtb_FRF_NEW;
  uint16_t rtb_Switch2_i_idx_0;
  uint16_t rtb_Switch2_i_idx_1;
  uint16_t rtb_Switch2_p_0;
  int8_t rtb_X;
  uint8_t rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX;
  uint8_t rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX_l;
  uint8_t rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN;
  uint8_t rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN_l;
  uint8_t rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX;
  uint8_t rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX_k;
  uint8_t rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN;
  uint8_t rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN_f;

  /* MATLAB Function: '<S119>/get_tg_FLL_for_LVL' */
  /* :  c_g_assFLOW_BI2_TEMP_TGT = g_assFLOW_BI2_TEMP_TGT(LVL + 1); */
  get_tg_FLL_for_LVL(rtu_LVL, rtu_setTempFL, &rtb_u_abl);

  /* MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT' */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* Sum: '<S119>/ 1' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  rtb_u_abl = (int16_t)(g_assFLOW_BI2_TEMP_TGT[tmp_0 - 1] - rtb_u_abl);

  /* Gain: '<S119>/Gain6' */
  tmp_0 = 13107 * rtb_u_abl;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S114>/Switch1' incorporates:
   *  Gain: '<S114>/Gain6'
   *  Sum: '<S114>/Add'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_PLUS = g_aucFLOW_BI2_FOOT_PLUS(LVL + 1); */
  if (rtb_X >= 0) {
    rtb_FLF_NEW = rty_Out1[4];
  } else {
    /* MATLAB Function: '<S114>/g_aucFLOW_BI_FOOT_PLUS_LEFT' incorporates:
     *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S114>/Gain6' incorporates:
     *  MATLAB Function: '<S114>/g_aucFLOW_BI_FOOT_PLUS_LEFT'
     *  Product: '<S114>/Product3'
     */
    tmp_0 = g_aucFLOW_BI2_FOOT_PLUS[tmp_0 - 1] * rtb_X * 13107;
    rtb_FLF_NEW = (uint16_t)((int16_t)rty_Out1[4] - (int8_t)(((((uint32_t)tmp_0
      & 65536U) != 0U) && (((uint32_t)tmp_0 & 65535U) != 0U)) + (tmp_0 >> 17)));
  }

  /* End of Switch: '<S114>/Switch1' */

  /* MATLAB Function: '<S114>/g_aucFLOW_BI_FOOT_VALVE_MAX1' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_VALVE_MAX = g_aucFLOW_BI2_FOOT_VALVE_MAX(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX_l = g_aucFLOW_BI2_FOOT_VALVE_MAX[tmp_0 - 1];

  /* End of MATLAB Function: '<S114>/g_aucFLOW_BI_FOOT_VALVE_MAX1' */

  /* MATLAB Function: '<S114>/g_aucFLOW_BI_FOOT_VALVE_MIN1' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_VALVE_MIN = g_aucFLOW_BI2_FOOT_VALVE_MIN(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN = g_aucFLOW_BI2_FOOT_VALVE_MIN[tmp_0 - 1];

  /* End of MATLAB Function: '<S114>/g_aucFLOW_BI_FOOT_VALVE_MIN1' */

  /* MATLAB Function: '<S126>/get_tg_FLL_for_LVL' */
  /* :  c_g_assFLOW_BI2_TEMP_TGT = g_assFLOW_BI2_TEMP_TGT(LVL + 1 + 6); */
  get_tg_FLL_for_LVL_j(rtu_LVL, rtu_setTempFR, &rtb_u_abl);

  /* MATLAB Function: '<S126>/g_assFLOW_BI2_TEMP_TGT_RIGHT' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  /* Sum: '<S126>/ 1' incorporates:
   *  MATLAB Function: '<S126>/g_assFLOW_BI2_TEMP_TGT_RIGHT'
   */
  rtb_u_abl = (int16_t)(g_assFLOW_BI2_TEMP_TGT[tmp - 1] - rtb_u_abl);

  /* Gain: '<S126>/Gain6' */
  tmp_0 = 13107 * rtb_u_abl;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S115>/Switch3' incorporates:
   *  Gain: '<S115>/Gain7'
   *  Sum: '<S115>/Add1'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_PLUS = g_aucFLOW_BI2_FOOT_PLUS(LVL + 1 + 6); */
  if (rtb_X >= 0) {
    rtb_FRF_NEW = rty_Out1[6];
  } else {
    /* MATLAB Function: '<S115>/g_aucFLOW_BI_FOOT_PLUS_RIGHT' incorporates:
     *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    tmp = (int32_t)((uint32_t)tmp_0 + 6U);
    if ((uint32_t)tmp_0 + 6U > 255U) {
      tmp = 255;
    }

    /* Gain: '<S115>/Gain7' incorporates:
     *  MATLAB Function: '<S115>/g_aucFLOW_BI_FOOT_PLUS_RIGHT'
     *  Product: '<S115>/Product4'
     */
    tmp_0 = g_aucFLOW_BI2_FOOT_PLUS[tmp - 1] * rtb_X * 13107;
    rtb_FRF_NEW = (uint16_t)((int16_t)rty_Out1[6] - (int8_t)(((((uint32_t)tmp_0
      & 65536U) != 0U) && (((uint32_t)tmp_0 & 65535U) != 0U)) + (tmp_0 >> 17)));
  }

  /* End of Switch: '<S115>/Switch3' */

  /* MATLAB Function: '<S115>/g_aucFLOW_BI_FOOT_VALVE_MAX2' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_VALVE_MAX = g_aucFLOW_BI2_FOOT_VALVE_MAX(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX = g_aucFLOW_BI2_FOOT_VALVE_MAX[tmp - 1];

  /* End of MATLAB Function: '<S115>/g_aucFLOW_BI_FOOT_VALVE_MAX2' */

  /* MATLAB Function: '<S115>/g_aucFLOW_BI_FOOT_VALVE_MIN2' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_FOOT_VALVE_MIN = g_aucFLOW_BI2_FOOT_VALVE_MIN(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN_l = g_aucFLOW_BI2_FOOT_VALVE_MIN[tmp - 1];

  /* End of MATLAB Function: '<S115>/g_aucFLOW_BI_FOOT_VALVE_MIN2' */

  /* MATLAB Function: '<S116>/g_assFLOW_BI_AMB_TGT' */
  /* :  c_g_aucFLOW_BI2_VENT_PLUS = g_aucFLOW_BI2_VENT_PLUS(LVL + 1); */
  g_assFLOW_BI_AMB_TGT_e(rtu_LVL, &rtb_u_abl);

  /* MATLAB Function: '<S116>/g_aucFLOW_BI_VENT_PLUS' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* Gain: '<S116>/Gain2' incorporates:
   *  Sum: '<S116>/deg'
   */
  tmp = (int16_t)(rtb_u_abl - rtu_Amb_Fb) * 13107;

  /* Product: '<S116>/Умножили' incorporates:
   *  Gain: '<S116>/Gain'
   *  Gain: '<S116>/Gain2'
   *  MATLAB Function: '<S116>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_abl = (int16_t)((int8_t)(((((uint32_t)tmp & 65536U) != 0U) &&
    ((((uint32_t)tmp & 65535U) != 0U) || (tmp > 0))) + (tmp >> 17)) * (int32_t)
                        ((g_aucFLOW_BI2_VENT_PLUS[tmp_0 - 1] * 205U + 1024U) >>
    11));

  /* DataTypeConversion: '<S116>/Data Type Conversion' incorporates:
   *  Sum: '<S116>/ '
   *  Switch: '<S132>/Switch2'
   */
  rtb_Switch2_i_idx_0 = (uint16_t)((uint16_t)((rty_Out1[0] - rtb_u_abl) >> 1) <<
    1);
  rtb_Switch2_i_idx_1 = (uint16_t)((uint16_t)((rty_Out1[1] - rtb_u_abl) >> 1) <<
    1);

  /* MATLAB Function: '<S116>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_VENT_VALVE_MAX = g_aucFLOW_BI2_VENT_VALVE_MAX(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX_k = g_aucFLOW_BI2_VENT_VALVE_MAX[tmp_0 - 1];

  /* End of MATLAB Function: '<S116>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S116>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_VENT_VALVE_MIN = g_aucFLOW_BI2_VENT_VALVE_MIN(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN_f = g_aucFLOW_BI2_VENT_VALVE_MIN[tmp_0 - 1];

  /* End of MATLAB Function: '<S116>/g_aucFLOW_BI_VENT_VALVE_MIN' */

  /* MATLAB Function: '<S117>/g_assFLOW_BI_AMB_TGT' */
  /* :  c_g_aucFLOW_BI2_VENT_PLUS = g_aucFLOW_BI2_VENT_PLUS(LVL + 1 + 6); */
  g_assFLOW_BI_AMB_TGT_e(rtu_LVL, &rtb_u_abl);

  /* MATLAB Function: '<S117>/g_aucFLOW_BI_VENT_PLUS' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  /* Gain: '<S117>/Gain2' incorporates:
   *  Sum: '<S117>/deg'
   */
  tmp_0 = (int16_t)(rtb_u_abl - rtu_Amb_Fb) * 13107;

  /* Product: '<S117>/Умножили' incorporates:
   *  Gain: '<S117>/Gain'
   *  Gain: '<S117>/Gain2'
   *  MATLAB Function: '<S117>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_abl = (int16_t)((int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) &&
    ((((uint32_t)tmp_0 & 65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17)) *
                        (int32_t)((g_aucFLOW_BI2_VENT_PLUS[tmp - 1] * 205U +
    1024U) >> 11));

  /* MATLAB Function: '<S117>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_VENT_VALVE_MAX = g_aucFLOW_BI2_VENT_VALVE_MAX(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX = g_aucFLOW_BI2_VENT_VALVE_MAX[tmp - 1];

  /* End of MATLAB Function: '<S117>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S117>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S119>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_BI2_VENT_VALVE_MIN = g_aucFLOW_BI2_VENT_VALVE_MIN(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN = g_aucFLOW_BI2_VENT_VALVE_MIN[tmp - 1];

  /* End of MATLAB Function: '<S117>/g_aucFLOW_BI_VENT_VALVE_MIN' */

  /* DataTypeConversion: '<S117>/Data Type Conversion' incorporates:
   *  Sum: '<S117>/ '
   *  Switch: '<S137>/Switch2'
   */
  rtb_Switch2_p_0 = (uint16_t)((uint16_t)((rty_Out1[0] - rtb_u_abl) >> 1) << 1);

  /* Switch: '<S132>/Switch2' incorporates:
   *  RelationalOperator: '<S132>/LowerRelop1'
   *  RelationalOperator: '<S132>/UpperRelop'
   *  Switch: '<S132>/Switch'
   */
  if (rtb_Switch2_i_idx_0 > rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX_k) {
    /* Assignment: '<S36>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[0] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX_k;
  } else if (rtb_Switch2_i_idx_0 < rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN_f) {
    /* Switch: '<S132>/Switch' incorporates:
     *  Assignment: '<S36>/Присваивание в [1-2]'
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[0] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN_f;
  } else {
    /* Assignment: '<S36>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     *  Switch: '<S132>/Switch'
     */
    rty_Out1[0] = rtb_Switch2_i_idx_0;
  }

  /* Switch: '<S137>/Switch2' incorporates:
   *  RelationalOperator: '<S137>/LowerRelop1'
   *  RelationalOperator: '<S137>/UpperRelop'
   *  Switch: '<S137>/Switch'
   */
  if (rtb_Switch2_p_0 > rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX) {
    /* Assignment: '<S36>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[2] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX;
  } else if (rtb_Switch2_p_0 < rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN) {
    /* Switch: '<S137>/Switch' incorporates:
     *  Assignment: '<S36>/Присваивание в [3-4]'
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[2] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN;
  } else {
    /* Assignment: '<S36>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     *  Switch: '<S137>/Switch'
     */
    rty_Out1[2] = rtb_Switch2_p_0;
  }

  /* DataTypeConversion: '<S117>/Data Type Conversion' incorporates:
   *  Sum: '<S117>/ '
   *  Switch: '<S137>/Switch2'
   */
  rtb_Switch2_p_0 = (uint16_t)((uint16_t)((rty_Out1[1] - rtb_u_abl) >> 1) << 1);

  /* Switch: '<S132>/Switch2' incorporates:
   *  RelationalOperator: '<S132>/LowerRelop1'
   *  RelationalOperator: '<S132>/UpperRelop'
   *  Switch: '<S132>/Switch'
   */
  if (rtb_Switch2_i_idx_1 > rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX_k) {
    /* Assignment: '<S36>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[1] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX_k;
  } else if (rtb_Switch2_i_idx_1 < rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN_f) {
    /* Switch: '<S132>/Switch' incorporates:
     *  Assignment: '<S36>/Присваивание в [1-2]'
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[1] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN_f;
  } else {
    /* Assignment: '<S36>/Присваивание в [1-2]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     *  Switch: '<S132>/Switch'
     */
    rty_Out1[1] = rtb_Switch2_i_idx_1;
  }

  /* Switch: '<S137>/Switch2' incorporates:
   *  RelationalOperator: '<S137>/LowerRelop1'
   *  RelationalOperator: '<S137>/UpperRelop'
   *  Switch: '<S137>/Switch'
   */
  if (rtb_Switch2_p_0 > rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX) {
    /* Assignment: '<S36>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[3] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MAX;
  } else if (rtb_Switch2_p_0 < rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN) {
    /* Switch: '<S137>/Switch' incorporates:
     *  Assignment: '<S36>/Присваивание в [3-4]'
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[3] = rtb_c_g_aucFLOW_BI2_VENT_VALVE_MIN;
  } else {
    /* Assignment: '<S36>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     *  Switch: '<S137>/Switch'
     */
    rty_Out1[3] = rtb_Switch2_p_0;
  }

  /* Switch: '<S118>/Switch2' incorporates:
   *  RelationalOperator: '<S118>/LowerRelop1'
   *  RelationalOperator: '<S118>/UpperRelop'
   *  Switch: '<S118>/Switch'
   */
  if (rtb_FLF_NEW > rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX_l) {
    /* Assignment: '<S36>/Присваивание в [5]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[4] = rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX_l;
  } else if (rtb_FLF_NEW < rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN) {
    /* Switch: '<S118>/Switch' incorporates:
     *  Assignment: '<S36>/Присваивание в [5]'
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[4] = rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN;
  } else {
    /* Assignment: '<S36>/Присваивание в [5]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     *  Switch: '<S118>/Switch'
     */
    rty_Out1[4] = rtb_FLF_NEW;
  }

  /* End of Switch: '<S118>/Switch2' */

  /* Switch: '<S125>/Switch2' incorporates:
   *  RelationalOperator: '<S125>/LowerRelop1'
   *  RelationalOperator: '<S125>/UpperRelop'
   *  Switch: '<S125>/Switch'
   */
  if (rtb_FRF_NEW > rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX) {
    /* Assignment: '<S36>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[6] = rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MAX;
  } else if (rtb_FRF_NEW < rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN_l) {
    /* Switch: '<S125>/Switch' incorporates:
     *  Assignment: '<S36>/Присваивание в [7]'
     *  SignalConversion generated from: '<S36>/Out1'
     */
    rty_Out1[6] = rtb_c_g_aucFLOW_BI2_FOOT_VALVE_MIN_l;
  } else {
    /* Assignment: '<S36>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S36>/Out1'
     *  Switch: '<S125>/Switch'
     */
    rty_Out1[6] = rtb_FRF_NEW;
  }

  /* End of Switch: '<S125>/Switch2' */
}

/*
 * Output and update for atomic system:
 *    '<S38>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S39>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S147>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S148>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 */
void g_aucFLOW_AF_FOOT_VALVE_MAX_e(uint8_t rtu_LVL, uint8_t
  *rty_c_g_aucFLOW_AF_FOOT_VALVE_MAX)
{
  int32_t tmp;

  /* :  c_g_aucFLOW_AF_FOOT_VALVE_MAX = g_aucFLOW_AF_FOOT_VALVE_MAX(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_c_g_aucFLOW_AF_FOOT_VALVE_MAX = g_aucFLOW_AF_FOOT_VALVE_MAX[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S40>/g_assFLOW_AF_AMB_TGT'
 *    '<S41>/g_assFLOW_AF_AMB_TGT'
 *    '<S65>/g_assFLOW_AF_AMB_TGT'
 *    '<S149>/g_assFLOW_AF_AMB_TGT'
 *    '<S150>/g_assFLOW_AF_AMB_TGT'
 *    '<S174>/g_assFLOW_AF_AMB_TGT'
 */
void g_assFLOW_AF_AMB_TGT_g(uint8_t rtu_LVL, int16_t *rty_c_g_assFLOW_AF_AMB_TGT)
{
  int32_t tmp;

  /* :  c_g_assFLOW_AF_AMB_TGT = g_assFLOW_AF_AMB_TGT(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_c_g_assFLOW_AF_AMB_TGT = g_assFLOW_AF_AMB_TGT[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S29>/Afoot'
 *    '<S30>/Afoot'
 */
void Afoot(int16_t rtu_Amb_Fb, uint8_t rtu_LVL, uint16_t rty_Out1[9], uint8_t
           rtu_setTempFL, uint8_t rtu_setTempFR)
{
  int32_t i;
  int32_t tmp_0;
  uint32_t qY;
  int16_t tmp[78];
  int16_t rtb_deg_en;
  uint16_t rtb_FLF_NEW;
  uint16_t rtb_FRF_NEW;
  uint16_t rtb_Switch2_ar_idx_0;
  uint16_t rtb_Switch2_ar_idx_1;
  uint16_t rtb_Switch2_j_idx_0;
  uint16_t rtb_Switch2_j_idx_1;
  int8_t rtb_X;
  uint8_t rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX;
  uint8_t rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k;

  /* MATLAB Function: '<S43>/get_tg_for_LVL' */
  /* :  c_g_aucFLOW_AF_BLR_AF_TGT = g_aucFLOW_AF_BLR_AF_TGT(LVL + 1); */
  /* :  table = [ */
  /* :          g_assVTG_FL_LV0; */
  /* :          g_assVTG_FL_LV1; */
  /* :          g_assVTG_FL_LV2; */
  /* :          g_assVTG_FL_LV3; */
  /* :          g_assVTG_FL_LV4; */
  /* :          g_assVTG_FL_LV5 */
  /* :      ]; */
  /* :  vals = table(ambient_Lvl + 1, set_tmp - 16); */
  for (i = 0; i < 13; i++) {
    tmp[6 * i] = g_assVTG_FL_LV0[i];
    tmp[6 * i + 1] = g_assVTG_FL_LV1[i];
    tmp[6 * i + 2] = g_assVTG_FL_LV2[i];
    tmp[6 * i + 3] = g_assVTG_FL_LV3[i];
    tmp[6 * i + 4] = g_assVTG_FL_LV4[i];
    tmp[6 * i + 5] = g_assVTG_FL_LV5[i];
  }

  /* MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT' */
  i = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    i = 255;
  }

  /* MATLAB Function: '<S43>/get_tg_for_LVL' incorporates:
   *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
  qY = rtu_setTempFL - 16U;

  /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
  if (rtu_setTempFL - 16U > rtu_setTempFL) {
    qY = 0U;
  }

  /* Gain: '<S43>/Gain6' incorporates:
   *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   *  MATLAB Function: '<S43>/get_tg_for_LVL'
   *  Sum: '<S43>/ 1'
   */
  i = (int16_t)(g_aucFLOW_AF_BLR_AF_TGT[i - 1] - tmp[(((int32_t)qY - 1) * 6 +
    tmp_0) - 1]) * 13107;
  rtb_X = (int8_t)(((((uint32_t)i & 65536U) != 0U) && ((((uint32_t)i & 65535U)
    != 0U) || (i > 0))) + (i >> 17));

  /* Switch: '<S38>/Switch1' incorporates:
   *  Gain: '<S38>/Gain6'
   *  Sum: '<S38>/Add'
   */
  /* :  c_g_aucFLOW_AF_FOOT_PLUS = g_aucFLOW_AF_FOOT_PLUS(LVL + 1); */
  if (rtb_X >= 0) {
    rtb_FLF_NEW = rty_Out1[4];
  } else {
    /* MATLAB Function: '<S38>/g_aucFLOW_AF_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    i = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      i = 255;
    }

    /* Gain: '<S38>/Gain6' incorporates:
     *  MATLAB Function: '<S38>/g_aucFLOW_AF_FOOT_PLUS'
     *  Product: '<S38>/Product3'
     */
    i = g_aucFLOW_AF_FOOT_PLUS[i - 1] * rtb_X * 13107;
    rtb_FLF_NEW = (uint16_t)((int16_t)rty_Out1[4] - (int8_t)(((((uint32_t)i &
      65536U) != 0U) && (((uint32_t)i & 65535U) != 0U)) + (i >> 17)));
  }

  /* End of Switch: '<S38>/Switch1' */

  /* MATLAB Function: '<S38>/g_aucFLOW_AF_FOOT_VALVE_MAX' */
  g_aucFLOW_AF_FOOT_VALVE_MAX_e(rtu_LVL, &rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX);

  /* Switch: '<S42>/Switch2' incorporates:
   *  RelationalOperator: '<S42>/LowerRelop1'
   */
  if (rtb_FLF_NEW > rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX) {
    rtb_FLF_NEW = rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX;
  }

  /* End of Switch: '<S42>/Switch2' */

  /* MATLAB Function: '<S49>/get_vtg_for_LVL' */
  /* :  c_g_aucFLOW_AF_BLR_AF_TGT = g_aucFLOW_AF_BLR_AF_TGT(LVL + 1); */
  /* :  table = [ */
  /* :          g_assVTG_FR_LV0; */
  /* :          g_assVTG_FR_LV1; */
  /* :          g_assVTG_FR_LV2; */
  /* :          g_assVTG_FR_LV3; */
  /* :          g_assVTG_FR_LV4; */
  /* :          g_assVTG_FR_LV5 */
  /* :      ]; */
  /* :  vals = table(ambient_Lvl + 1, set_tmp - 16); */
  for (i = 0; i < 13; i++) {
    tmp[6 * i] = g_assVTG_FR_LV0[i];
    tmp[6 * i + 1] = g_assVTG_FR_LV1[i];
    tmp[6 * i + 2] = g_assVTG_FR_LV2[i];
    tmp[6 * i + 3] = g_assVTG_FR_LV3[i];
    tmp[6 * i + 4] = g_assVTG_FR_LV4[i];
    tmp[6 * i + 5] = g_assVTG_FR_LV5[i];
  }

  /* MATLAB Function: '<S49>/g_aucFLOW_AF_BLR_AF_TGT' incorporates:
   *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  i = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    i = 255;
  }

  /* MATLAB Function: '<S49>/get_vtg_for_LVL' incorporates:
   *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  qY = rtu_setTempFR - 16U;
  if (rtu_setTempFR - 16U > rtu_setTempFR) {
    qY = 0U;
  }

  /* Sum: '<S49>/ 1' incorporates:
   *  MATLAB Function: '<S49>/g_aucFLOW_AF_BLR_AF_TGT'
   *  MATLAB Function: '<S49>/get_vtg_for_LVL'
   */
  rtb_deg_en = (int16_t)(g_aucFLOW_AF_BLR_AF_TGT[i - 1] - tmp[(((int32_t)qY - 1)
    * 6 + tmp_0) - 1]);

  /* Gain: '<S49>/Gain6' */
  i = 13107 * rtb_deg_en;
  rtb_X = (int8_t)(((((uint32_t)i & 65536U) != 0U) && ((((uint32_t)i & 65535U)
    != 0U) || (i > 0))) + (i >> 17));

  /* Switch: '<S39>/Switch3' incorporates:
   *  Gain: '<S39>/Gain7'
   *  Sum: '<S39>/Add1'
   */
  /* :  c_g_aucFLOW_AF_FOOT_PLUS = g_aucFLOW_AF_FOOT_PLUS(LVL + 1 + 6); */
  if (rtb_X >= 0) {
    rtb_FRF_NEW = rty_Out1[6];
  } else {
    /* MATLAB Function: '<S39>/g_aucFLOW_AF_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    i = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      i = 255;
    }

    tmp_0 = (int32_t)((uint32_t)i + 6U);
    if ((uint32_t)i + 6U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S39>/Gain7' incorporates:
     *  MATLAB Function: '<S39>/g_aucFLOW_AF_FOOT_PLUS'
     *  Product: '<S39>/Product4'
     */
    i = g_aucFLOW_AF_FOOT_PLUS[tmp_0 - 1] * rtb_X * 13107;
    rtb_FRF_NEW = (uint16_t)((int16_t)rty_Out1[6] - (int8_t)(((((uint32_t)i &
      65536U) != 0U) && (((uint32_t)i & 65535U) != 0U)) + (i >> 17)));
  }

  /* End of Switch: '<S39>/Switch3' */

  /* MATLAB Function: '<S39>/g_aucFLOW_AF_FOOT_VALVE_MAX' */
  g_aucFLOW_AF_FOOT_VALVE_MAX_e(rtu_LVL, &rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX);

  /* MATLAB Function: '<S40>/g_assFLOW_AF_AMB_TGT' */
  /* :  c_g_aucFLOW_AF_VENT_PLUS = g_aucFLOW_AF_VENT_PLUS(LVL + 1); */
  g_assFLOW_AF_AMB_TGT_g(rtu_LVL, &rtb_deg_en);

  /* Sum: '<S40>/deg' */
  rtb_deg_en -= rtu_Amb_Fb;

  /* Gain: '<S40>/Gain2' */
  i = 13107 * rtb_deg_en;
  rtb_X = (int8_t)(((((uint32_t)i & 65536U) != 0U) && ((((uint32_t)i & 65535U)
    != 0U) || (i > 0))) + (i >> 17));

  /* Switch: '<S40>/if (deg < 0)' incorporates:
   *  Sum: '<S40>/ '
   *  Switch: '<S54>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_ar_idx_0 = rty_Out1[0];
    rtb_Switch2_ar_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S40>/g_aucFLOW_AF_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    i = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      i = 255;
    }

    /* Product: '<S40>/Умножили' incorporates:
     *  Gain: '<S40>/Gain'
     *  MATLAB Function: '<S40>/g_aucFLOW_AF_VENT_PLUS'
     */
    rtb_deg_en = (int16_t)((int32_t)((g_aucFLOW_AF_VENT_PLUS[i - 1] * 205U +
      1024U) >> 11) * rtb_X);
    rtb_Switch2_ar_idx_0 = (uint16_t)(rty_Out1[0] - rtb_deg_en);
    rtb_Switch2_ar_idx_1 = (uint16_t)(rty_Out1[1] - rtb_deg_en);
  }

  /* End of Switch: '<S40>/if (deg < 0)' */

  /* MATLAB Function: '<S40>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_AF_VENT_VALVE_MAX = g_aucFLOW_AF_VENT_VALVE_MAX(LVL + 1); */
  i = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    i = 255;
  }

  rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k = g_aucFLOW_AF_VENT_VALVE_MAX[i - 1];

  /* End of MATLAB Function: '<S40>/g_aucFLOW_AF_VENT_VALVE_MAX' */

  /* Switch: '<S54>/Switch2' incorporates:
   *  RelationalOperator: '<S54>/LowerRelop1'
   */
  if (rtb_Switch2_ar_idx_0 > rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k) {
    rtb_Switch2_ar_idx_0 = rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k;
  }

  if (rtb_Switch2_ar_idx_1 > rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k) {
    rtb_Switch2_ar_idx_1 = rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k;
  }

  /* End of Switch: '<S54>/Switch2' */

  /* MATLAB Function: '<S41>/g_assFLOW_AF_AMB_TGT' */
  /* :  c_g_aucFLOW_AF_VENT_PLUS = g_aucFLOW_AF_VENT_PLUS(LVL + 1 + 6); */
  g_assFLOW_AF_AMB_TGT_g(rtu_LVL, &rtb_deg_en);

  /* Gain: '<S41>/Gain2' incorporates:
   *  Sum: '<S41>/deg'
   */
  i = (int16_t)(rtb_deg_en - rtu_Amb_Fb) * 13107;
  rtb_X = (int8_t)(((((uint32_t)i & 65536U) != 0U) && ((((uint32_t)i & 65535U)
    != 0U) || (i > 0))) + (i >> 17));

  /* Switch: '<S41>/if (deg < 0)' incorporates:
   *  DataTypeConversion: '<S41>/Data Type Conversion'
   *  Sum: '<S41>/ '
   *  Switch: '<S58>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_j_idx_0 = rty_Out1[0];
    rtb_Switch2_j_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S41>/g_aucFLOW_AF_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    i = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      i = 255;
    }

    tmp_0 = (int32_t)((uint32_t)i + 6U);
    if ((uint32_t)i + 6U > 255U) {
      tmp_0 = 255;
    }

    /* Product: '<S41>/Умножили' incorporates:
     *  Gain: '<S41>/Gain'
     *  MATLAB Function: '<S41>/g_aucFLOW_AF_VENT_PLUS'
     */
    rtb_deg_en = (int16_t)((int32_t)((g_aucFLOW_AF_VENT_PLUS[tmp_0 - 1] * 205U +
      1024U) >> 11) * rtb_X);
    rtb_Switch2_j_idx_0 = (uint16_t)((int16_t)rty_Out1[0] - rtb_deg_en);
    rtb_Switch2_j_idx_1 = (uint16_t)((int16_t)rty_Out1[1] - rtb_deg_en);
  }

  /* End of Switch: '<S41>/if (deg < 0)' */

  /* MATLAB Function: '<S41>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S43>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_AF_VENT_VALVE_MAX = g_aucFLOW_AF_VENT_VALVE_MAX(LVL + 1 + 6); */
  i = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    i = 255;
  }

  tmp_0 = (int32_t)((uint32_t)i + 6U);
  if ((uint32_t)i + 6U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k = g_aucFLOW_AF_VENT_VALVE_MAX[tmp_0 - 1];

  /* End of MATLAB Function: '<S41>/g_aucFLOW_AF_VENT_VALVE_MAX' */

  /* Assignment: '<S33>/Присваивание в [1-2]' incorporates:
   *  SignalConversion generated from: '<S33>/Out1'
   *  Switch: '<S54>/Switch2'
   */
  rty_Out1[0] = rtb_Switch2_ar_idx_0;

  /* Switch: '<S58>/Switch2' incorporates:
   *  RelationalOperator: '<S58>/LowerRelop1'
   */
  if (rtb_Switch2_j_idx_0 > rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k) {
    /* Assignment: '<S33>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S33>/Out1'
     */
    rty_Out1[2] = rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k;
  } else {
    /* Assignment: '<S33>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S33>/Out1'
     */
    rty_Out1[2] = rtb_Switch2_j_idx_0;
  }

  /* Assignment: '<S33>/Присваивание в [1-2]' incorporates:
   *  SignalConversion generated from: '<S33>/Out1'
   *  Switch: '<S54>/Switch2'
   */
  rty_Out1[1] = rtb_Switch2_ar_idx_1;

  /* Switch: '<S58>/Switch2' incorporates:
   *  RelationalOperator: '<S58>/LowerRelop1'
   */
  if (rtb_Switch2_j_idx_1 > rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k) {
    /* Assignment: '<S33>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S33>/Out1'
     */
    rty_Out1[3] = rtb_c_g_aucFLOW_AF_VENT_VALVE_MAX_k;
  } else {
    /* Assignment: '<S33>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S33>/Out1'
     */
    rty_Out1[3] = rtb_Switch2_j_idx_1;
  }

  /* Assignment: '<S33>/Присваивание в [5]' incorporates:
   *  SignalConversion generated from: '<S33>/Out1'
   */
  rty_Out1[4] = rtb_FLF_NEW;

  /* Switch: '<S48>/Switch2' incorporates:
   *  RelationalOperator: '<S48>/LowerRelop1'
   */
  if (rtb_FRF_NEW > rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX) {
    /* Assignment: '<S33>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S33>/Out1'
     */
    rty_Out1[6] = rtb_c_g_aucFLOW_AF_FOOT_VALVE_MAX;
  } else {
    /* Assignment: '<S33>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S33>/Out1'
     *  Switch: '<S48>/Switch'
     */
    rty_Out1[6] = rtb_FRF_NEW;
  }

  /* End of Switch: '<S48>/Switch2' */
}

/*
 * Output and update for atomic system:
 *    '<S62>/g_aucFLOW_AFSM_FOOT_VALVE_MAX'
 *    '<S63>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S171>/g_aucFLOW_AFSM_FOOT_VALVE_MAX'
 *    '<S172>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 */
void g_aucFLOW_AFSM_FOOT_VALVE_MAX_f(uint8_t rtu_LVL, uint8_t
  *rty_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX)
{
  int32_t tmp;

  /* :  c_g_aucFLOW_AFSM_FOOT_VALVE_MAX = g_aucFLOW_AFSM_FOOT_VALVE_MAX(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX = g_aucFLOW_AFSM_FOOT_VALVE_MAX[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S29>/Afoot_Summer'
 *    '<S30>/Afoot_Summer'
 */
void Afoot_Summer(int16_t rtu_Amb_Fb, uint8_t rtu_LVL, uint16_t rty_Out1[9],
                  uint8_t rtu_setTempFL, uint8_t rtu_setTempFR)
{
  int32_t tmp;
  int32_t tmp_0;
  int16_t rtb_deg_c;
  uint16_t rtb_FLF_NEW;
  uint16_t rtb_FRF_NEW;
  uint16_t rtb_Switch2_j1_idx_0;
  uint16_t rtb_Switch2_j1_idx_1;
  uint16_t rtb_Switch2_l_idx_0;
  uint16_t rtb_Switch2_l_idx_1;
  int8_t rtb_X;
  uint8_t rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX;
  uint8_t rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g;

  /* MATLAB Function: '<S67>/get_tg_for_LVL' */
  /* :  c_g_assFLOW_AFSM_TEMP_TGT = g_assFLOW_AFSM_TEMP_TGT(LVL + 1); */
  get_tg_FLL_for_LVL(rtu_LVL, rtu_setTempFL, &rtb_deg_c);

  /* MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT' */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* Sum: '<S67>/ 1' incorporates:
   *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
   */
  rtb_deg_c = (int16_t)(g_assFLOW_AFSM_TEMP_TGT[tmp_0 - 1] - rtb_deg_c);

  /* Gain: '<S67>/Gain6' */
  tmp_0 = 13107 * rtb_deg_c;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S62>/Switch1' incorporates:
   *  Gain: '<S62>/Gain6'
   *  Sum: '<S62>/Add'
   */
  /* :  c_g_aucFLOW_AFSM_FOOT_PLUS = g_aucFLOW_AFSM_FOOT_PLUS(LVL + 1); */
  if (rtb_X >= 0) {
    rtb_FLF_NEW = rty_Out1[4];
  } else {
    /* MATLAB Function: '<S62>/g_aucFLOW_AFSM_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S62>/Gain6' incorporates:
     *  MATLAB Function: '<S62>/g_aucFLOW_AFSM_FOOT_PLUS'
     *  Product: '<S62>/Product3'
     */
    tmp_0 = g_aucFLOW_AFSM_FOOT_PLUS[tmp_0 - 1] * rtb_X * 13107;
    rtb_FLF_NEW = (uint16_t)((int16_t)rty_Out1[4] - (int8_t)(((((uint32_t)tmp_0
      & 65536U) != 0U) && (((uint32_t)tmp_0 & 65535U) != 0U)) + (tmp_0 >> 17)));
  }

  /* End of Switch: '<S62>/Switch1' */

  /* MATLAB Function: '<S62>/g_aucFLOW_AFSM_FOOT_VALVE_MAX' */
  g_aucFLOW_AFSM_FOOT_VALVE_MAX_f(rtu_LVL, &rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX);

  /* Switch: '<S66>/Switch2' incorporates:
   *  RelationalOperator: '<S66>/LowerRelop1'
   */
  if (rtb_FLF_NEW > rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX) {
    rtb_FLF_NEW = rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX;
  }

  /* End of Switch: '<S66>/Switch2' */

  /* MATLAB Function: '<S73>/get_tg_FLL_for_LVL' */
  /* :  c_g_assFLOW_AFSM_TEMP_TGT = g_assFLOW_AFSM_TEMP_TGT(LVL + 1 + 6); */
  get_tg_FLL_for_LVL_j(rtu_LVL, rtu_setTempFR, &rtb_deg_c);

  /* MATLAB Function: '<S73>/g_assFLOW_AFSM_TEMP_TGT' incorporates:
   *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
   */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  /* Gain: '<S73>/Gain6' incorporates:
   *  MATLAB Function: '<S73>/g_assFLOW_AFSM_TEMP_TGT'
   *  Sum: '<S73>/ 1'
   */
  tmp_0 = (int16_t)(g_assFLOW_AFSM_TEMP_TGT[tmp - 1] - rtb_deg_c) * 13107;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S63>/Switch3' incorporates:
   *  Gain: '<S63>/Gain7'
   *  Sum: '<S63>/Add1'
   */
  /* :  c_g_aucFLOW_AFSM_FOOT_PLUS = g_aucFLOW_AFSM_FOOT_PLUS(LVL + 1 + 6); */
  if (rtb_X >= 0) {
    rtb_FRF_NEW = rty_Out1[6];
  } else {
    /* MATLAB Function: '<S63>/g_aucFLOW_AFSM_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    tmp = (int32_t)((uint32_t)tmp_0 + 6U);
    if ((uint32_t)tmp_0 + 6U > 255U) {
      tmp = 255;
    }

    /* Gain: '<S63>/Gain7' incorporates:
     *  MATLAB Function: '<S63>/g_aucFLOW_AFSM_FOOT_PLUS'
     *  Product: '<S63>/Product4'
     */
    tmp_0 = g_aucFLOW_AFSM_FOOT_PLUS[tmp - 1] * rtb_X * 13107;
    rtb_FRF_NEW = (uint16_t)((int16_t)rty_Out1[6] - (int8_t)(((((uint32_t)tmp_0
      & 65536U) != 0U) && (((uint32_t)tmp_0 & 65535U) != 0U)) + (tmp_0 >> 17)));
  }

  /* End of Switch: '<S63>/Switch3' */

  /* MATLAB Function: '<S63>/g_aucFLOW_AF_FOOT_VALVE_MAX' */
  g_aucFLOW_AFSM_FOOT_VALVE_MAX_f(rtu_LVL, &rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX);

  /* MATLAB Function: '<S64>/g_assFLOW_AFSM_AMB_TGT' incorporates:
   *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_AFSM_VENT_PLUS = g_aucFLOW_AFSM_VENT_PLUS(LVL + 1); */
  /* :  c_g_assFLOW_AFSM_AMB_TGT = g_assFLOW_AFSM_AMB_TGT(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  /* Sum: '<S64>/deg' incorporates:
   *  MATLAB Function: '<S64>/g_assFLOW_AFSM_AMB_TGT'
   */
  rtb_deg_c = (int16_t)(g_assFLOW_AFSM_AMB_TGT[tmp_0 - 1] - rtu_Amb_Fb);

  /* Gain: '<S64>/Gain2' */
  tmp_0 = 13107 * rtb_deg_c;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S64>/if (deg < 0)' incorporates:
   *  Sum: '<S64>/ '
   *  Switch: '<S78>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_l_idx_0 = rty_Out1[0];
    rtb_Switch2_l_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S64>/g_aucFLOW_AFSM_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Product: '<S64>/Умножили' incorporates:
     *  Gain: '<S64>/Gain'
     *  MATLAB Function: '<S64>/g_aucFLOW_AFSM_VENT_PLUS'
     */
    rtb_deg_c = (int16_t)((int32_t)((g_aucFLOW_AFSM_VENT_PLUS[tmp_0 - 1] * 205U
      + 1024U) >> 11) * rtb_X);
    rtb_Switch2_l_idx_0 = (uint16_t)(rty_Out1[0] - rtb_deg_c);
    rtb_Switch2_l_idx_1 = (uint16_t)(rty_Out1[1] - rtb_deg_c);
  }

  /* End of Switch: '<S64>/if (deg < 0)' */

  /* MATLAB Function: '<S64>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_AFSM_VENT_VALVE_MAX = g_aucFLOW_AFSM_VENT_VALVE_MAX(LVL + 1); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g = g_aucFLOW_AFSM_VENT_VALVE_MAX[tmp_0 -
    1];

  /* End of MATLAB Function: '<S64>/g_aucFLOW_AF_VENT_VALVE_MAX' */

  /* Switch: '<S78>/Switch2' incorporates:
   *  RelationalOperator: '<S78>/LowerRelop1'
   */
  if (rtb_Switch2_l_idx_0 > rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g) {
    rtb_Switch2_l_idx_0 = rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g;
  }

  if (rtb_Switch2_l_idx_1 > rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g) {
    rtb_Switch2_l_idx_1 = rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g;
  }

  /* End of Switch: '<S78>/Switch2' */

  /* MATLAB Function: '<S65>/g_assFLOW_AF_AMB_TGT' */
  /* :  c_g_aucFLOW_AFSM_VENT_PLUS = g_aucFLOW_AFSM_VENT_PLUS(LVL + 1 + 6); */
  g_assFLOW_AF_AMB_TGT_g(rtu_LVL, &rtb_deg_c);

  /* Gain: '<S65>/Gain2' incorporates:
   *  Sum: '<S65>/deg'
   */
  tmp_0 = (int16_t)(rtb_deg_c - rtu_Amb_Fb) * 13107;
  rtb_X = (int8_t)(((((uint32_t)tmp_0 & 65536U) != 0U) && ((((uint32_t)tmp_0 &
    65535U) != 0U) || (tmp_0 > 0))) + (tmp_0 >> 17));

  /* Switch: '<S65>/if (deg < 0)' incorporates:
   *  DataTypeConversion: '<S65>/Data Type Conversion'
   *  Sum: '<S65>/ '
   *  Switch: '<S82>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_j1_idx_0 = rty_Out1[0];
    rtb_Switch2_j1_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S65>/g_aucFLOW_AF_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    tmp = (int32_t)((uint32_t)tmp_0 + 6U);
    if ((uint32_t)tmp_0 + 6U > 255U) {
      tmp = 255;
    }

    /* Product: '<S65>/Умножили' incorporates:
     *  Gain: '<S65>/Gain'
     *  MATLAB Function: '<S65>/g_aucFLOW_AF_VENT_PLUS'
     */
    rtb_deg_c = (int16_t)((int32_t)((g_aucFLOW_AFSM_VENT_PLUS[tmp - 1] * 205U +
      1024U) >> 11) * rtb_X);
    rtb_Switch2_j1_idx_0 = (uint16_t)((int16_t)rty_Out1[0] - rtb_deg_c);
    rtb_Switch2_j1_idx_1 = (uint16_t)((int16_t)rty_Out1[1] - rtb_deg_c);
  }

  /* End of Switch: '<S65>/if (deg < 0)' */

  /* MATLAB Function: '<S65>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S67>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
   */
  /* :  c_g_aucFLOW_AFSM_VENT_VALVE_MAX = g_aucFLOW_AFSM_VENT_VALVE_MAX(LVL + 1 + 6); */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g = g_aucFLOW_AFSM_VENT_VALVE_MAX[tmp - 1];

  /* End of MATLAB Function: '<S65>/g_aucFLOW_AF_VENT_VALVE_MAX' */

  /* Assignment: '<S34>/Присваивание в [1-2]' incorporates:
   *  SignalConversion generated from: '<S34>/Out1'
   *  Switch: '<S78>/Switch2'
   */
  rty_Out1[0] = rtb_Switch2_l_idx_0;

  /* Switch: '<S82>/Switch2' incorporates:
   *  RelationalOperator: '<S82>/LowerRelop1'
   */
  if (rtb_Switch2_j1_idx_0 > rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g) {
    /* Assignment: '<S34>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S34>/Out1'
     */
    rty_Out1[2] = rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g;
  } else {
    /* Assignment: '<S34>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S34>/Out1'
     */
    rty_Out1[2] = rtb_Switch2_j1_idx_0;
  }

  /* Assignment: '<S34>/Присваивание в [1-2]' incorporates:
   *  SignalConversion generated from: '<S34>/Out1'
   *  Switch: '<S78>/Switch2'
   */
  rty_Out1[1] = rtb_Switch2_l_idx_1;

  /* Switch: '<S82>/Switch2' incorporates:
   *  RelationalOperator: '<S82>/LowerRelop1'
   */
  if (rtb_Switch2_j1_idx_1 > rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g) {
    /* Assignment: '<S34>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S34>/Out1'
     */
    rty_Out1[3] = rtb_c_g_aucFLOW_AFSM_VENT_VALVE_MAX_g;
  } else {
    /* Assignment: '<S34>/Присваивание в [3-4]' incorporates:
     *  SignalConversion generated from: '<S34>/Out1'
     */
    rty_Out1[3] = rtb_Switch2_j1_idx_1;
  }

  /* Assignment: '<S34>/Присваивание в [5]' incorporates:
   *  SignalConversion generated from: '<S34>/Out1'
   */
  rty_Out1[4] = rtb_FLF_NEW;

  /* Switch: '<S72>/Switch2' incorporates:
   *  RelationalOperator: '<S72>/LowerRelop1'
   */
  if (rtb_FRF_NEW > rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX) {
    /* Assignment: '<S34>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S34>/Out1'
     */
    rty_Out1[6] = rtb_c_g_aucFLOW_AFSM_FOOT_VALVE_MAX;
  } else {
    /* Assignment: '<S34>/Присваивание в [7]' incorporates:
     *  SignalConversion generated from: '<S34>/Out1'
     *  Switch: '<S72>/Switch'
     */
    rty_Out1[6] = rtb_FRF_NEW;
  }

  /* End of Switch: '<S72>/Switch2' */
}

double rt_roundd(double u)
{
  double y;
  if (fabs(u) < 4.503599627370496E+15) {
    if (u >= 0.5) {
      y = floor(u + 0.5);
    } else if (u > -0.5) {
      y = 0.0;
    } else {
      y = ceil(u - 0.5);
    }
  } else {
    y = u;
  }

  return y;
}

/*
 * Output and update for atomic system:
 *    '<S9>/Начальные положения заслонок left'
 *    '<S9>/Начальные положения заслонок right'
 */
void left(uint8_t rtu_idx, uint16_t rty_vals[9])
{
  int32_t i;
  int32_t rtu_idx_0;
  uint16_t tmp[45];

  /* :  table = [ */
  /* :          g_ausFLOW_FR_VE2VALVE; */
  /* :          g_ausFLOW_FR_BIVALVE; */
  /* :          g_ausFLOW_FR_BI2VALVE; */
  /* :          g_ausFLOW_FR_AF2VALVE; */
  /* :          g_ausFLOW_FR_AF2VALVE_SUMMER */
  /* :      ]; */
  /* :  idx = idx / 10; */
  /* :  vals = table(idx, :); */
  rtu_idx_0 = (int32_t)rt_roundd((double)rtu_idx / 10.0);
  for (i = 0; i < 9; i++) {
    tmp[5 * i] = g_ausFLOW_FR_VE2VALVE[i];
    tmp[5 * i + 1] = g_ausFLOW_FR_BIVALVE[i];
    tmp[5 * i + 2] = g_ausFLOW_FR_BI2VALVE[i];
    tmp[5 * i + 3] = g_ausFLOW_FR_AF2VALVE[i];
    tmp[5 * i + 4] = g_ausFLOW_FR_AF2VALVE_SUMMER[i];
    rty_vals[i] = tmp[(5 * i + rtu_idx_0) - 1];
  }
}

/*
 * Output and update for action system:
 *    '<S382>/Stop Mode'
 *    '<S383>/Stop Mode'
 */
void StopMode(int8_t rtu_stepIn, int8_t *rty_step, const uint8_t
              *rtd_Busy_private_a, uint8_t rtd_COM_private_h[9], const uint8_t
              *rtd_Error_Connect_private_f, uint8_t rtd_MODE_private_a[9])
{
  int32_t i;

  /* If: '<S452>/If1' incorporates:
   *  DataStoreRead: '<S452>/Data Store Read1'
   *  DataStoreRead: '<S452>/Data Store Read2'
   */
  if ((*rtd_Busy_private_a == 0) && (*rtd_Error_Connect_private_f == 0)) {
    /* Outputs for IfAction SubSystem: '<S452>/If Action Subsystem2' incorporates:
     *  ActionPort: '<S475>/Action Port'
     */
    for (i = 0; i < 9; i++) {
      /* DataStoreWrite: '<S475>/Data Store Write' */
      rtd_MODE_private_a[i] = 2U;

      /* DataStoreWrite: '<S475>/Data Store Write1' */
      rtd_COM_private_h[i] = 1U;
    }

    /* Sum: '<S475>/step inc' incorporates:
     *  Constant: '<S475>/Constant'
     */
    *rty_step = (int8_t)(rtu_stepIn + 1);

    /* End of Outputs for SubSystem: '<S452>/If Action Subsystem2' */
  } else {
    /* Outputs for IfAction SubSystem: '<S452>/If Action Subsystem3' incorporates:
     *  ActionPort: '<S476>/Action Port'
     */
    /* SignalConversion generated from: '<S476>/stepIn' */
    *rty_step = rtu_stepIn;

    /* End of Outputs for SubSystem: '<S452>/If Action Subsystem3' */
  }

  /* End of If: '<S452>/If1' */
}

/*
 * Output and update for atomic system:
 *    '<S524>/g_assSTART_ENTER_INCAR'
 *    '<S525>/g_assSTART_ENTER_INCAR'
 */
void g_assSTART_ENTER_INCAR_a(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;

  /* :  out = int16(g_assSTART_ENTER_INCAR(LVL+1)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_assSTART_ENTER_INCAR[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S519>/Level 3'
 *    '<S519>/Level 4'
 *    '<S519>/Level 5'
 */
void Level3(int8_t *rty_step1, const uint16_t *rtd_ECT, const uint8_t *rtd_LEVEL,
            const double *rtd_MODE_DRIVER)
{
  int32_t q0;
  uint32_t qY;

  /* MATLAB Function: '<S527>/g_assSTART_ENTER_COOLANT ' incorporates:
   *  DataStoreRead: '<S527>/Data Store Read3'
   */
  /* :  out = int16(g_assSTART_ENTER_COOLANT(LVL + 1 - 3)); */
  q0 = (int32_t)(*rtd_LEVEL + 1U);
  if (*rtd_LEVEL + 1U > 255U) {
    q0 = 255;
  }

  /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
  qY = (uint32_t)q0 - 3U;

  /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
  if ((uint32_t)q0 - 3U > (uint32_t)q0) {
    qY = 0U;
  }

  /* Switch: '<S527>/Switch' incorporates:
   *  Constant: '<S527>/AUTO'
   *  Constant: '<S527>/Constant'
   *  Constant: '<S527>/Constant1'
   *  DataStoreRead: '<S527>/Data Store Read'
   *  DataStoreRead: '<S527>/Data Store Read1'
   *  Logic: '<S527>/AND'
   *  MATLAB Function: '<S527>/g_assSTART_ENTER_COOLANT '
   *  RelationalOperator: '<S527>/Relational Operator'
   *  RelationalOperator: '<S527>/Relational Operator2'
   */
  if ((*rtd_ECT < g_assSTART_ENTER_COOLANT[(int32_t)qY - 1]) &&
      (*rtd_MODE_DRIVER == 1.0)) {
    *rty_step1 = 0;
  } else {
    *rty_step1 = -1;
  }

  /* End of Switch: '<S527>/Switch' */
}

/*
 * Output and update for action system:
 *    '<S520>/Level 0'
 *    '<S520>/Level 1'
 *    '<S520>/Level 2'
 *    '<S780>/Level 0'
 *    '<S780>/Level 1'
 */
void Level0(int8_t *rty_step)
{
  /* SignalConversion generated from: '<S537>/step' incorporates:
   *  Constant: '<S537>/Constant'
   */
  *rty_step = 1;
}

/*
 * Output and update for atomic system:
 *    '<S540>/incar filter down'
 *    '<S541>/incar filter down'
 *    '<S542>/incar filter down'
 *    '<S552>/incar filter down'
 *    '<S553>/incar filter down'
 *    '<S555>/incar filter down'
 *    '<S556>/incar filter down'
 *    '<S557>/incar filter down'
 *    '<S620>/incar filter down'
 *    '<S621>/incar filter down'
 *    ...
 */
void incarfilterdown(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_INCAR_FLT_DN(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_INCAR_FLT_DN[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S540>/incar filter up'
 *    '<S541>/incar filter up'
 *    '<S542>/incar filter up'
 *    '<S552>/incar filter up'
 *    '<S553>/incar filter up'
 *    '<S555>/incar filter up'
 *    '<S556>/incar filter up'
 *    '<S557>/incar filter up'
 *    '<S620>/incar filter up'
 *    '<S621>/incar filter up'
 *    ...
 */
void incarfilterup(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_INCAR_FLT_UP(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_INCAR_FLT_UP[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S541>/g_assSTART_COOLANT_STEP0_TO_1 '
 *    '<S542>/g_assSTART_COOLANT_STEP0_TO_1 '
 */
void g_assSTART_COOLANT_STEP0_TO_1_k(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t q0;
  uint32_t qY;

  /* :  out = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 1 - 2)); */
  q0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    q0 = 255;
  }

  /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
  qY = (uint32_t)q0 - 2U;

  /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
  if ((uint32_t)q0 - 2U > (uint32_t)q0) {
    qY = 0U;
  }

  *rty_out = g_assSTART_COOLANT_STEP0_TO_1[(int32_t)qY - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/3 way valve status'
 *    '<S553>/3 way valve status'
 *    '<S555>/3 way valve status'
 *    '<S556>/3 way valve status'
 *    '<S557>/3 way valve status'
 */
void uwayvalvestatus(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_3WAY_OPEN(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_3WAY_OPEN[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/Dtg_FrontLower_X'
 *    '<S553>/Dtg_FrontLower_X'
 *    '<S555>/Dtg_FrontLower_X'
 */
void Dtg_FrontLower_X(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_L(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_DUCT_TGT_STEP2_FX_L[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/Dtg_FrontUpper_X'
 *    '<S553>/Dtg_FrontUpper_X'
 *    '<S555>/Dtg_FrontUpper_X'
 */
void Dtg_FrontUpper_X(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_U(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_DUCT_TGT_STEP2_FX_U[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/Incar temp goto from step 1 to step 2 '
 *    '<S553>/Incar temp goto from step 1 to step 2 '
 *    '<S555>/Incar temp goto from step 1 to step 2 '
 *    '<S556>/Incar temp goto from step 1 to step 2 '
 *    '<S557>/Incar temp goto from step 1 to step 2 '
 */
void Incartempgotofromstep1tostep2(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;

  /* :  out = int16(g_assSTART_INCAR_STEP1_TO_2(LVL + 1)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_assSTART_INCAR_STEP1_TO_2[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/blower FR'
 *    '<S553>/blower FR'
 */
void blowerFR(uint8_t rtu_LVL, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_ausSTART_BLR_AF_STEP12_F(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausSTART_BLR_AF_STEP12_F[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/mode FR step 1'
 *    '<S553>/mode FR step 1'
 *    '<S555>/mode FR step 1'
 *    '<S556>/mode FR step 1'
 *    '<S557>/mode FR step 1'
 */
void modeFRstep1(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_VALVE_IDX_STEP1(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_VALVE_IDX_STEP1[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S552>/window heating'
 *    '<S553>/window heating'
 *    '<S555>/window heating'
 *    '<S556>/window heating'
 *    '<S557>/window heating'
 */
void windowheating(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_ELEC_WINDOW(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_ELEC_WINDOW[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S553>/Time goto from step 1 to step 2 '
 *    '<S555>/Time goto from step 1 to step 2 '
 *    '<S556>/Time goto from step 1 to step 2 '
 *    '<S557>/Time goto from step 1 to step 2 '
 */
void Timegotofromstep1tostep2(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;
  uint16_t tmp_0;

  /* :  out = int16(g_ausSTART_TIME_STEP1_TO_2(LVL + 1)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = g_ausSTART_TIME_STEP1_TO_2[tmp - 1];
  if (tmp_0 > 32767) {
    tmp_0 = 32767U;
  }

  *rty_out = (int16_t)tmp_0;
}

/*
 * Output and update for atomic system:
 *    '<S586>/ECT min max'
 *    '<S600>/ECT min max'
 *    '<S613>/ECT min max'
 */
void ECTminmax(uint8_t rtu_LVL, int16_t rty_out[2])
{
  int32_t q0;
  uint32_t qY;

  /* :  min = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 1 - 2)); */
  /* :  max = int16(g_assSTART_COOLANT_TO_STEP2(1)); */
  /* :  out = [min, max]; */
  q0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    q0 = 255;
  }

  /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
  qY = (uint32_t)q0 - 2U;

  /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
  if ((uint32_t)q0 - 2U > (uint32_t)q0) {
    qY = 0U;
  }

  rty_out[0] = g_assSTART_COOLANT_STEP0_TO_1[(int32_t)qY - 1];
  rty_out[1] = g_assSTART_COOLANT_TO_STEP2[0];
}

/*
 * Output and update for atomic system:
 *    '<S586>/blower min max'
 *    '<S600>/blower min max'
 *    '<S613>/blower min max'
 */
void blowerminmax(uint8_t rtu_LVL, uint16_t rty_out[2])
{
  int32_t tmp;

  /* :  min = 20; */
  /* :  max = g_ausSTART_BLR_AF_STEP12_F(LVL + 1); */
  /* :  out = [min, max]; */
  rty_out[0] = 20U;
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  rty_out[1] = g_ausSTART_BLR_AF_STEP12_F[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S521>/Level 4'
 *    '<S521>/Level 5'
 */
void Level4(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,
            uint8_t *rtd_Dtg_FUR, const uint16_t *rtd_ECT, uint8_t
            *rtd_El_window_heating, const int16_t *rtd_Incar_FL, uint8_t
            *rtd_Incar_filter_down_value, uint8_t *rtd_Incar_filter_up_value,
            const uint8_t *rtd_LEVEL, uint8_t *rtd_Mode_FL, uint8_t *rtd_Mode_FR,
            double *rtd_Recirculation, uint8_t *rtd_Valve_3_way, const int8_t
            *rtd_step_start_controle_front, const uint32_t *rtd_t_now, DW_Level4
            *localDW)
{
  int32_t tmp;
  int16_t rtb_out_ns[2];
  int16_t rtb_out_g3;
  int16_t rtb_out_hk;
  uint16_t rtb_out_gp[2];
  uint8_t rtb_out_oc;
  bool rtb_Equal_c;
  bool rtb_RelationalOperator1_f;

  /* DataStoreWrite: '<S556>/Data Store Write8' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read10'
   *  MATLAB Function: '<S556>/3 way valve status'
   */
  uwayvalvestatus(*rtd_LEVEL, rtd_Valve_3_way);

  /* DataStoreWrite: '<S556>/Data Store Write' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read1'
   *  MATLAB Function: '<S556>/incar filter up'
   */
  incarfilterup(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S556>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read2'
   *  MATLAB Function: '<S556>/incar filter down'
   */
  incarfilterdown(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* MATLAB Function: '<S556>/mode FR step 1' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read5'
   */
  modeFRstep1(*rtd_LEVEL, &rtb_out_oc);

  /* DataStoreWrite: '<S556>/Data Store Write2' */
  *rtd_Mode_FR = rtb_out_oc;

  /* DataStoreWrite: '<S556>/Data Store Write3' */
  *rtd_Mode_FL = rtb_out_oc;

  /* MATLAB Function: '<S556>/window heating' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read6'
   */
  windowheating(*rtd_LEVEL, &rtb_out_oc);

  /* DataStoreWrite: '<S556>/Data Store Write4' */
  *rtd_El_window_heating = rtb_out_oc;

  /* MATLAB Function: '<S600>/blower min max' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read7'
   */
  blowerminmax(*rtd_LEVEL, rtb_out_gp);

  /* MATLAB Function: '<S600>/ECT min max' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read7'
   */
  ECTminmax(*rtd_LEVEL, rtb_out_ns);

  /* Lookup_n-D: '<S600>/blower для текущего ECT' incorporates:
   *  DataStoreRead: '<S600>/engine coolant temp'
   *  DataStoreWrite: '<S556>/Data Store Write5'
   */
  *rtd_Blower_FR = look1_iu16bs16lu64n32_binlcse(*rtd_ECT, rtb_out_ns,
    rtb_out_gp, 1U);

  /* DataStoreWrite: '<S556>/Data Store Write6' incorporates:
   *  DataStoreWrite: '<S556>/Data Store Write5'
   */
  *rtd_Blower_FL = *rtd_Blower_FR;

  /* MATLAB Function: '<S556>/Dtg_FrontUpper_X' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read8'
   */
  /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_U(LVL + 1); */
  tmp = (int32_t)(*rtd_LEVEL + 1U);
  if (*rtd_LEVEL + 1U > 255U) {
    tmp = 255;
  }

  rtb_out_oc = g_aucSTART_DUCT_TGT_STEP2_FX_U[tmp - 1];

  /* DataStoreWrite: '<S556>/Data Store Write10' */
  *rtd_Dtg_FUR = rtb_out_oc;

  /* DataStoreWrite: '<S556>/Data Store Write11' */
  *rtd_Dtg_FUL = rtb_out_oc;

  /* MATLAB Function: '<S556>/Dtg_FrontLower_X' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read8'
   *  DataStoreRead: '<S556>/Data Store Read9'
   *  MATLAB Function: '<S556>/Dtg_FrontUpper_X'
   */
  /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_L(LVL + 1); */
  tmp = (int32_t)(*rtd_LEVEL + 1U);
  if (*rtd_LEVEL + 1U > 255U) {
    tmp = 255;
  }

  rtb_out_oc = g_aucSTART_DUCT_TGT_STEP2_FX_L[tmp - 1];

  /* End of MATLAB Function: '<S556>/Dtg_FrontLower_X' */

  /* DataStoreWrite: '<S556>/Data Store Write12' */
  *rtd_Dtg_FLR = rtb_out_oc;

  /* DataStoreWrite: '<S556>/Data Store Write13' */
  *rtd_Dtg_FLL = rtb_out_oc;

  /* DataStoreWrite: '<S556>/Data Store Write7' incorporates:
   *  Constant: '<S556>/Recirc logic Partial REC'
   */
  *rtd_Recirculation = 1.0;

  /* RelationalOperator: '<S556>/Equal' incorporates:
   *  DataStoreRead: '<S556>/current step'
   */
  rtb_Equal_c = (*rtd_step_start_controle_front == 1);

  /* MATLAB Function: '<S556>/Incar temp goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read3'
   */
  Incartempgotofromstep1tostep2(*rtd_LEVEL, &rtb_out_g3);

  /* MATLAB Function: '<S556>/Time goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S556>/Data Store Read4'
   */
  Timegotofromstep1tostep2(*rtd_LEVEL, &rtb_out_hk);

  /* RelationalOperator: '<S556>/Relational Operator1' incorporates:
   *  DataStoreRead: '<S598>/Data Store Read4'
   *  Gain: '<S556>/из сек в мс'
   *  Sum: '<S598>/Subtract'
   *  UnitDelay: '<S598>/t_start_delay_private '
   */
  rtb_RelationalOperator1_f = (*rtd_t_now -
    localDW->t_start_delay_private_DSTATE > (uint32_t)(1000 * rtb_out_hk));

  /* Switch: '<S598>/Switch' incorporates:
   *  DataStoreRead: '<S598>/Data Store Read4'
   *  Logic: '<S598>/Logical Operator3'
   *  Logic: '<S598>/Logical Operator4'
   *  UnitDelay: '<S598>/Cond_prev_private '
   *  UnitDelay: '<S598>/t_start_delay_private '
   */
  if (rtb_Equal_c && (!localDW->Cond_prev_private_DSTATE)) {
    localDW->t_start_delay_private_DSTATE = *rtd_t_now;
  }

  /* End of Switch: '<S598>/Switch' */

  /* Switch: '<S556>/Switch' incorporates:
   *  Constant: '<S556>/go to next step'
   *  Constant: '<S556>/stay at step 1'
   *  DataStoreRead: '<S556>/incar temp'
   *  Logic: '<S556>/Logical Operator'
   *  RelationalOperator: '<S556>/Relational Operator'
   */
  if ((*rtd_Incar_FL > rtb_out_g3) || rtb_RelationalOperator1_f) {
    *rty_step = 2;
  } else {
    *rty_step = 1;
  }

  /* End of Switch: '<S556>/Switch' */

  /* Update for UnitDelay: '<S598>/Cond_prev_private ' */
  localDW->Cond_prev_private_DSTATE = rtb_Equal_c;
}

/*
 * Output and update for atomic system:
 *    '<S620>/3 way valve status'
 *    '<S621>/3 way valve status'
 *    '<S623>/3 way valve status'
 *    '<S624>/3 way valve status'
 *    '<S625>/3 way valve status'
 */
void uwayvalvestatus_m(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_3WAY_OPEN(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_3WAY_OPEN[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S627>/time for step'
 *    '<S657>/time for step'
 *    '<S687>/time for step'
 *    '<S718>/time for step'
 *    '<S749>/time for step'
 */
void timeforstep(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_L(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_DUCT_TGT_STEP2_FX_L[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S628>/time for step'
 *    '<S658>/time for step'
 *    '<S688>/time for step'
 *    '<S719>/time for step'
 *    '<S750>/time for step'
 */
void timeforstep_a(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_DUCT_TGT_STEP2_FX_U(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_DUCT_TGT_STEP2_FX_U[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S620>/Time goto from step 2 to step 3 '
 *    '<S621>/Time goto from step 2 to step 3 '
 *    '<S623>/Time goto from step 2 to step 3 '
 *    '<S624>/Time goto from step 2 to step 3 '
 *    '<S625>/Time goto from step 2 to step 3 '
 */
void Timegotofromstep2tostep3(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;
  uint16_t tmp_0;

  /* :  out = int16(g_ausSTART_TIME_STEP2_TO_3(LVL + 1)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = g_ausSTART_TIME_STEP2_TO_3[tmp - 1];
  if (tmp_0 > 32767) {
    tmp_0 = 32767U;
  }

  *rty_out = (int16_t)tmp_0;
}

/*
 * Output and update for atomic system:
 *    '<S631>/blower step'
 *    '<S661>/blower step'
 *    '<S692>/blower step'
 *    '<S723>/blower step'
 *    '<S754>/blower step'
 */
void blowerstep(uint8_t rtu_LVL, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_ausSTART_BLR_SPD_STEP2_F(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausSTART_BLR_SPD_STEP2_F[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S631>/blower time for step'
 *    '<S661>/blower time for step'
 *    '<S692>/blower time for step'
 *    '<S723>/blower time for step'
 *    '<S754>/blower time for step'
 */
void blowertimeforstep(uint8_t rtu_LVL, uint16_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_ausSTART_BLR_SPD_STEP2_F(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_ausSTART_BLR_SPD_STEP2_F[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S634>/step'
 *    '<S664>/step'
 *    '<S695>/step'
 *    '<S726>/step'
 *    '<S757>/step'
 */
void step_l(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_VALVE_CHANGE_SPD_F(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_VALVE_CHANGE_SPD_F[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S634>/time for step'
 *    '<S664>/time for step'
 *    '<S695>/time for step'
 *    '<S726>/time for step'
 *    '<S757>/time for step'
 */
void timeforstep_f(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_VALVE_CHANGE_SPD_F(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_VALVE_CHANGE_SPD_F[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S621>/window heating'
 *    '<S623>/window heating'
 *    '<S624>/window heating'
 *    '<S625>/window heating'
 */
void windowheating_k(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_ELEC_WINDOW(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_ELEC_WINDOW[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S623>/autodemist (autodefog)'
 *    '<S624>/autodemist (autodefog)'
 *    '<S625>/autodemist (autodefog)'
 */
void autodemistautodefog(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_AUTODEMIST2_STEP2(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_AUTODEMIST2_STEP2[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S522>/Level 3'
 *    '<S522>/Level 4'
 */
void Level3_d(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,
              uint8_t *rtd_Dtg_FLL, uint8_t *rtd_Dtg_FLR, uint8_t *rtd_Dtg_FUL,
              uint8_t *rtd_Dtg_FUR, const uint8_t *rtd_Dtg_logic_FLL, const
              uint8_t *rtd_Dtg_logic_FUL, uint8_t *rtd_El_window_heating, const
              bool *rtd_HI_logic_on, uint8_t *rtd_Incar_filter_down_value,
              uint8_t *rtd_Incar_filter_up_value, const uint8_t *rtd_LEVEL,
              uint8_t *rtd_Mode_FL, uint8_t *rtd_Mode_FR, const uint8_t
              *rtd_Mode_logic_FL, double *rtd_Recirculation, uint8_t
              *rtd_Valve_3_way, const int8_t *rtd_step_start_controle_front,
              const uint32_t *rtd_t_now, DW_Level3_h *localDW)
{
  int32_t tmp;
  int16_t rtb_out_jl;
  uint16_t rtb_out_apg;
  uint16_t rtb_out_g1;
  uint8_t rtb_out_f4;
  uint8_t rtb_out_fo;
  uint8_t rtb_out_j5;
  bool rtb_Cond_prev_private_l2;
  bool rtb_RelationalOperator1_f;

  /* DataStoreWrite: '<S623>/Data Store Write8' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read10'
   *  MATLAB Function: '<S623>/3 way valve status'
   */
  uwayvalvestatus_m(*rtd_LEVEL, rtd_Valve_3_way);

  /* MATLAB Function: '<S687>/step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read9'
   */
  Dtg_FrontLower_X(*rtd_LEVEL, &rtb_out_j5);

  /* MATLAB Function: '<S687>/time for step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read9'
   */
  timeforstep(*rtd_LEVEL, &rtb_out_fo);

  /* Switch: '<S687>/Switch' incorporates:
   *  Constant: '<S687>/Constant'
   *  Constant: '<S697>/epsilon'
   *  DataStoreRead: '<S687>/Текущее значение blower '
   *  DataStoreRead: '<S687>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S687>/текущее время в мс'
   *  DataStoreWrite: '<S623>/Data Store Write12'
   *  Product: '<S687>/Product1'
   *  Product: '<S687>/change rate (dtg//sec)'
   *  Product: '<S687>/скорость в мс'
   *  Product: '<S687>/шаг изменения'
   *  RelationalOperator: '<S697>/Relational Operator'
   *  RelationalOperator: '<S701>/Relational Operator'
   *  Sum: '<S687>/Add'
   *  Sum: '<S697>/Add'
   *  Sum: '<S698>/Subtract'
   *  Switch: '<S701>/Switch'
   *  UnitDelay: '<S698>/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: '<S701>/Switch' incorporates:
       *  Constant: '<S701>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S701>/Switch' incorporates:
       *  Constant: '<S701>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Dtg_FLR = (uint8_t)((double)rtb_out_j5 / (double)rtb_out_fo / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE) * (double)tmp + (double)*
      rtd_Dtg_FLL);
  }

  /* End of Switch: '<S687>/Switch' */

  /* DataStoreWrite: '<S623>/Data Store Write13' incorporates:
   *  DataStoreWrite: '<S623>/Data Store Write12'
   */
  *rtd_Dtg_FLL = *rtd_Dtg_FLR;

  /* MATLAB Function: '<S688>/step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read8'
   */
  Dtg_FrontUpper_X(*rtd_LEVEL, &rtb_out_j5);

  /* MATLAB Function: '<S688>/time for step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read8'
   */
  timeforstep_a(*rtd_LEVEL, &rtb_out_fo);

  /* Switch: '<S688>/Switch' incorporates:
   *  Constant: '<S688>/Constant'
   *  Constant: '<S702>/epsilon'
   *  DataStoreRead: '<S688>/Текущее значение blower '
   *  DataStoreRead: '<S688>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S688>/текущее время в мс'
   *  DataStoreWrite: '<S623>/Data Store Write10'
   *  Product: '<S688>/Product1'
   *  Product: '<S688>/change rate (dtg//sec)'
   *  Product: '<S688>/скорость в мс'
   *  Product: '<S688>/шаг изменения'
   *  RelationalOperator: '<S702>/Relational Operator'
   *  RelationalOperator: '<S706>/Relational Operator'
   *  Sum: '<S688>/Add'
   *  Sum: '<S702>/Add'
   *  Sum: '<S703>/Subtract'
   *  Switch: '<S706>/Switch'
   *  UnitDelay: '<S703>/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: '<S706>/Switch' incorporates:
       *  Constant: '<S706>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S706>/Switch' incorporates:
       *  Constant: '<S706>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Dtg_FUR = (uint8_t)((double)rtb_out_j5 / (double)rtb_out_fo / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_e) * (double)tmp + (double)*
      rtd_Dtg_FUL);
  }

  /* End of Switch: '<S688>/Switch' */

  /* DataStoreWrite: '<S623>/Data Store Write11' incorporates:
   *  DataStoreWrite: '<S623>/Data Store Write10'
   */
  *rtd_Dtg_FUL = *rtd_Dtg_FUR;

  /* DataStoreWrite: '<S623>/Data Store Write' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read1'
   *  MATLAB Function: '<S623>/incar filter up'
   */
  incarfilterup(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S623>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read2'
   *  MATLAB Function: '<S623>/incar filter down'
   */
  incarfilterdown(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* DataStoreWrite: '<S623>/Data Store Write14' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read3'
   *  MATLAB Function: '<S623>/autodemist (autodefog)'
   */
  autodemistautodefog(*rtd_LEVEL, rtd_Autodefog);

  /* Sum: '<S712>/Add' incorporates:
   *  DataStoreRead: '<S695>/Текущее значение blower '
   *  DataStoreRead: '<S695>/значение auto (в соответствии с логикой)'
   */
  rtb_out_j5 = (uint8_t)(*rtd_Mode_FL - *rtd_Mode_logic_FL);

  /* MATLAB Function: '<S695>/step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read5'
   */
  step_l(*rtd_LEVEL, &rtb_out_fo);

  /* MATLAB Function: '<S695>/time for step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read5'
   */
  timeforstep_f(*rtd_LEVEL, &rtb_out_f4);

  /* Switch: '<S695>/Switch' incorporates:
   *  Constant: '<S695>/Constant'
   *  Constant: '<S712>/epsilon'
   *  DataStoreRead: '<S695>/Текущее значение blower '
   *  DataStoreRead: '<S695>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S695>/текущее время в мс'
   *  DataStoreWrite: '<S623>/Data Store Write2'
   *  Product: '<S695>/Product1'
   *  Product: '<S695>/change rate (step//sec)'
   *  Product: '<S695>/скорость в мс'
   *  Product: '<S695>/шаг изменения'
   *  RelationalOperator: '<S712>/Relational Operator'
   *  RelationalOperator: '<S716>/Relational Operator'
   *  Sum: '<S695>/Add'
   *  Sum: '<S713>/Subtract'
   *  Switch: '<S716>/Switch'
   *  UnitDelay: '<S713>/Unit Delay'
   */
  if (rtb_out_j5 <= 0.01) {
    *rtd_Mode_FR = *rtd_Mode_logic_FL;
  } else {
    if (*rtd_Mode_FL <= *rtd_Mode_logic_FL) {
      /* Switch: '<S716>/Switch' incorporates:
       *  Constant: '<S716>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S716>/Switch' incorporates:
       *  Constant: '<S716>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Mode_FR = (uint8_t)((double)rtb_out_fo / (double)rtb_out_f4 / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_h) * (double)tmp + (double)*
      rtd_Mode_FL);
  }

  /* End of Switch: '<S695>/Switch' */

  /* DataStoreWrite: '<S623>/Data Store Write3' incorporates:
   *  DataStoreWrite: '<S623>/Data Store Write2'
   */
  *rtd_Mode_FL = *rtd_Mode_FR;

  /* MATLAB Function: '<S623>/window heating' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read6'
   */
  windowheating_k(*rtd_LEVEL, &rtb_out_j5);

  /* DataStoreWrite: '<S623>/Data Store Write4' */
  *rtd_El_window_heating = rtb_out_j5;

  /* Sum: '<S707>/Add' incorporates:
   *  DataStoreRead: '<S692>/Текущее значение blower '
   *  DataStoreRead: '<S692>/значение auto (в соответствии с логикой)'
   */
  rtb_out_g1 = (uint16_t)(*rtd_Blower_FL - *rtd_Blower_logic_FL);

  /* RelationalOperator: '<S707>/Relational Operator' incorporates:
   *  Constant: '<S707>/epsilon'
   */
  rtb_Cond_prev_private_l2 = (rtb_out_g1 <= 0.01);

  /* MATLAB Function: '<S692>/blower step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read7'
   */
  blowerstep(*rtd_LEVEL, &rtb_out_apg);

  /* MATLAB Function: '<S692>/blower time for step' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read7'
   */
  blowertimeforstep(*rtd_LEVEL, &rtb_out_g1);

  /* Switch: '<S692>/Switch' incorporates:
   *  Constant: '<S692>/Constant'
   *  DataStoreRead: '<S692>/Текущее значение blower '
   *  DataStoreRead: '<S692>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S692>/текущее время в мс'
   *  DataStoreWrite: '<S623>/Data Store Write5'
   *  Product: '<S692>/Product1'
   *  Product: '<S692>/change rate (step//sec)'
   *  Product: '<S692>/скорость в мс'
   *  Product: '<S692>/шаг изменения'
   *  RelationalOperator: '<S711>/Relational Operator'
   *  Sum: '<S692>/Add'
   *  Sum: '<S708>/Subtract'
   *  Switch: '<S711>/Switch'
   *  UnitDelay: '<S708>/Unit Delay'
   */
  if (rtb_Cond_prev_private_l2) {
    *rtd_Blower_FR = *rtd_Blower_logic_FL;
  } else {
    if (*rtd_Blower_FL <= *rtd_Blower_logic_FL) {
      /* Switch: '<S711>/Switch' incorporates:
       *  Constant: '<S711>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S711>/Switch' incorporates:
       *  Constant: '<S711>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Blower_FR = (uint16_t)((double)rtb_out_apg / (double)rtb_out_g1 /
      1000.0 * (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_o) * (double)tmp
      + (double)*rtd_Blower_FL);
  }

  /* End of Switch: '<S692>/Switch' */

  /* DataStoreWrite: '<S623>/Data Store Write6' incorporates:
   *  DataStoreWrite: '<S623>/Data Store Write5'
   */
  *rtd_Blower_FL = *rtd_Blower_FR;

  /* DataStoreWrite: '<S623>/Data Store Write7' incorporates:
   *  Constant: '<S623>/Recirc logic Partial REC'
   */
  *rtd_Recirculation = 1.0;

  /* RelationalOperator: '<S623>/Equal' incorporates:
   *  DataStoreRead: '<S623>/current step'
   */
  rtb_Cond_prev_private_l2 = (*rtd_step_start_controle_front == 1);

  /* MATLAB Function: '<S623>/Time goto from step 2 to step 3 ' incorporates:
   *  DataStoreRead: '<S623>/Data Store Read4'
   */
  Timegotofromstep2tostep3(*rtd_LEVEL, &rtb_out_jl);

  /* RelationalOperator: '<S623>/Relational Operator1' incorporates:
   *  DataStoreRead: '<S689>/Data Store Read4'
   *  Gain: '<S623>/из сек в мс'
   *  Sum: '<S689>/Subtract'
   *  UnitDelay: '<S689>/t_start_delay_private '
   */
  rtb_RelationalOperator1_f = (*rtd_t_now -
    localDW->t_start_delay_private_DSTATE > (uint32_t)(1000 * rtb_out_jl));

  /* Switch: '<S689>/Switch' incorporates:
   *  DataStoreRead: '<S689>/Data Store Read4'
   *  Logic: '<S689>/Logical Operator3'
   *  Logic: '<S689>/Logical Operator4'
   *  UnitDelay: '<S689>/Cond_prev_private '
   *  UnitDelay: '<S689>/t_start_delay_private '
   */
  if (rtb_Cond_prev_private_l2 && (!localDW->Cond_prev_private_DSTATE)) {
    localDW->t_start_delay_private_DSTATE = *rtd_t_now;
  }

  /* End of Switch: '<S689>/Switch' */

  /* Switch: '<S623>/Switch' incorporates:
   *  Constant: '<S623>/go to next step'
   *  Constant: '<S623>/stay at step 1'
   *  DataStoreRead: '<S623>/Data Store Read'
   *  Logic: '<S623>/Logical Operator'
   */
  if (rtb_RelationalOperator1_f || (*rtd_HI_logic_on)) {
    *rty_step = 2;
  } else {
    *rty_step = 1;
  }

  /* End of Switch: '<S623>/Switch' */

  /* Update for UnitDelay: '<S698>/Unit Delay' incorporates:
   *  DataStoreRead: '<S687>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE = *rtd_t_now;

  /* Update for UnitDelay: '<S703>/Unit Delay' incorporates:
   *  DataStoreRead: '<S688>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_e = *rtd_t_now;

  /* Update for UnitDelay: '<S713>/Unit Delay' incorporates:
   *  DataStoreRead: '<S695>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_h = *rtd_t_now;

  /* Update for UnitDelay: '<S708>/Unit Delay' incorporates:
   *  DataStoreRead: '<S692>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_o = *rtd_t_now;

  /* Update for UnitDelay: '<S689>/Cond_prev_private ' */
  localDW->Cond_prev_private_DSTATE = rtb_Cond_prev_private_l2;
}

/*
 * Output and update for action system:
 *    '<S517>/Step 3'
 *    '<S518>/Step 3'
 */
void Step3(int8_t *rty_step, int8_t *rtd_start_control_finished_front)
{
  /* DataStoreWrite: '<S523>/Data Store Write10' incorporates:
   *  Constant: '<S523>/True'
   */
  *rtd_start_control_finished_front = 1;

  /* SignalConversion generated from: '<S523>/step' incorporates:
   *  Constant: '<S523>/Constant1'
   */
  *rty_step = 3;
}

/*
 * Output and update for atomic system:
 *    '<S784>/g_ausSTART_ENTER_SETTEMP'
 *    '<S785>/g_ausSTART_ENTER_SETTEMP'
 *    '<S786>/g_ausSTART_ENTER_SETTEMP'
 */
void g_ausSTART_ENTER_SETTEMP_p(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;
  uint16_t tmp_1;

  /* :  out = int16(g_ausSTART_ENTER_SETTEMP(LVL+1+6)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  tmp_1 = g_ausSTART_ENTER_SETTEMP[tmp_0 - 1];
  if (tmp_1 > 32767) {
    tmp_1 = 32767U;
  }

  *rty_out = (int16_t)tmp_1;
}

/*
 * Output and update for atomic system:
 *    '<S785>/g_assSTART_ENTER_INCAR'
 *    '<S786>/g_assSTART_ENTER_INCAR'
 *    '<S787>/g_assSTART_ENTER_INCAR'
 *    '<S788>/g_assSTART_ENTER_INCAR'
 *    '<S789>/g_assSTART_ENTER_INCAR'
 */
void g_assSTART_ENTER_INCAR_l(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = int16(g_assSTART_ENTER_INCAR(LVL+1+6)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_assSTART_ENTER_INCAR[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S787>/g_assSTART_ENTER_COOLANT '
 *    '<S788>/g_assSTART_ENTER_COOLANT '
 *    '<S789>/g_assSTART_ENTER_COOLANT '
 */
void g_assSTART_ENTER_COOLANT_i(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;

  /* :  out = int16(g_assSTART_ENTER_COOLANT(LVL + 1)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_assSTART_ENTER_COOLANT[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S779>/Level 4'
 *    '<S779>/Level 5'
 */
void Level4_i(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_dtd;
  int16_t rtb_out_mu;

  /* MATLAB Function: '<S788>/g_assSTART_ENTER_INCAR' incorporates:
   *  DataStoreRead: '<S788>/Data Store Read4'
   */
  g_assSTART_ENTER_INCAR_l(*rtd_LEVEL, &rtb_out_mu);

  /* MATLAB Function: '<S788>/g_assSTART_ENTER_COOLANT ' incorporates:
   *  DataStoreRead: '<S788>/Data Store Read3'
   */
  g_assSTART_ENTER_COOLANT_i(*rtd_LEVEL, &rtb_out_dtd);

  /* Switch: '<S788>/Switch' incorporates:
   *  Constant: '<S788>/AUTO'
   *  Constant: '<S788>/Constant'
   *  Constant: '<S788>/Constant1'
   *  DataStoreRead: '<S788>/Data Store Read'
   *  DataStoreRead: '<S788>/Data Store Read1'
   *  DataStoreRead: '<S788>/Data Store Read2'
   *  Logic: '<S788>/AND'
   *  Logic: '<S788>/AND1'
   *  RelationalOperator: '<S788>/Relational Operator'
   *  RelationalOperator: '<S788>/Relational Operator1'
   *  RelationalOperator: '<S788>/Relational Operator2'
   */
  if (((*rtd_Incar_RR < rtb_out_mu) || (*rtd_ECT < rtb_out_dtd)) &&
      (*rtd_MODE_RR_passenger == 1.0)) {
    *rty_step1 = 0;
  } else {
    *rty_step1 = -1;
  }

  /* End of Switch: '<S788>/Switch' */
}

/*
 * Output and update for atomic system:
 *    '<S805>/incar filter down'
 *    '<S806>/incar filter down'
 *    '<S807>/incar filter down'
 *    '<S808>/incar filter down'
 */
void incarfilterdown_j(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_INCAR_FLT_DN(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_INCAR_FLT_DN[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S805>/incar filter up'
 *    '<S806>/incar filter up'
 *    '<S807>/incar filter up'
 *    '<S808>/incar filter up'
 */
void incarfilterup_d(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_INCAR_FLT_UP(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_INCAR_FLT_UP[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S806>/g_assSTART_COOLANT_STEP0_TO_1 '
 *    '<S807>/g_assSTART_COOLANT_STEP0_TO_1 '
 *    '<S808>/g_assSTART_COOLANT_STEP0_TO_1 '
 */
void g_assSTART_COOLANT_STEP0_TO_1_g(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;

  /* :  out = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 3)); */
  tmp = (int32_t)(rtu_LVL + 3U);
  if (rtu_LVL + 3U > 255U) {
    tmp = 255;
  }

  *rty_out = g_assSTART_COOLANT_STEP0_TO_1[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S780>/Level 4'
 *    '<S780>/Level 5'
 */
void Level4_h(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
              uint16_t *rtd_ECT, uint8_t *rtd_Incar_filter_down_value, uint8_t
              *rtd_Incar_filter_up_value, const uint8_t *rtd_LEVEL, uint8_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_dfj;

  /* DataStoreWrite: '<S807>/Data Store Write5' incorporates:
   *  Constant: '<S807>/Constant2'
   */
  *rtd_Blower_RR = 10U;

  /* DataStoreWrite: '<S807>/Data Store Write6' incorporates:
   *  Constant: '<S807>/Constant3'
   */
  *rtd_Blower_RL = 10U;

  /* DataStoreWrite: '<S807>/Data Store Write10' incorporates:
   *  Constant: '<S807>/Constant4'
   */
  *rtd_Dtg_RR = 80U;

  /* DataStoreWrite: '<S807>/Data Store Write11' incorporates:
   *  Constant: '<S807>/Constant5'
   */
  *rtd_Dtg_RL = 80U;

  /* DataStoreWrite: '<S807>/Data Store Write' incorporates:
   *  DataStoreRead: '<S807>/Data Store Read1'
   *  MATLAB Function: '<S807>/incar filter up'
   */
  incarfilterup_d(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S807>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S807>/Data Store Read2'
   *  MATLAB Function: '<S807>/incar filter down'
   */
  incarfilterdown_j(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* DataStoreWrite: '<S807>/Data Store Write2' incorporates:
   *  Constant: '<S807>/Mode - foot'
   */
  *rtd_Mode_RR = 60U;

  /* DataStoreWrite: '<S807>/Data Store Write3' incorporates:
   *  Constant: '<S807>/Mode - foot'
   */
  *rtd_Mode_RL = 60U;

  /* DataStoreWrite: '<S807>/Data Store Write8' incorporates:
   *  Constant: '<S807>/Valve open'
   */
  *rtd_Valve_3_way = 1U;

  /* DataStoreWrite: '<S807>/Data Store Write9' incorporates:
   *  Constant: '<S807>/Valve open'
   */
  *rtd_Valve_2_way = 1U;

  /* MATLAB Function: '<S807>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
   *  DataStoreRead: '<S807>/Data Store Read3'
   */
  g_assSTART_COOLANT_STEP0_TO_1_g(*rtd_LEVEL, &rtb_out_dfj);

  /* Switch: '<S807>/Switch' incorporates:
   *  DataStoreRead: '<S807>/Engine coolant temp'
   *  RelationalOperator: '<S807>/Relational Operator'
   */
  *rty_step1 = (int8_t)(*rtd_ECT > rtb_out_dfj);
}

/*
 * Output and update for atomic system:
 *    '<S821>/2 way valve'
 *    '<S822>/2 way valve'
 *    '<S823>/2 way valve'
 *    '<S824>/2 way valve'
 *    '<S825>/2 way valve'
 *    '<S826>/2 way valve'
 *    '<S891>/2 way valve'
 *    '<S892>/2 way valve'
 *    '<S893>/2 way valve'
 *    '<S894>/2 way valve'
 *    ...
 */
void uwayvalve(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_2WAY_OPEN(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_2WAY_OPEN[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S821>/Dtg_rear'
 *    '<S822>/Dtg_rear'
 *    '<S823>/Dtg_rear'
 *    '<S824>/Dtg_rear'
 *    '<S825>/Dtg_rear'
 *    '<S826>/Dtg_rear'
 */
void Dtg_rear(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_DUCT_TGT_STEP2_RX(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_DUCT_TGT_STEP2_RX[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S821>/Incar temp goto from step 1 to step 2 '
 *    '<S822>/Incar temp goto from step 1 to step 2 '
 *    '<S823>/Incar temp goto from step 1 to step 2 '
 *    '<S824>/Incar temp goto from step 1 to step 2 '
 *    '<S825>/Incar temp goto from step 1 to step 2 '
 *    '<S826>/Incar temp goto from step 1 to step 2 '
 */
void Incartempgotofromstep1tostep2_b(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = int16(g_assSTART_INCAR_STEP1_TO_2(LVL + 1 + 6)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_assSTART_INCAR_STEP1_TO_2[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S821>/Time goto from step 1 to step 2 '
 *    '<S822>/Time goto from step 1 to step 2 '
 *    '<S823>/Time goto from step 1 to step 2 '
 *    '<S824>/Time goto from step 1 to step 2 '
 *    '<S825>/Time goto from step 1 to step 2 '
 *    '<S826>/Time goto from step 1 to step 2 '
 *    '<S891>/Time goto from step 1 to step 2 '
 *    '<S892>/Time goto from step 1 to step 2 '
 *    '<S893>/Time goto from step 1 to step 2 '
 *    '<S894>/Time goto from step 1 to step 2 '
 *    ...
 */
void Timegotofromstep1tostep2_h(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;
  uint16_t tmp_1;

  /* :  out = int16(g_ausSTART_TIME_STEP1_TO_2(LVL + 1 + 6)); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  tmp_1 = g_ausSTART_TIME_STEP1_TO_2[tmp_0 - 1];
  if (tmp_1 > 32767) {
    tmp_1 = 32767U;
  }

  *rty_out = (int16_t)tmp_1;
}

/*
 * Output and update for atomic system:
 *    '<S821>/mode rear step 1'
 *    '<S822>/mode rear step 1'
 *    '<S823>/mode rear step 1'
 *    '<S824>/mode rear step 1'
 *    '<S825>/mode rear step 1'
 *    '<S826>/mode rear step 1'
 */
void moderearstep1(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_VALVE_IDX_STEP1(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_VALVE_IDX_STEP1[tmp_0 - 1];
}

/*
 * Output and update for action system:
 *    '<S781>/Level 0'
 *    '<S781>/Level 1'
 */
void Level0_h(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
              *rtd_Incar_RR, uint8_t *rtd_Incar_filter_down_value, uint8_t
              *rtd_Incar_filter_up_value, const uint8_t *rtd_LEVEL, uint8_t
              *rtd_Mode_RL, uint8_t *rtd_Mode_RR, double *rtd_Recirculation,
              uint8_t *rtd_Valve_2_way, const int8_t
              *rtd_step_start_controle_rear, const uint32_t *rtd_t_now,
              DW_Level0_p *localDW)
{
  int32_t tmp;
  uint32_t rtb_dt_dl;
  int16_t rtb_out_gl;
  int16_t rtb_out_ni;
  uint16_t rtb_out_it;
  uint8_t rtb_out_c5o;
  bool rtb_Equal_ix;

  /* DataStoreWrite: '<S821>/Data Store Write9' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read6'
   *  MATLAB Function: '<S821>/2 way valve'
   */
  uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);

  /* DataStoreWrite: '<S821>/Data Store Write' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read1'
   *  MATLAB Function: '<S821>/incar filter up'
   */
  incarfilterup_d(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S821>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read2'
   *  MATLAB Function: '<S821>/incar filter down'
   */
  incarfilterdown_j(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* MATLAB Function: '<S821>/mode rear step 1' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read5'
   */
  moderearstep1(*rtd_LEVEL, &rtb_out_c5o);

  /* DataStoreWrite: '<S821>/Data Store Write2' */
  *rtd_Mode_RR = rtb_out_c5o;

  /* DataStoreWrite: '<S821>/Data Store Write3' */
  *rtd_Mode_RL = rtb_out_c5o;

  /* MATLAB Function: '<S821>/blower rear' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read7'
   */
  /* :  out = g_ausSTART_BLR_AF_STEP12_R(LVL + 1); */
  tmp = (int32_t)(*rtd_LEVEL + 1U);
  if (*rtd_LEVEL + 1U > 255U) {
    tmp = 255;
  }

  rtb_out_it = g_ausSTART_BLR_AF_STEP12_R[tmp - 1];

  /* End of MATLAB Function: '<S821>/blower rear' */

  /* DataStoreWrite: '<S821>/Data Store Write5' */
  *rtd_Blower_RR = rtb_out_it;

  /* DataStoreWrite: '<S821>/Data Store Write6' */
  *rtd_Blower_RL = rtb_out_it;

  /* MATLAB Function: '<S821>/Dtg_rear' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read8'
   */
  Dtg_rear(*rtd_LEVEL, &rtb_out_c5o);

  /* DataStoreWrite: '<S821>/Data Store Write10' */
  *rtd_Dtg_RR = rtb_out_c5o;

  /* DataStoreWrite: '<S821>/Data Store Write11' */
  *rtd_Dtg_RL = rtb_out_c5o;

  /* DataStoreWrite: '<S821>/Data Store Write7' incorporates:
   *  Constant: '<S821>/Recirc logic Partial REC'
   */
  *rtd_Recirculation = 1.0;

  /* RelationalOperator: '<S821>/Equal' incorporates:
   *  DataStoreRead: '<S821>/current step'
   */
  rtb_Equal_ix = (*rtd_step_start_controle_rear == 1);

  /* MATLAB Function: '<S821>/Incar temp goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read3'
   */
  Incartempgotofromstep1tostep2_b(*rtd_LEVEL, &rtb_out_ni);

  /* Sum: '<S830>/Subtract' incorporates:
   *  DataStoreRead: '<S830>/Data Store Read4'
   *  UnitDelay: '<S830>/t_start_delay_private '
   */
  rtb_dt_dl = *rtd_t_now - localDW->t_start_delay_private_DSTATE;

  /* MATLAB Function: '<S821>/Time goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S821>/Data Store Read4'
   */
  Timegotofromstep1tostep2_h(*rtd_LEVEL, &rtb_out_gl);

  /* Switch: '<S830>/Switch' incorporates:
   *  DataStoreRead: '<S830>/Data Store Read4'
   *  Logic: '<S830>/Logical Operator3'
   *  Logic: '<S830>/Logical Operator4'
   *  UnitDelay: '<S830>/Cond_prev_private '
   *  UnitDelay: '<S830>/t_start_delay_private '
   */
  if (rtb_Equal_ix && (!localDW->Cond_prev_private_DSTATE)) {
    localDW->t_start_delay_private_DSTATE = *rtd_t_now;
  }

  /* End of Switch: '<S830>/Switch' */

  /* Switch: '<S821>/Switch' incorporates:
   *  Constant: '<S821>/go to next step'
   *  Constant: '<S821>/stay at step 1'
   *  DataStoreRead: '<S821>/incar temp'
   *  Gain: '<S821>/из сек в мс'
   *  Logic: '<S821>/Logical Operator'
   *  RelationalOperator: '<S821>/Relational Operator'
   *  RelationalOperator: '<S821>/Relational Operator1'
   */
  if ((*rtd_Incar_RR < rtb_out_ni) || (rtb_dt_dl > (uint16_t)(1000 * rtb_out_gl)))
  {
    *rty_step = 2;
  } else {
    *rty_step = 1;
  }

  /* End of Switch: '<S821>/Switch' */

  /* Update for UnitDelay: '<S830>/Cond_prev_private ' */
  localDW->Cond_prev_private_DSTATE = rtb_Equal_ix;
}

/*
 * Output and update for atomic system:
 *    '<S850>/blower start finish'
 *    '<S862>/blower start finish'
 *    '<S874>/blower start finish'
 *    '<S885>/blower start finish'
 */
void blowerstartfinish(uint8_t rtu_LVL, uint16_t rty_out[2])
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  start = g_ausSTART_BLR_AF_STEP12_R(LVL + 1); */
  /* :  finish = g_ausSTART_BLR_AF_STEP12_R(LVL + 1 + 6); */
  /* :  out = [start, finish]; */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  rty_out[0] = g_ausSTART_BLR_AF_STEP12_R[tmp_0 - 1];
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

  tmp = (int32_t)((uint32_t)tmp_0 + 6U);
  if ((uint32_t)tmp_0 + 6U > 255U) {
    tmp = 255;
  }

  rty_out[1] = g_ausSTART_BLR_AF_STEP12_R[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S862>/ECT min max'
 *    '<S874>/ECT min max'
 *    '<S885>/ECT min max'
 */
void ECTminmax_h(uint8_t rtu_LVL, int16_t rty_out[2])
{
  int32_t tmp;

  /* :  min = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 3)); */
  /* :  max = int16(g_assSTART_COOLANT_TO_STEP2(3)); */
  /* :  out = [min, max]; */
  tmp = (int32_t)(rtu_LVL + 3U);
  if (rtu_LVL + 3U > 255U) {
    tmp = 255;
  }

  rty_out[0] = g_assSTART_COOLANT_STEP0_TO_1[tmp - 1];
  rty_out[1] = g_assSTART_COOLANT_TO_STEP2[2];
}

/*
 * Output and update for action system:
 *    '<S781>/Level 4'
 *    '<S781>/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,
              const int16_t *rtd_Incar_RR, uint8_t *rtd_Incar_filter_down_value,
              uint8_t *rtd_Incar_filter_up_value, const uint8_t *rtd_LEVEL,
              uint8_t *rtd_Mode_RL, uint8_t *rtd_Mode_RR, double
              *rtd_Recirculation, uint8_t *rtd_Valve_2_way, const int8_t
              *rtd_step_start_controle_rear, const uint32_t *rtd_t_now,
              DW_Level4_m *localDW)
{
  uint32_t rtb_dt_k;
  int16_t rtb_out_l1[2];
  int16_t rtb_out_a4;
  int16_t rtb_out_hj;
  uint16_t rtb_out_bd[2];
  uint8_t rtb_out_m1;
  bool rtb_Equal_hg;

  /* DataStoreWrite: '<S825>/Data Store Write9' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read6'
   *  MATLAB Function: '<S825>/2 way valve'
   */
  uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);

  /* DataStoreWrite: '<S825>/Data Store Write' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read1'
   *  MATLAB Function: '<S825>/incar filter up'
   */
  incarfilterup_d(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S825>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read2'
   *  MATLAB Function: '<S825>/incar filter down'
   */
  incarfilterdown_j(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* MATLAB Function: '<S825>/mode rear step 1' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read5'
   */
  moderearstep1(*rtd_LEVEL, &rtb_out_m1);

  /* DataStoreWrite: '<S825>/Data Store Write2' */
  *rtd_Mode_RR = rtb_out_m1;

  /* DataStoreWrite: '<S825>/Data Store Write3' */
  *rtd_Mode_RL = rtb_out_m1;

  /* MATLAB Function: '<S874>/blower start finish' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read7'
   */
  blowerstartfinish(*rtd_LEVEL, rtb_out_bd);

  /* MATLAB Function: '<S874>/ECT min max' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read7'
   */
  ECTminmax_h(*rtd_LEVEL, rtb_out_l1);

  /* Lookup_n-D: '<S874>/blower для текущего ECT' incorporates:
   *  DataStoreRead: '<S874>/engine coolant temp'
   *  DataStoreWrite: '<S825>/Data Store Write5'
   */
  *rtd_Blower_RR = look1_iu16bs16lu64n32_binlcse(*rtd_ECT, rtb_out_l1,
    rtb_out_bd, 1U);

  /* DataStoreWrite: '<S825>/Data Store Write6' incorporates:
   *  DataStoreWrite: '<S825>/Data Store Write5'
   */
  *rtd_Blower_RL = *rtd_Blower_RR;

  /* MATLAB Function: '<S825>/Dtg_rear' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read8'
   */
  Dtg_rear(*rtd_LEVEL, &rtb_out_m1);

  /* DataStoreWrite: '<S825>/Data Store Write10' */
  *rtd_Dtg_RR = rtb_out_m1;

  /* DataStoreWrite: '<S825>/Data Store Write11' */
  *rtd_Dtg_RL = rtb_out_m1;

  /* DataStoreWrite: '<S825>/Data Store Write7' incorporates:
   *  Constant: '<S825>/Recirc logic Partial REC'
   */
  *rtd_Recirculation = 1.0;

  /* RelationalOperator: '<S825>/Equal' incorporates:
   *  DataStoreRead: '<S825>/current step'
   */
  rtb_Equal_hg = (*rtd_step_start_controle_rear == 1);

  /* MATLAB Function: '<S825>/Incar temp goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read3'
   */
  Incartempgotofromstep1tostep2_b(*rtd_LEVEL, &rtb_out_hj);

  /* Sum: '<S872>/Subtract' incorporates:
   *  DataStoreRead: '<S872>/Data Store Read4'
   *  UnitDelay: '<S872>/t_start_delay_private '
   */
  rtb_dt_k = *rtd_t_now - localDW->t_start_delay_private_DSTATE;

  /* MATLAB Function: '<S825>/Time goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S825>/Data Store Read4'
   */
  Timegotofromstep1tostep2_h(*rtd_LEVEL, &rtb_out_a4);

  /* Switch: '<S872>/Switch' incorporates:
   *  DataStoreRead: '<S872>/Data Store Read4'
   *  Logic: '<S872>/Logical Operator3'
   *  Logic: '<S872>/Logical Operator4'
   *  UnitDelay: '<S872>/Cond_prev_private '
   *  UnitDelay: '<S872>/t_start_delay_private '
   */
  if (rtb_Equal_hg && (!localDW->Cond_prev_private_DSTATE)) {
    localDW->t_start_delay_private_DSTATE = *rtd_t_now;
  }

  /* End of Switch: '<S872>/Switch' */

  /* Switch: '<S825>/Switch' incorporates:
   *  Constant: '<S825>/go to next step'
   *  Constant: '<S825>/stay at step 1'
   *  DataStoreRead: '<S825>/incar temp'
   *  Gain: '<S825>/из сек в мс'
   *  Logic: '<S825>/Logical Operator'
   *  RelationalOperator: '<S825>/Relational Operator'
   *  RelationalOperator: '<S825>/Relational Operator1'
   */
  if ((*rtd_Incar_RR > rtb_out_hj) || (rtb_dt_k > (uint16_t)(1000 * rtb_out_a4)))
  {
    *rty_step = 2;
  } else {
    *rty_step = 1;
  }

  /* End of Switch: '<S825>/Switch' */

  /* Update for UnitDelay: '<S872>/Cond_prev_private ' */
  localDW->Cond_prev_private_DSTATE = rtb_Equal_hg;
}

/*
 * Output and update for atomic system:
 *    '<S898>/time for step'
 *    '<S921>/time for step'
 *    '<S944>/time for step'
 *    '<S967>/time for step'
 *    '<S990>/time for step'
 *    '<S1013>/time for step'
 */
void timeforstep_fu(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_DUCT_TGT_STEP2_RX(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_DUCT_TGT_STEP2_RX[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S901>/blower step'
 *    '<S924>/blower step'
 *    '<S947>/blower step'
 *    '<S970>/blower step'
 *    '<S993>/blower step'
 *    '<S1016>/blower step'
 */
void blowerstep_j(uint8_t rtu_LVL, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_ausSTART_BLR_SPD_STEP2_R(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausSTART_BLR_SPD_STEP2_R[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S901>/blower time for step'
 *    '<S924>/blower time for step'
 *    '<S947>/blower time for step'
 *    '<S970>/blower time for step'
 *    '<S993>/blower time for step'
 *    '<S1016>/blower time for step'
 */
void blowertimeforstep_a(uint8_t rtu_LVL, uint16_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_ausSTART_BLR_SPD_STEP2_R(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_ausSTART_BLR_SPD_STEP2_R[tmp_0 - 1];
}

/*
 * Output and update for atomic system:
 *    '<S904>/step'
 *    '<S927>/step'
 *    '<S950>/step'
 *    '<S973>/step'
 *    '<S996>/step'
 *    '<S1019>/step'
 */
void step_c(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;

  /* :  out = g_aucSTART_VALVE_CHANGE_SPD_R(LVL + 1); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_aucSTART_VALVE_CHANGE_SPD_R[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S904>/time for step'
 *    '<S927>/time for step'
 *    '<S950>/time for step'
 *    '<S973>/time for step'
 *    '<S996>/time for step'
 *    '<S1019>/time for step'
 */
void timeforstep_h(uint8_t rtu_LVL, uint8_t *rty_out)
{
  int32_t tmp;
  int32_t tmp_0;

  /* :  out = g_aucSTART_VALVE_CHANGE_SPD_R(LVL + 1 + 6); */
  tmp = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp = 255;
  }

  tmp_0 = (int32_t)((uint32_t)tmp + 6U);
  if ((uint32_t)tmp + 6U > 255U) {
    tmp_0 = 255;
  }

  *rty_out = g_aucSTART_VALVE_CHANGE_SPD_R[tmp_0 - 1];
}

/*
 * Output and update for action system:
 *    '<S782>/Level 0'
 *    '<S782>/Level 1'
 */
void Level0_j(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 *
              rtd_Dtg_RR, const uint8_t *rtd_Dtg_logic_RR, uint8_t
              *rtd_Incar_filter_down_value, uint8_t *rtd_Incar_filter_up_value,
              const uint8_t *rtd_LEVEL, uint8_t *rtd_Mode_RL, uint8_t
              *rtd_Mode_RR, const uint8_t *rtd_Mode_logic_RR, double
              *rtd_Recirculation, uint8_t *rtd_Valve_2_way, const int8_t
              *rtd_step_start_controle_rear, const uint32_t *rtd_t_now,
              DW_Level0_n *localDW)
{
  int32_t tmp;
  uint32_t rtb_dt_l;
  int16_t rtb_out_gw;
  uint16_t rtb_out_jki;
  uint16_t rtb_out_ma;
  uint8_t rtb_out_ke;
  uint8_t rtb_out_mz;
  bool rtb_RelationalOperator1_em;

  /* DataStoreWrite: '<S891>/Data Store Write9' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read6'
   *  MATLAB Function: '<S891>/2 way valve'
   */
  uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);

  /* MATLAB Function: '<S898>/step' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read8'
   */
  Dtg_rear(*rtd_LEVEL, &rtb_out_mz);

  /* MATLAB Function: '<S898>/time for step' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read8'
   */
  timeforstep_fu(*rtd_LEVEL, &rtb_out_ke);

  /* Switch: '<S898>/Switch' incorporates:
   *  Constant: '<S898>/Constant'
   *  Constant: '<S905>/epsilon'
   *  DataStoreRead: '<S898>/Текущее значение blower '
   *  DataStoreRead: '<S898>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S898>/текущее время в мс'
   *  DataStoreWrite: '<S891>/Data Store Write10'
   *  Product: '<S898>/Product1'
   *  Product: '<S898>/change rate (dtg//sec)'
   *  Product: '<S898>/скорость в мс'
   *  Product: '<S898>/шаг изменения'
   *  RelationalOperator: '<S905>/Relational Operator'
   *  RelationalOperator: '<S909>/Relational Operator'
   *  Sum: '<S898>/Add'
   *  Sum: '<S905>/Add'
   *  Sum: '<S906>/Subtract'
   *  Switch: '<S909>/Switch'
   *  UnitDelay: '<S906>/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: '<S909>/Switch' incorporates:
       *  Constant: '<S909>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S909>/Switch' incorporates:
       *  Constant: '<S909>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Dtg_RR = (uint8_t)((double)rtb_out_mz / (double)rtb_out_ke / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE) * (double)tmp + (double)*
      rtd_Dtg_RR);
  }

  /* End of Switch: '<S898>/Switch' */

  /* DataStoreWrite: '<S891>/Data Store Write11' incorporates:
   *  DataStoreWrite: '<S891>/Data Store Write10'
   */
  *rtd_Dtg_RL = *rtd_Dtg_RR;

  /* DataStoreWrite: '<S891>/Data Store Write' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read1'
   *  MATLAB Function: '<S891>/incar filter up'
   */
  incarfilterup_d(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S891>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read2'
   *  MATLAB Function: '<S891>/incar filter down'
   */
  incarfilterdown_j(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* Sum: '<S915>/Add' incorporates:
   *  DataStoreRead: '<S904>/Текущее значение blower '
   *  DataStoreRead: '<S904>/значение auto (в соответствии с логикой)'
   */
  rtb_out_mz = (uint8_t)(*rtd_Mode_RR - *rtd_Mode_logic_RR);

  /* RelationalOperator: '<S915>/Relational Operator' incorporates:
   *  Constant: '<S915>/epsilon'
   */
  rtb_RelationalOperator1_em = (rtb_out_mz <= 0.01);

  /* MATLAB Function: '<S904>/step' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read5'
   */
  step_c(*rtd_LEVEL, &rtb_out_ke);

  /* MATLAB Function: '<S904>/time for step' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read5'
   */
  timeforstep_h(*rtd_LEVEL, &rtb_out_mz);

  /* Switch: '<S904>/Switch' incorporates:
   *  Constant: '<S904>/Constant'
   *  DataStoreRead: '<S904>/Текущее значение blower '
   *  DataStoreRead: '<S904>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S904>/текущее время в мс'
   *  DataStoreWrite: '<S891>/Data Store Write2'
   *  Product: '<S904>/Product1'
   *  Product: '<S904>/change rate (step//sec)'
   *  Product: '<S904>/скорость в мс'
   *  Product: '<S904>/шаг изменения'
   *  RelationalOperator: '<S919>/Relational Operator'
   *  Sum: '<S904>/Add'
   *  Sum: '<S916>/Subtract'
   *  Switch: '<S919>/Switch'
   *  UnitDelay: '<S916>/Unit Delay'
   */
  if (rtb_RelationalOperator1_em) {
    *rtd_Mode_RR = *rtd_Mode_logic_RR;
  } else {
    if (*rtd_Mode_RR <= *rtd_Mode_logic_RR) {
      /* Switch: '<S919>/Switch' incorporates:
       *  Constant: '<S919>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S919>/Switch' incorporates:
       *  Constant: '<S919>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Mode_RR = (uint8_t)((double)rtb_out_ke / (double)rtb_out_mz / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_a) * (double)tmp + (double)*
      rtd_Mode_RR);
  }

  /* End of Switch: '<S904>/Switch' */

  /* DataStoreWrite: '<S891>/Data Store Write3' incorporates:
   *  DataStoreWrite: '<S891>/Data Store Write2'
   */
  *rtd_Mode_RL = *rtd_Mode_RR;

  /* MATLAB Function: '<S901>/blower step' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read7'
   */
  blowerstep_j(*rtd_LEVEL, &rtb_out_ma);

  /* MATLAB Function: '<S901>/blower time for step' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read7'
   */
  blowertimeforstep_a(*rtd_LEVEL, &rtb_out_jki);

  /* Switch: '<S901>/Switch' incorporates:
   *  Constant: '<S901>/Constant'
   *  Constant: '<S910>/epsilon'
   *  DataStoreRead: '<S901>/Текущее значение blower '
   *  DataStoreRead: '<S901>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S901>/текущее время в мс'
   *  DataStoreWrite: '<S891>/Data Store Write5'
   *  Product: '<S901>/Product1'
   *  Product: '<S901>/change rate (step//sec)'
   *  Product: '<S901>/скорость в мс'
   *  Product: '<S901>/шаг изменения'
   *  RelationalOperator: '<S910>/Relational Operator'
   *  RelationalOperator: '<S914>/Relational Operator'
   *  Sum: '<S901>/Add'
   *  Sum: '<S910>/Add'
   *  Sum: '<S911>/Subtract'
   *  Switch: '<S914>/Switch'
   *  UnitDelay: '<S911>/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: '<S914>/Switch' incorporates:
       *  Constant: '<S914>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S914>/Switch' incorporates:
       *  Constant: '<S914>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Blower_RR = (uint16_t)((double)rtb_out_ma / (double)rtb_out_jki /
      1000.0 * (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_l) * (double)tmp
      + (double)*rtd_Blower_RR);
  }

  /* End of Switch: '<S901>/Switch' */

  /* DataStoreWrite: '<S891>/Data Store Write6' incorporates:
   *  DataStoreWrite: '<S891>/Data Store Write5'
   */
  *rtd_Blower_RL = *rtd_Blower_RR;

  /* DataStoreWrite: '<S891>/Data Store Write7' incorporates:
   *  Constant: '<S891>/Recirc logic Partial REC'
   */
  *rtd_Recirculation = 1.0;

  /* RelationalOperator: '<S891>/Equal' incorporates:
   *  DataStoreRead: '<S891>/current step'
   */
  rtb_RelationalOperator1_em = (*rtd_step_start_controle_rear == 1);

  /* Sum: '<S899>/Subtract' incorporates:
   *  DataStoreRead: '<S899>/Data Store Read4'
   *  UnitDelay: '<S899>/t_start_delay_private '
   */
  rtb_dt_l = *rtd_t_now - localDW->t_start_delay_private_DSTATE;

  /* Switch: '<S899>/Switch' incorporates:
   *  DataStoreRead: '<S899>/Data Store Read4'
   *  Logic: '<S899>/Logical Operator3'
   *  Logic: '<S899>/Logical Operator4'
   *  UnitDelay: '<S899>/Cond_prev_private '
   *  UnitDelay: '<S899>/t_start_delay_private '
   */
  if (rtb_RelationalOperator1_em && (!localDW->Cond_prev_private_DSTATE)) {
    localDW->t_start_delay_private_DSTATE = *rtd_t_now;
  }

  /* End of Switch: '<S899>/Switch' */

  /* MATLAB Function: '<S891>/Time goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S891>/Data Store Read4'
   */
  Timegotofromstep1tostep2_h(*rtd_LEVEL, &rtb_out_gw);

  /* Switch: '<S891>/Switch' incorporates:
   *  Constant: '<S891>/go to next step'
   *  Constant: '<S891>/stay at step 1'
   *  Gain: '<S891>/из сек в мс'
   *  RelationalOperator: '<S891>/Relational Operator1'
   */
  if (rtb_dt_l > (uint16_t)(1000 * rtb_out_gw)) {
    *rty_step = 2;
  } else {
    *rty_step = 1;
  }

  /* End of Switch: '<S891>/Switch' */

  /* Update for UnitDelay: '<S906>/Unit Delay' incorporates:
   *  DataStoreRead: '<S898>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE = *rtd_t_now;

  /* Update for UnitDelay: '<S916>/Unit Delay' incorporates:
   *  DataStoreRead: '<S904>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_a = *rtd_t_now;

  /* Update for UnitDelay: '<S911>/Unit Delay' incorporates:
   *  DataStoreRead: '<S901>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_l = *rtd_t_now;

  /* Update for UnitDelay: '<S899>/Cond_prev_private ' */
  localDW->Cond_prev_private_DSTATE = rtb_RelationalOperator1_em;
}

/*
 * Output and update for action system:
 *    '<S782>/Level 2'
 *    '<S782>/Level 3'
 *    '<S782>/Level 4'
 *    '<S782>/Level 5'
 */
void Level2(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
            *rtd_Dtg_RR, const uint8_t *rtd_Dtg_logic_RR, const bool
            *rtd_HI_logic_on, uint8_t *rtd_Incar_filter_down_value, uint8_t
            *rtd_Incar_filter_up_value, const uint8_t *rtd_LEVEL, uint8_t
            *rtd_Mode_RL, uint8_t *rtd_Mode_RR, const uint8_t *rtd_Mode_logic_RR,
            double *rtd_Recirculation, uint8_t *rtd_Valve_2_way, const int8_t
            *rtd_step_start_controle_rear, const uint32_t *rtd_t_now, DW_Level2 *
            localDW)
{
  int32_t tmp;
  uint32_t rtb_dt_h;
  int16_t rtb_out_aa;
  uint16_t rtb_out_i3;
  uint16_t rtb_out_oi;
  uint8_t rtb_out_b2p;
  uint8_t rtb_out_cy;
  bool rtb_Cond_prev_private_ax;

  /* DataStoreWrite: '<S893>/Data Store Write9' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read6'
   *  MATLAB Function: '<S893>/2 way valve'
   */
  uwayvalve(*rtd_LEVEL, rtd_Valve_2_way);

  /* MATLAB Function: '<S944>/step' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read8'
   */
  Dtg_rear(*rtd_LEVEL, &rtb_out_b2p);

  /* MATLAB Function: '<S944>/time for step' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read8'
   */
  timeforstep_fu(*rtd_LEVEL, &rtb_out_cy);

  /* Switch: '<S944>/Switch' incorporates:
   *  Constant: '<S944>/Constant'
   *  Constant: '<S951>/epsilon'
   *  DataStoreRead: '<S944>/Текущее значение blower '
   *  DataStoreRead: '<S944>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S944>/текущее время в мс'
   *  DataStoreWrite: '<S893>/Data Store Write10'
   *  Product: '<S944>/Product1'
   *  Product: '<S944>/change rate (dtg//sec)'
   *  Product: '<S944>/скорость в мс'
   *  Product: '<S944>/шаг изменения'
   *  RelationalOperator: '<S951>/Relational Operator'
   *  RelationalOperator: '<S955>/Relational Operator'
   *  Sum: '<S944>/Add'
   *  Sum: '<S951>/Add'
   *  Sum: '<S952>/Subtract'
   *  Switch: '<S955>/Switch'
   *  UnitDelay: '<S952>/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: '<S955>/Switch' incorporates:
       *  Constant: '<S955>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S955>/Switch' incorporates:
       *  Constant: '<S955>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Dtg_RR = (uint8_t)((double)rtb_out_b2p / (double)rtb_out_cy / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE) * (double)tmp + (double)*
      rtd_Dtg_RR);
  }

  /* End of Switch: '<S944>/Switch' */

  /* DataStoreWrite: '<S893>/Data Store Write11' incorporates:
   *  DataStoreWrite: '<S893>/Data Store Write10'
   */
  *rtd_Dtg_RL = *rtd_Dtg_RR;

  /* DataStoreWrite: '<S893>/Data Store Write' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read1'
   *  MATLAB Function: '<S893>/incar filter up'
   */
  incarfilterup_d(*rtd_LEVEL, rtd_Incar_filter_up_value);

  /* DataStoreWrite: '<S893>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read2'
   *  MATLAB Function: '<S893>/incar filter down'
   */
  incarfilterdown_j(*rtd_LEVEL, rtd_Incar_filter_down_value);

  /* Sum: '<S961>/Add' incorporates:
   *  DataStoreRead: '<S950>/Текущее значение blower '
   *  DataStoreRead: '<S950>/значение auto (в соответствии с логикой)'
   */
  rtb_out_b2p = (uint8_t)(*rtd_Mode_RR - *rtd_Mode_logic_RR);

  /* RelationalOperator: '<S961>/Relational Operator' incorporates:
   *  Constant: '<S961>/epsilon'
   */
  rtb_Cond_prev_private_ax = (rtb_out_b2p <= 0.01);

  /* MATLAB Function: '<S950>/step' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read5'
   */
  step_c(*rtd_LEVEL, &rtb_out_cy);

  /* MATLAB Function: '<S950>/time for step' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read5'
   */
  timeforstep_h(*rtd_LEVEL, &rtb_out_b2p);

  /* Switch: '<S950>/Switch' incorporates:
   *  Constant: '<S950>/Constant'
   *  DataStoreRead: '<S950>/Текущее значение blower '
   *  DataStoreRead: '<S950>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S950>/текущее время в мс'
   *  DataStoreWrite: '<S893>/Data Store Write2'
   *  Product: '<S950>/Product1'
   *  Product: '<S950>/change rate (step//sec)'
   *  Product: '<S950>/скорость в мс'
   *  Product: '<S950>/шаг изменения'
   *  RelationalOperator: '<S965>/Relational Operator'
   *  Sum: '<S950>/Add'
   *  Sum: '<S962>/Subtract'
   *  Switch: '<S965>/Switch'
   *  UnitDelay: '<S962>/Unit Delay'
   */
  if (rtb_Cond_prev_private_ax) {
    *rtd_Mode_RR = *rtd_Mode_logic_RR;
  } else {
    if (*rtd_Mode_RR <= *rtd_Mode_logic_RR) {
      /* Switch: '<S965>/Switch' incorporates:
       *  Constant: '<S965>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S965>/Switch' incorporates:
       *  Constant: '<S965>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Mode_RR = (uint8_t)((double)rtb_out_cy / (double)rtb_out_b2p / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_j) * (double)tmp + (double)*
      rtd_Mode_RR);
  }

  /* End of Switch: '<S950>/Switch' */

  /* DataStoreWrite: '<S893>/Data Store Write3' incorporates:
   *  DataStoreWrite: '<S893>/Data Store Write2'
   */
  *rtd_Mode_RL = *rtd_Mode_RR;

  /* MATLAB Function: '<S947>/blower step' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read7'
   */
  blowerstep_j(*rtd_LEVEL, &rtb_out_i3);

  /* MATLAB Function: '<S947>/blower time for step' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read7'
   */
  blowertimeforstep_a(*rtd_LEVEL, &rtb_out_oi);

  /* Switch: '<S947>/Switch' incorporates:
   *  Constant: '<S947>/Constant'
   *  Constant: '<S956>/epsilon'
   *  DataStoreRead: '<S947>/Текущее значение blower '
   *  DataStoreRead: '<S947>/значение auto (в соответствии с логикой)'
   *  DataStoreRead: '<S947>/текущее время в мс'
   *  DataStoreWrite: '<S893>/Data Store Write5'
   *  Product: '<S947>/Product1'
   *  Product: '<S947>/change rate (step//sec)'
   *  Product: '<S947>/скорость в мс'
   *  Product: '<S947>/шаг изменения'
   *  RelationalOperator: '<S956>/Relational Operator'
   *  RelationalOperator: '<S960>/Relational Operator'
   *  Sum: '<S947>/Add'
   *  Sum: '<S956>/Add'
   *  Sum: '<S957>/Subtract'
   *  Switch: '<S960>/Switch'
   *  UnitDelay: '<S957>/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: '<S960>/Switch' incorporates:
       *  Constant: '<S960>/Constant'
       */
      tmp = 1;
    } else {
      /* Switch: '<S960>/Switch' incorporates:
       *  Constant: '<S960>/Constant1'
       */
      tmp = -1;
    }

    *rtd_Blower_RR = (uint16_t)((double)rtb_out_i3 / (double)rtb_out_oi / 1000.0
      * (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_m) * (double)tmp +
      (double)*rtd_Blower_RR);
  }

  /* End of Switch: '<S947>/Switch' */

  /* DataStoreWrite: '<S893>/Data Store Write6' incorporates:
   *  DataStoreWrite: '<S893>/Data Store Write5'
   */
  *rtd_Blower_RL = *rtd_Blower_RR;

  /* DataStoreWrite: '<S893>/Data Store Write7' incorporates:
   *  Constant: '<S893>/Recirc logic Partial REC'
   */
  *rtd_Recirculation = 1.0;

  /* RelationalOperator: '<S893>/Equal' incorporates:
   *  DataStoreRead: '<S893>/current step'
   */
  rtb_Cond_prev_private_ax = (*rtd_step_start_controle_rear == 1);

  /* Sum: '<S945>/Subtract' incorporates:
   *  DataStoreRead: '<S945>/Data Store Read4'
   *  UnitDelay: '<S945>/t_start_delay_private '
   */
  rtb_dt_h = *rtd_t_now - localDW->t_start_delay_private_DSTATE;

  /* MATLAB Function: '<S893>/Time goto from step 1 to step 2 ' incorporates:
   *  DataStoreRead: '<S893>/Data Store Read4'
   */
  Timegotofromstep1tostep2_h(*rtd_LEVEL, &rtb_out_aa);

  /* Switch: '<S945>/Switch' incorporates:
   *  DataStoreRead: '<S945>/Data Store Read4'
   *  Logic: '<S945>/Logical Operator3'
   *  Logic: '<S945>/Logical Operator4'
   *  UnitDelay: '<S945>/Cond_prev_private '
   *  UnitDelay: '<S945>/t_start_delay_private '
   */
  if (rtb_Cond_prev_private_ax && (!localDW->Cond_prev_private_DSTATE)) {
    localDW->t_start_delay_private_DSTATE = *rtd_t_now;
  }

  /* End of Switch: '<S945>/Switch' */

  /* Switch: '<S893>/Switch' incorporates:
   *  Constant: '<S893>/go to next step'
   *  Constant: '<S893>/stay at step 1'
   *  DataStoreRead: '<S893>/Data Store Read'
   *  Gain: '<S893>/из сек в мс'
   *  Logic: '<S893>/Logical Operator'
   *  RelationalOperator: '<S893>/Relational Operator1'
   */
  if ((rtb_dt_h > (uint16_t)(1000 * rtb_out_aa)) || (*rtd_HI_logic_on)) {
    *rty_step = 2;
  } else {
    *rty_step = 1;
  }

  /* End of Switch: '<S893>/Switch' */

  /* Update for UnitDelay: '<S952>/Unit Delay' incorporates:
   *  DataStoreRead: '<S944>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE = *rtd_t_now;

  /* Update for UnitDelay: '<S962>/Unit Delay' incorporates:
   *  DataStoreRead: '<S950>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_j = *rtd_t_now;

  /* Update for UnitDelay: '<S957>/Unit Delay' incorporates:
   *  DataStoreRead: '<S947>/текущее время в мс'
   */
  localDW->UnitDelay_DSTATE_m = *rtd_t_now;

  /* Update for UnitDelay: '<S945>/Cond_prev_private ' */
  localDW->Cond_prev_private_DSTATE = rtb_Cond_prev_private_ax;
}

/* Model step function */
void HVAC_model_step(void)
{
  double rtb_Divide1_ja[9];
  double rtb_Divide1;
  double rtb_Divide3;
  int32_t i;
  int32_t tmp_0;
  uint32_t rtb_dt_du;
  uint32_t rtb_dt_h;
  int16_t tmp[6];
  int16_t rtb_out_nh[2];
  int16_t AMB;
  int16_t Eva_F;
  int16_t Eva_R;
  int16_t Incar_FL;
  int16_t Incar_FR;
  int16_t Incar_RL;
  int16_t Incar_RR;
  int16_t Pressure;
  uint16_t Merge[9];
  uint16_t rtb_vals_m[9];
  uint16_t rtb_out_fw[2];
  uint16_t Blower_FR;
  uint16_t rtb_out_jk;
  int8_t rtb_Switch_hx;
  uint8_t rtb_get_modes_for_levels[78];
  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;
  uint8_t rtb_Gain_l;
  uint8_t rtb_u_pe;
  bool rtb_RelationalOperator_htm[9];
  bool rtb_FailCond;
  bool rtb_FailCond_a;
  bool rtb_FailCond_b;
  bool rtb_FailCond_e;
  bool rtb_FailCond_f;
  bool rtb_FailCond_g;
  bool rtb_FailCond_l;
  bool rtb_FailCond_mg;
  bool rtb_LogicalOperator1;
  bool rtb_LogicalOperator1_ca;
  bool rtb_LogicalOperator1_f;
  bool rtb_LogicalOperator1_k;
  bool rtb_LogicalOperator1_lc;
  bool rtb_LogicalOperator1_lk;
  bool rtb_LogicalOperator3_f3;
  bool rtb_LogicalOperator3_oi;

  /* Product: '<S251>/Divide1' incorporates:
   *  Constant: '<S251>/Constant'
   *  Constant: '<S251>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S251>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.Sensor_Ambient_Temp / 4095.0 * 5.0;

  /* Logic: '<S251>/Logical Operator' incorporates:
   *  Constant: '<S293>/Constant'
   *  Constant: '<S294>/Constant'
   *  RelationalOperator: '<S293>/Compare'
   *  RelationalOperator: '<S294>/Compare'
   */
  rtb_FailCond = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

  /* Logic: '<S251>/Logical Operator1' incorporates:
   *  Constant: '<S295>/Constant'
   *  DataStoreRead: '<S296>/Data Store Read4'
   *  RelationalOperator: '<S295>/Compare'
   *  Sum: '<S296>/Subtract'
   *  UnitDelay: '<S296>/t_start_delay_private '
   */
  rtb_LogicalOperator1 = (rtb_FailCond && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE >= 3000U));

  /* Switch: '<S251>/Switch' incorporates:
   *  Constant: '<S251>/Constant2'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S251>/Data Store Write'
   *  Lookup_n-D: '<S251>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1) {
    AMB = 100;
  } else {
    AMB = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Ambient_Temp,
      rtConstP.pooled32, rtConstP.uDLookupTable_tableData, 1023U);
  }

  /* End of Switch: '<S251>/Switch' */

  /* MATLAB Function: '<S251>/Write Ambient' incorporates:
   *  DataStoreRead: '<S251>/Data Store Read'
   *  DataStoreWrite: '<S251>/Data Store Write'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Ambient = %d * 0.1 C\n',Ambient); */
    printf("Ambient = %d * 0.1 C\n", AMB);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S251>/Write Ambient' */

  /* MATLAB Function: '<S251>/Write ERROR' incorporates:
   *  DataStoreRead: '<S251>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1) {
    /* :  if(AmbientErr) */
    /* :  fprintf('CCU_Body_Err.CCU_AmbienTemptSenErr_Stat = 0x1 (Failure), Sensor_Ambient_Temp = %f V\n',Sensor_Ambient_Temp); */
    printf("CCU_Body_Err.CCU_AmbienTemptSenErr_Stat = 0x1 (Failure), Sensor_Ambient_Temp = %f V\n",
           rtb_Divide1);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S251>/Write ERROR' */

  /* Switch: '<S296>/Switch' incorporates:
   *  DataStoreRead: '<S296>/Data Store Read4'
   *  Logic: '<S296>/Logical Operator3'
   *  Logic: '<S296>/Logical Operator4'
   *  UnitDelay: '<S296>/Cond_prev_private '
   *  UnitDelay: '<S296>/t_start_delay_private '
   */
  if (rtb_FailCond && (!rtDW.Cond_prev_private_DSTATE)) {
    rtDW.t_start_delay_private_DSTATE = rtDW.t_now;
  }

  /* End of Switch: '<S296>/Switch' */

  /* Product: '<S252>/Divide1' incorporates:
   *  Constant: '<S252>/Constant'
   *  Constant: '<S252>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S252>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.Sensor_Evap_Temp / 4095.0 * 5.0;

  /* Logic: '<S252>/Logical Operator' incorporates:
   *  Constant: '<S300>/Constant'
   *  Constant: '<S301>/Constant'
   *  RelationalOperator: '<S300>/Compare'
   *  RelationalOperator: '<S301>/Compare'
   */
  rtb_FailCond_f = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

  /* Logic: '<S252>/Logical Operator1' incorporates:
   *  Constant: '<S302>/Constant'
   *  DataStoreRead: '<S303>/Data Store Read4'
   *  RelationalOperator: '<S302>/Compare'
   *  Sum: '<S303>/Subtract'
   *  UnitDelay: '<S303>/t_start_delay_private '
   */
  rtb_LogicalOperator1_f = (rtb_FailCond_f && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_p >= 3000U));

  /* Switch: '<S252>/Switch' incorporates:
   *  Constant: '<S252>/Constant2'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S252>/Data Store Write1'
   *  Lookup_n-D: '<S252>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1_f) {
    Eva_F = -100;
  } else {
    Eva_F = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Evap_Temp,
      rtConstP.pooled32, rtConstP.pooled3, 1023U);
  }

  /* End of Switch: '<S252>/Switch' */

  /* MATLAB Function: '<S252>/Write ERROR' incorporates:
   *  DataStoreRead: '<S252>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_f) {
    /* :  if(EvapFErr) */
    /* :  fprintf('CCU_Body_Err.CCU_EvaTempSenErrF_Stat = 0x1 (Failure), Sensor_Evap_Temp = %f V\n',Sensor_Evap_Temp); */
    printf("CCU_Body_Err.CCU_EvaTempSenErrF_Stat = 0x1 (Failure), Sensor_Evap_Temp = %f V\n",
           rtb_Divide1);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S252>/Write ERROR' */

  /* MATLAB Function: '<S252>/Write Eva_F' incorporates:
   *  DataStoreRead: '<S252>/Data Store Read'
   *  DataStoreWrite: '<S252>/Data Store Write1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Eva_F = %d * 0.1 C\n',Eva_F); */
    printf("Eva_F = %d * 0.1 C\n", Eva_F);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S252>/Write Eva_F' */

  /* Switch: '<S303>/Switch' incorporates:
   *  DataStoreRead: '<S303>/Data Store Read4'
   *  Logic: '<S303>/Logical Operator3'
   *  Logic: '<S303>/Logical Operator4'
   *  UnitDelay: '<S303>/Cond_prev_private '
   *  UnitDelay: '<S303>/t_start_delay_private '
   */
  if (rtb_FailCond_f && (!rtDW.Cond_prev_private_DSTATE_h)) {
    rtDW.t_start_delay_private_DSTATE_p = rtDW.t_now;
  }

  /* End of Switch: '<S303>/Switch' */

  /* Product: '<S253>/Divide1' incorporates:
   *  Constant: '<S253>/Constant'
   *  Constant: '<S253>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S253>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.Sensor_Rear_Evap_Temp / 4095.0 * 5.0;

  /* Logic: '<S253>/Logical Operator' incorporates:
   *  Constant: '<S307>/Constant'
   *  Constant: '<S308>/Constant'
   *  RelationalOperator: '<S307>/Compare'
   *  RelationalOperator: '<S308>/Compare'
   */
  rtb_FailCond_g = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

  /* Logic: '<S253>/Logical Operator1' incorporates:
   *  Constant: '<S309>/Constant'
   *  DataStoreRead: '<S310>/Data Store Read4'
   *  RelationalOperator: '<S309>/Compare'
   *  Sum: '<S310>/Subtract'
   *  UnitDelay: '<S310>/t_start_delay_private '
   */
  rtb_LogicalOperator1_k = (rtb_FailCond_g && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_pk >= 3000U));

  /* Switch: '<S253>/Switch' incorporates:
   *  Constant: '<S253>/Constant2'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S253>/Data Store Write1'
   *  Lookup_n-D: '<S253>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1_k) {
    Eva_R = -100;
  } else {
    Eva_R = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Rear_Evap_Temp,
      rtConstP.pooled32, rtConstP.pooled3, 1023U);
  }

  /* End of Switch: '<S253>/Switch' */

  /* MATLAB Function: '<S253>/Write ERROR' incorporates:
   *  DataStoreRead: '<S253>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_k) {
    /* :  if(EvapRErr) */
    /* :  fprintf('CCU_Body_Err.CCU_EvaTempSenErrR_Stat = 0x1 (Failure), Sensor_Rear_Evap_Temp = %f V\n',Sensor_Rear_Evap_Temp); */
    printf("CCU_Body_Err.CCU_EvaTempSenErrR_Stat = 0x1 (Failure), Sensor_Rear_Evap_Temp = %f V\n",
           rtb_Divide1);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S253>/Write ERROR' */

  /* MATLAB Function: '<S253>/Write Eva_F' incorporates:
   *  DataStoreRead: '<S253>/Data Store Read'
   *  DataStoreWrite: '<S253>/Data Store Write1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Eva_R = %d * 0.1 C\n',Eva_R); */
    printf("Eva_R = %d * 0.1 C\n", Eva_R);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S253>/Write Eva_F' */

  /* Switch: '<S310>/Switch' incorporates:
   *  DataStoreRead: '<S310>/Data Store Read4'
   *  Logic: '<S310>/Logical Operator3'
   *  Logic: '<S310>/Logical Operator4'
   *  UnitDelay: '<S310>/Cond_prev_private '
   *  UnitDelay: '<S310>/t_start_delay_private '
   */
  if (rtb_FailCond_g && (!rtDW.Cond_prev_private_DSTATE_i)) {
    rtDW.t_start_delay_private_DSTATE_pk = rtDW.t_now;
  }

  /* End of Switch: '<S310>/Switch' */

  /* Product: '<S269>/Divide1' incorporates:
   *  Constant: '<S269>/Constant'
   *  Constant: '<S269>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S269>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.Sensor_AC_Pressure / 4095.0 * 5.0;

  /* Logic: '<S269>/Logical Operator' incorporates:
   *  Constant: '<S329>/Constant'
   *  Constant: '<S330>/Constant'
   *  RelationalOperator: '<S329>/Compare'
   *  RelationalOperator: '<S330>/Compare'
   */
  rtb_FailCond_mg = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

  /* Logic: '<S269>/Logical Operator1' incorporates:
   *  Constant: '<S331>/Constant'
   *  DataStoreRead: '<S332>/Data Store Read4'
   *  RelationalOperator: '<S331>/Compare'
   *  Sum: '<S332>/Subtract'
   *  UnitDelay: '<S332>/t_start_delay_private '
   */
  rtb_LogicalOperator1_lk = (rtb_FailCond_mg && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_e >= 3000U));

  /* Switch: '<S269>/Switch' incorporates:
   *  Constant: '<S269>/Constant2'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S269>/Data Store Write'
   *  Lookup_n-D: '<S269>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1_lk) {
    Pressure = 32;
  } else {
    Pressure = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_AC_Pressure,
      rtConstP.pooled32, rtConstP.uDLookupTable_tableData_f, 1023U);
  }

  /* End of Switch: '<S269>/Switch' */

  /* MATLAB Function: '<S269>/Write' incorporates:
   *  DataStoreRead: '<S269>/Data Store Read'
   *  DataStoreWrite: '<S269>/Data Store Write'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('AC_Pressure = %d * ATM\n',AC_Pressure); */
    printf("AC_Pressure = %d * ATM\n", Pressure);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S269>/Write' */

  /* MATLAB Function: '<S269>/Write ERROR' incorporates:
   *  DataStoreRead: '<S269>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_lk) {
    /* :  if(AC_PressureErr) */
    /* :  fprintf('CCU_Body_Err.CCU_PressSenErr_Stat = 0x1 (Failure), Sensor_AC_Pressure = %f V\n',Sensor_AC_Pressure); */
    printf("CCU_Body_Err.CCU_PressSenErr_Stat = 0x1 (Failure), Sensor_AC_Pressure = %f V\n",
           rtb_Divide1);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S269>/Write ERROR' */

  /* Switch: '<S332>/Switch' incorporates:
   *  DataStoreRead: '<S332>/Data Store Read4'
   *  Logic: '<S332>/Logical Operator3'
   *  Logic: '<S332>/Logical Operator4'
   *  UnitDelay: '<S332>/Cond_prev_private '
   *  UnitDelay: '<S332>/t_start_delay_private '
   */
  if (rtb_FailCond_mg && (!rtDW.Cond_prev_private_DSTATE_e)) {
    rtDW.t_start_delay_private_DSTATE_e = rtDW.t_now;
  }

  /* End of Switch: '<S332>/Switch' */

  /* Product: '<S286>/Divide1' incorporates:
   *  Constant: '<S286>/Constant'
   *  Constant: '<S286>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S286>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.Sensor_Incar_Temp_FL / 4095.0 * 5.0;

  /* Logic: '<S286>/Logical Operator' incorporates:
   *  Constant: '<S352>/Constant'
   *  Constant: '<S353>/Constant'
   *  RelationalOperator: '<S352>/Compare'
   *  RelationalOperator: '<S353>/Compare'
   */
  rtb_FailCond_e = ((rtb_Divide1 < 0.15) || (rtb_Divide1 > 4.9));

  /* Logic: '<S286>/Logical Operator1' incorporates:
   *  Constant: '<S354>/Constant'
   *  DataStoreRead: '<S358>/Data Store Read4'
   *  RelationalOperator: '<S354>/Compare'
   *  Sum: '<S358>/Subtract'
   *  UnitDelay: '<S358>/t_start_delay_private '
   */
  rtb_LogicalOperator1_ca = (rtb_FailCond_e && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_b >= 3000U));

  /* Switch: '<S286>/Switch' incorporates:
   *  Constant: '<S286>/Constant2'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S286>/Data Store Write'
   *  Lookup_n-D: '<S286>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1_ca) {
    Incar_FL = 200;
  } else {
    Incar_FL = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_FL,
      rtConstP.pooled32, rtConstP.pooled4, 1023U);
  }

  /* End of Switch: '<S286>/Switch' */

  /* Product: '<S286>/Divide3' incorporates:
   *  Constant: '<S286>/Constant3'
   *  Constant: '<S286>/Constant4'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S286>/Divide2'
   */
  rtb_Divide3 = (double)rtDW.ADC_Data_Model.Sensor_Incar_Temp_RL / 4095.0 * 5.0;

  /* Logic: '<S286>/Logical Operator2' incorporates:
   *  Constant: '<S355>/Constant'
   *  Constant: '<S356>/Constant'
   *  RelationalOperator: '<S355>/Compare'
   *  RelationalOperator: '<S356>/Compare'
   */
  rtb_FailCond_a = ((rtb_Divide3 < 0.15) || (rtb_Divide3 > 4.9));

  /* Logic: '<S286>/Logical Operator3' incorporates:
   *  Constant: '<S357>/Constant'
   *  DataStoreRead: '<S359>/Data Store Read4'
   *  RelationalOperator: '<S357>/Compare'
   *  Sum: '<S359>/Subtract'
   *  UnitDelay: '<S359>/t_start_delay_private '
   */
  rtb_LogicalOperator3_f3 = (rtb_FailCond_a && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_j >= 3000U));

  /* Switch: '<S286>/Switch1' incorporates:
   *  Constant: '<S286>/Constant5'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S286>/Data Store Write1'
   *  Lookup_n-D: '<S286>/1-D Lookup Table1'
   */
  if (rtb_LogicalOperator3_f3) {
    Incar_RL = 200;
  } else {
    Incar_RL = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_RL,
      rtConstP.pooled32, rtConstP.pooled4, 1023U);
  }

  /* End of Switch: '<S286>/Switch1' */

  /* MATLAB Function: '<S286>/Write ERROR' incorporates:
   *  DataStoreRead: '<S286>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_ca) {
    /* :  if(IncarFLErr) */
    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_FL = %f V\n',Sensor_Incar_Temp_FL); */
    printf("CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_FL = %f V\n",
           rtb_Divide1);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S286>/Write ERROR' */

  /* MATLAB Function: '<S286>/Write ERROR1' incorporates:
   *  DataStoreRead: '<S286>/Data Store Read1'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator3_f3) {
    /* :  if(IncarRLErr) */
    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_RL = %f V\n',Sensor_Incar_Temp_RL); */
    printf("CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_RL = %f V\n",
           rtb_Divide3);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S286>/Write ERROR1' */

  /* MATLAB Function: '<S286>/Write IncarFL' incorporates:
   *  DataStoreRead: '<S286>/Data Store Read'
   *  DataStoreWrite: '<S286>/Data Store Write'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('IncarFL = %d * 0.1 C\n',IncarFL); */
    printf("IncarFL = %d * 0.1 C\n", Incar_FL);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S286>/Write IncarFL' */

  /* MATLAB Function: '<S286>/Write IncarRL' incorporates:
   *  DataStoreRead: '<S286>/Data Store Read1'
   *  DataStoreWrite: '<S286>/Data Store Write1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('IncarRL = %d * 0.1 C\n',IncarRL); */
    printf("IncarRL = %d * 0.1 C\n", Incar_RL);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S286>/Write IncarRL' */

  /* Switch: '<S358>/Switch' incorporates:
   *  DataStoreRead: '<S358>/Data Store Read4'
   *  Logic: '<S358>/Logical Operator3'
   *  Logic: '<S358>/Logical Operator4'
   *  UnitDelay: '<S358>/Cond_prev_private '
   *  UnitDelay: '<S358>/t_start_delay_private '
   */
  if (rtb_FailCond_e && (!rtDW.Cond_prev_private_DSTATE_c)) {
    rtDW.t_start_delay_private_DSTATE_b = rtDW.t_now;
  }

  /* End of Switch: '<S358>/Switch' */

  /* Switch: '<S359>/Switch' incorporates:
   *  DataStoreRead: '<S359>/Data Store Read4'
   *  Logic: '<S359>/Logical Operator3'
   *  Logic: '<S359>/Logical Operator4'
   *  UnitDelay: '<S359>/Cond_prev_private '
   *  UnitDelay: '<S359>/t_start_delay_private '
   */
  if (rtb_FailCond_a && (!rtDW.Cond_prev_private_DSTATE_b)) {
    rtDW.t_start_delay_private_DSTATE_j = rtDW.t_now;
  }

  /* End of Switch: '<S359>/Switch' */

  /* Product: '<S287>/Divide1' incorporates:
   *  Constant: '<S287>/Constant'
   *  Constant: '<S287>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S287>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.Sensor_Incar_Temp_FR / 4095.0 * 5.0;

  /* Logic: '<S287>/Logical Operator' incorporates:
   *  Constant: '<S366>/Constant'
   *  Constant: '<S367>/Constant'
   *  RelationalOperator: '<S366>/Compare'
   *  RelationalOperator: '<S367>/Compare'
   */
  rtb_FailCond_l = ((rtb_Divide1 < 0.15) || (rtb_Divide1 > 4.9));

  /* Logic: '<S287>/Logical Operator1' incorporates:
   *  Constant: '<S368>/Constant'
   *  DataStoreRead: '<S372>/Data Store Read4'
   *  RelationalOperator: '<S368>/Compare'
   *  Sum: '<S372>/Subtract'
   *  UnitDelay: '<S372>/t_start_delay_private '
   */
  rtb_LogicalOperator1_lc = (rtb_FailCond_l && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_bh >= 3000U));

  /* Switch: '<S287>/Switch' incorporates:
   *  Constant: '<S287>/Constant2'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S287>/Data Store Write1'
   *  Lookup_n-D: '<S287>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1_lc) {
    Incar_FR = 200;
  } else {
    Incar_FR = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_FR,
      rtConstP.pooled32, rtConstP.pooled4, 1023U);
  }

  /* End of Switch: '<S287>/Switch' */

  /* Product: '<S287>/Divide3' incorporates:
   *  Constant: '<S287>/Constant3'
   *  Constant: '<S287>/Constant4'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S287>/Divide2'
   */
  rtb_Divide3 = (double)rtDW.ADC_Data_Model.Sensor_Incar_Temp_RR / 4095.0 * 5.0;

  /* Logic: '<S287>/Logical Operator2' incorporates:
   *  Constant: '<S369>/Constant'
   *  Constant: '<S370>/Constant'
   *  RelationalOperator: '<S369>/Compare'
   *  RelationalOperator: '<S370>/Compare'
   */
  rtb_FailCond_b = ((rtb_Divide3 < 0.15) || (rtb_Divide3 > 4.9));

  /* Logic: '<S287>/Logical Operator3' incorporates:
   *  Constant: '<S371>/Constant'
   *  DataStoreRead: '<S373>/Data Store Read4'
   *  RelationalOperator: '<S371>/Compare'
   *  Sum: '<S373>/Subtract'
   *  UnitDelay: '<S373>/t_start_delay_private '
   */
  rtb_LogicalOperator3_oi = (rtb_FailCond_b && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_bx >= 3000U));

  /* Switch: '<S287>/Switch1' incorporates:
   *  Constant: '<S287>/Constant5'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  DataStoreWrite: '<S287>/Data Store Write2'
   *  Lookup_n-D: '<S287>/1-D Lookup Table1'
   */
  if (rtb_LogicalOperator3_oi) {
    Incar_RR = 200;
  } else {
    Incar_RR = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Incar_Temp_RR,
      rtConstP.pooled32, rtConstP.pooled4, 1023U);
  }

  /* End of Switch: '<S287>/Switch1' */

  /* MATLAB Function: '<S287>/Write ERROR' incorporates:
   *  DataStoreRead: '<S287>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_lc) {
    /* :  if(IncarRLErr) */
    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_FR = %f V\n',Sensor_Incar_Temp_FR); */
    printf("CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_FR = %f V\n",
           rtb_Divide1);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S287>/Write ERROR' */

  /* MATLAB Function: '<S287>/Write ERROR1' incorporates:
   *  DataStoreRead: '<S287>/Data Store Read1'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator3_oi) {
    /* :  if(IncarRLErr) */
    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_RR = %f V\n',Sensor_Incar_Temp_RR); */
    printf("CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_RR = %f V\n",
           rtb_Divide3);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S287>/Write ERROR1' */

  /* MATLAB Function: '<S287>/Write IncarFR' incorporates:
   *  DataStoreRead: '<S287>/Data Store Read'
   *  DataStoreWrite: '<S287>/Data Store Write1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('IncarFR = %d * 0.1 C\n',IncarFR); */
    printf("IncarFR = %d * 0.1 C\n", Incar_FR);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S287>/Write IncarFR' */

  /* MATLAB Function: '<S287>/Write IncarRR' incorporates:
   *  DataStoreRead: '<S287>/Data Store Read1'
   *  DataStoreWrite: '<S287>/Data Store Write2'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('IncarRR = %d * 0.1 C\n',IncarRR); */
    printf("IncarRR = %d * 0.1 C\n", Incar_RR);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S287>/Write IncarRR' */

  /* Switch: '<S372>/Switch' incorporates:
   *  DataStoreRead: '<S372>/Data Store Read4'
   *  Logic: '<S372>/Logical Operator3'
   *  Logic: '<S372>/Logical Operator4'
   *  UnitDelay: '<S372>/Cond_prev_private '
   *  UnitDelay: '<S372>/t_start_delay_private '
   */
  if (rtb_FailCond_l && (!rtDW.Cond_prev_private_DSTATE_j)) {
    rtDW.t_start_delay_private_DSTATE_bh = rtDW.t_now;
  }

  /* End of Switch: '<S372>/Switch' */

  /* Switch: '<S373>/Switch' incorporates:
   *  DataStoreRead: '<S373>/Data Store Read4'
   *  Logic: '<S373>/Logical Operator3'
   *  Logic: '<S373>/Logical Operator4'
   *  UnitDelay: '<S373>/Cond_prev_private '
   *  UnitDelay: '<S373>/t_start_delay_private '
   */
  if (rtb_FailCond_b && (!rtDW.Cond_prev_private_DSTATE_f)) {
    rtDW.t_start_delay_private_DSTATE_bx = rtDW.t_now;
  }

  /* End of Switch: '<S373>/Switch' */

  /* BusCreator: '<S2>/Bus Creator' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read10'
   *  DataStoreRead: '<S2>/Data Store Read11'
   *  DataStoreRead: '<S2>/Data Store Read4'
   *  DataStoreRead: '<S2>/Data Store Read5'
   *  DataStoreRead: '<S2>/Data Store Read6'
   *  DataStoreRead: '<S2>/Data Store Read7'
   *  DataStoreRead: '<S2>/Data Store Read8'
   *  DataStoreRead: '<S2>/Data Store Read9'
   *  DataStoreWrite: '<S2>/Data Store Write2'
   */
  Status_Sensor_Model.Battery = 0;
  Status_Sensor_Model.AMB = AMB;
  Status_Sensor_Model.Incar_FL = Incar_FL;
  Status_Sensor_Model.Incar_FR = Incar_FR;
  Status_Sensor_Model.Incar_RL = Incar_RL;
  Status_Sensor_Model.Incar_RR = Incar_RR;
  Status_Sensor_Model.Eva_F = Eva_F;
  Status_Sensor_Model.Eva_R = Eva_R;
  Status_Sensor_Model.Pressure = Pressure;
  Status_Sensor_Model.Duct_FL_Upper = 0;
  Status_Sensor_Model.Duct_FL_Lower = 0;
  Status_Sensor_Model.Duct_FR_Upper = 0;
  Status_Sensor_Model.Duct_FR_Lower = 0;
  Status_Sensor_Model.Duct_RL = 0;
  Status_Sensor_Model.Duct_RR = 0;
  Status_Sensor_Model.Duct_Side_FL = 0;
  Status_Sensor_Model.Duct_Side_FR = 0;
  Status_Sensor_Model.Duct_Side_RL = 0;
  Status_Sensor_Model.Duct_Side_RR = 0;
  Status_Sensor_Model.AQS = 0;

  /* DataStoreWrite: '<S2>/Data Store Write' incorporates:
   *  Constant: '<S2>/Constant'
   */
  rtDW.LOGGER_ACP = 0.0;

  /* Product: '<S254>/Divide1' incorporates:
   *  Constant: '<S254>/Constant'
   *  Constant: '<S254>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S254>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5120_2EKA_ShutoffValvePowerTXV1 /
    4095.0 * 5.0;

  /* MATLAB Function: '<S254>/Write' incorporates:
   *  Constant: '<S254>/Constant2'
   *  Constant: '<S254>/Constant3'
   *  DataStoreRead: '<S254>/Data Store Read'
   *  Product: '<S254>/Divide2'
   *  Product: '<S254>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5120_2EKA_ShutoffValvePowerTXV1 V = %f Iout = %f\n',U,I); */
    printf("BTS5120_2EKA_ShutoffValvePowerTXV1 V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S254>/Write' */

  /* Product: '<S255>/Divide1' incorporates:
   *  Constant: '<S255>/Constant'
   *  Constant: '<S255>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S255>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5120_2EKA_ShutoffValvePowerTXV2 /
    4095.0 * 5.0;

  /* MATLAB Function: '<S255>/Write' incorporates:
   *  Constant: '<S255>/Constant2'
   *  Constant: '<S255>/Constant3'
   *  DataStoreRead: '<S255>/Data Store Read'
   *  Product: '<S255>/Divide2'
   *  Product: '<S255>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5120_2EKA_ShutoffValvePowerTXV2 V = %f Iout = %f\n',U,I); */
    printf("BTS5120_2EKA_ShutoffValvePowerTXV2 V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S255>/Write' */

  /* Product: '<S256>/Divide1' incorporates:
   *  Constant: '<S256>/Constant'
   *  Constant: '<S256>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S256>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_ChannelPTCPower1 /
    4095.0 * 5.0;

  /* MATLAB Function: '<S256>/Write' incorporates:
   *  Constant: '<S256>/Constant2'
   *  Constant: '<S256>/Constant3'
   *  DataStoreRead: '<S256>/Data Store Read'
   *  Product: '<S256>/Divide2'
   *  Product: '<S256>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_ChannelPTCPower1 V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_ChannelPTCPower1 V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S256>/Write' */

  /* Product: '<S257>/Divide1' incorporates:
   *  Constant: '<S257>/Constant'
   *  Constant: '<S257>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S257>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_ChannelPTCPower2 /
    4095.0 * 5.0;

  /* MATLAB Function: '<S257>/Write' incorporates:
   *  Constant: '<S257>/Constant2'
   *  Constant: '<S257>/Constant3'
   *  DataStoreRead: '<S257>/Data Store Read'
   *  Product: '<S257>/Divide2'
   *  Product: '<S257>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_ChannelPTCPower2 V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_ChannelPTCPower2 V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S257>/Write' */

  /* Product: '<S258>/Divide1' incorporates:
   *  Constant: '<S258>/Constant'
   *  Constant: '<S258>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S258>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_FrontIncarMotor /
    4095.0 * 5.0;

  /* MATLAB Function: '<S258>/Write' incorporates:
   *  Constant: '<S258>/Constant2'
   *  Constant: '<S258>/Constant3'
   *  DataStoreRead: '<S258>/Data Store Read'
   *  Product: '<S258>/Divide2'
   *  Product: '<S258>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_FrontIncarMotor V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_FrontIncarMotor V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S258>/Write' */

  /* Product: '<S259>/Divide1' incorporates:
   *  Constant: '<S259>/Constant'
   *  Constant: '<S259>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S259>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_RearIncarMotor / 4095.0
    * 5.0;

  /* MATLAB Function: '<S259>/Write' incorporates:
   *  Constant: '<S259>/Constant2'
   *  Constant: '<S259>/Constant3'
   *  DataStoreRead: '<S259>/Data Store Read'
   *  Product: '<S259>/Divide2'
   *  Product: '<S259>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_RearIncarMotor V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_RearIncarMotor V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S259>/Write' */

  /* Product: '<S260>/Divide1' incorporates:
   *  Constant: '<S260>/Constant'
   *  Constant: '<S260>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S260>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_ReservePowerSupply /
    4095.0 * 5.0;

  /* MATLAB Function: '<S260>/Write' incorporates:
   *  Constant: '<S260>/Constant2'
   *  Constant: '<S260>/Constant3'
   *  DataStoreRead: '<S260>/Data Store Read'
   *  Product: '<S260>/Divide2'
   *  Product: '<S260>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_ReservePowerSupply V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_ReservePowerSupply V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S260>/Write' */

  /* Product: '<S261>/Divide1' incorporates:
   *  Constant: '<S261>/Constant'
   *  Constant: '<S261>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S261>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_ShutOFFValveFront /
    4095.0 * 5.0;

  /* MATLAB Function: '<S261>/Write' incorporates:
   *  Constant: '<S261>/Constant2'
   *  Constant: '<S261>/Constant3'
   *  DataStoreRead: '<S261>/Data Store Read'
   *  Product: '<S261>/Divide2'
   *  Product: '<S261>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_ShutOFFValveFront V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_ShutOFFValveFront V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S261>/Write' */

  /* Product: '<S262>/Divide1' incorporates:
   *  Constant: '<S262>/Constant'
   *  Constant: '<S262>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S262>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_ShutOFFValveRear /
    4095.0 * 5.0;

  /* MATLAB Function: '<S262>/Write' incorporates:
   *  Constant: '<S262>/Constant2'
   *  Constant: '<S262>/Constant3'
   *  DataStoreRead: '<S262>/Data Store Read'
   *  Product: '<S262>/Divide2'
   *  Product: '<S262>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_ShutOFFValveRear V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_ShutOFFValveRear V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S262>/Write' */

  /* Product: '<S263>/Divide1' incorporates:
   *  Constant: '<S263>/Constant'
   *  Constant: '<S263>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S263>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.BTS5180_2EKA_TwoWayValve / 4095.0 *
    5.0;

  /* MATLAB Function: '<S263>/Write' incorporates:
   *  Constant: '<S263>/Constant2'
   *  Constant: '<S263>/Constant3'
   *  DataStoreRead: '<S263>/Data Store Read'
   *  Product: '<S263>/Divide2'
   *  Product: '<S263>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('BTS5180_2EKA_TwoWayValve V = %f Iout = %f\n',U,I); */
    printf("BTS5180_2EKA_TwoWayValve V = %f Iout = %f\n", rtb_Divide1,
           rtb_Divide1 / 1200.0 * 550.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S263>/Write' */

  /* MATLAB Function: '<S264>/Write' incorporates:
   *  Constant: '<S264>/Constant'
   *  Constant: '<S264>/Constant1'
   *  DataStoreRead: '<S264>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S264>/Divide'
   *  Product: '<S264>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('IGN_ANS = %f V\n',data); */
    printf("IGN_ANS = %f V\n", (double)rtDW.ADC_Data_Model.IGN_ANS / 4095.0 *
           27.75);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S264>/Write' */

  /* MATLAB Function: '<S265>/Write' incorporates:
   *  Constant: '<S265>/Constant'
   *  Constant: '<S265>/Constant1'
   *  DataStoreRead: '<S265>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S265>/Divide'
   *  Product: '<S265>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('PBATT_CHECK V = %f\n',U); */
    printf("PBATT_CHECK V = %f\n", (double)rtDW.ADC_Data_Model.PBATT_CHECK /
           4095.0 * 33.4375);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S265>/Write' */

  /* MATLAB Function: '<S266>/Write' incorporates:
   *  Constant: '<S266>/Constant'
   *  Constant: '<S266>/Constant1'
   *  DataStoreRead: '<S266>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S266>/Divide'
   *  Product: '<S266>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Pressure_DIAG V = %f\n',U); */
    printf("Pressure_DIAG V = %f\n", (double)rtDW.ADC_Data_Model.Pressure_DIAG /
           4095.0 * 6.0638);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S266>/Write' */

  /* MATLAB Function: '<S267>/Write' incorporates:
   *  Constant: '<S267>/Constant'
   *  Constant: '<S267>/Constant1'
   *  DataStoreRead: '<S267>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S267>/Divide'
   *  Product: '<S267>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Reserve_Sensor_Duct_Temp_1 V = %f\n',U); */
    printf("Reserve_Sensor_Duct_Temp_1 V = %f\n", (double)
           rtDW.ADC_Data_Model.Reserve_Sensor_Duct_Temp_1 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S267>/Write' */

  /* MATLAB Function: '<S268>/Write' incorporates:
   *  Constant: '<S268>/Constant'
   *  Constant: '<S268>/Constant1'
   *  DataStoreRead: '<S268>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S268>/Divide'
   *  Product: '<S268>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Reserve_Sensor_Duct_Temp_2 V = %f\n',U); */
    printf("Reserve_Sensor_Duct_Temp_2 V = %f\n", (double)
           rtDW.ADC_Data_Model.Reserve_Sensor_Duct_Temp_2 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S268>/Write' */

  /* MATLAB Function: '<S270>/Write' incorporates:
   *  Constant: '<S270>/Constant'
   *  Constant: '<S270>/Constant1'
   *  DataStoreRead: '<S270>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S270>/Divide'
   *  Product: '<S270>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Front_Duct1 V = %f\n',U); */
    printf("Sensor_Front_Duct1 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Front_Duct1 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S270>/Write' */

  /* MATLAB Function: '<S271>/Write' incorporates:
   *  Constant: '<S271>/Constant'
   *  Constant: '<S271>/Constant1'
   *  DataStoreRead: '<S271>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S271>/Divide'
   *  Product: '<S271>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Front_Duct2 V = %f\n',U); */
    printf("Sensor_Front_Duct2 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Front_Duct2 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S271>/Write' */

  /* MATLAB Function: '<S272>/Write' incorporates:
   *  Constant: '<S272>/Constant'
   *  Constant: '<S272>/Constant1'
   *  DataStoreRead: '<S272>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S272>/Divide'
   *  Product: '<S272>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Front_Duct3 V = %f\n',U); */
    printf("Sensor_Front_Duct3 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Front_Duct3 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S272>/Write' */

  /* MATLAB Function: '<S273>/Write' incorporates:
   *  Constant: '<S273>/Constant'
   *  Constant: '<S273>/Constant1'
   *  DataStoreRead: '<S273>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S273>/Divide'
   *  Product: '<S273>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Front_Duct4 V = %f\n',U); */
    printf("Sensor_Front_Duct4 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Front_Duct4 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S273>/Write' */

  /* MATLAB Function: '<S274>/Write' incorporates:
   *  Constant: '<S274>/Constant'
   *  Constant: '<S274>/Constant1'
   *  DataStoreRead: '<S274>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S274>/Divide'
   *  Product: '<S274>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Front_Duct5 V = %f\n',U); */
    printf("Sensor_Front_Duct5 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Front_Duct5 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S274>/Write' */

  /* MATLAB Function: '<S275>/Write' incorporates:
   *  Constant: '<S275>/Constant'
   *  Constant: '<S275>/Constant1'
   *  DataStoreRead: '<S275>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S275>/Divide'
   *  Product: '<S275>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Front_Duct V = %f\n',U); */
    printf("Sensor_Front_Duct V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Front_Duct6 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S275>/Write' */

  /* MATLAB Function: '<S276>/Write' incorporates:
   *  Constant: '<S276>/Constant'
   *  Constant: '<S276>/Constant1'
   *  DataStoreRead: '<S276>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S276>/Divide'
   *  Product: '<S276>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Rear_Duct1 V = %f\n',U); */
    printf("Sensor_Rear_Duct1 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Rear_Duct1 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S276>/Write' */

  /* MATLAB Function: '<S277>/Write' incorporates:
   *  Constant: '<S277>/Constant'
   *  Constant: '<S277>/Constant1'
   *  DataStoreRead: '<S277>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S277>/Divide'
   *  Product: '<S277>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Rear_Duct2 V = %f\n',U); */
    printf("Sensor_Rear_Duct2 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Rear_Duct2 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S277>/Write' */

  /* MATLAB Function: '<S278>/Write' incorporates:
   *  Constant: '<S278>/Constant'
   *  Constant: '<S278>/Constant1'
   *  DataStoreRead: '<S278>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S278>/Divide'
   *  Product: '<S278>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Rear_Duct3 V = %f\n',U); */
    printf("Sensor_Rear_Duct3 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Rear_Duct3 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S278>/Write' */

  /* MATLAB Function: '<S279>/Write' incorporates:
   *  Constant: '<S279>/Constant'
   *  Constant: '<S279>/Constant1'
   *  DataStoreRead: '<S279>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S279>/Divide'
   *  Product: '<S279>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Rear_Duct4 V = %f\n',U); */
    printf("Sensor_Rear_Duct4 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Rear_Duct4 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S279>/Write' */

  /* MATLAB Function: '<S280>/Write' incorporates:
   *  Constant: '<S280>/Constant'
   *  Constant: '<S280>/Constant1'
   *  DataStoreRead: '<S280>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S280>/Divide'
   *  Product: '<S280>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Rear_Duct5 V = %f\n',U); */
    printf("Sensor_Rear_Duct5 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Rear_Duct5 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S280>/Write' */

  /* MATLAB Function: '<S281>/Write' incorporates:
   *  Constant: '<S281>/Constant'
   *  Constant: '<S281>/Constant1'
   *  DataStoreRead: '<S281>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S281>/Divide'
   *  Product: '<S281>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Sensor_Rear_Duct6 V = %f\n',U); */
    printf("Sensor_Rear_Duct6 V = %f\n", (double)
           rtDW.ADC_Data_Model.Sensor_Rear_Duct6 / 4095.0 * 5.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S281>/Write' */

  /* MATLAB Function: '<S282>/Write' incorporates:
   *  Constant: '<S282>/Constant'
   *  Constant: '<S282>/Constant1'
   *  DataStoreRead: '<S282>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S282>/Divide'
   *  Product: '<S282>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('VN7008AJ_DIAG_FrontLINActuatorPowerDriverAB V = %f\n',U); */
    printf("VN7008AJ_DIAG_FrontLINActuatorPowerDriverAB V = %f\n", (double)
           rtDW.ADC_Data_Model.VN7008AJ_DIAG_FrontLINActuatorPowerDriverAB /
           4095.0 * 17.5);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S282>/Write' */

  /* MATLAB Function: '<S283>/Write' incorporates:
   *  Constant: '<S283>/Constant'
   *  Constant: '<S283>/Constant1'
   *  DataStoreRead: '<S283>/Data Store Read'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S283>/Divide'
   *  Product: '<S283>/Divide1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('VN7008AJ_DIAG_RearLINActuatorPowerDriverC V = %f\n',U); */
    printf("VN7008AJ_DIAG_RearLINActuatorPowerDriverC V = %f\n", (double)
           rtDW.ADC_Data_Model.VN7008AJ_DIAG_RearLINActuatorPowerDriverC /
           4095.0 * 17.5);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S283>/Write' */

  /* Product: '<S284>/Divide1' incorporates:
   *  Constant: '<S284>/Constant'
   *  Constant: '<S284>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S284>/Divide'
   */
  rtb_Divide1 = (double)
    rtDW.ADC_Data_Model.VN7008AJ_FrontLINActuatorPowerDriverAB / 4095.0 * 5.0;

  /* MATLAB Function: '<S284>/Write' incorporates:
   *  Constant: '<S284>/Constant2'
   *  Constant: '<S284>/Constant3'
   *  DataStoreRead: '<S284>/Data Store Read'
   *  Product: '<S284>/Divide2'
   *  Product: '<S284>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('VN7008AJ_FrontLINActuatorPowerDriverAB V = %f Iout = %f\n',U,I); */
    printf("VN7008AJ_FrontLINActuatorPowerDriverAB V = %f Iout = %f\n",
           rtb_Divide1, rtb_Divide1 / 2490.0 * 5890.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S284>/Write' */

  /* Product: '<S285>/Divide1' incorporates:
   *  Constant: '<S285>/Constant'
   *  Constant: '<S285>/Constant1'
   *  DataStoreRead: '<S2>/Data Store Read1'
   *  Product: '<S285>/Divide'
   */
  rtb_Divide1 = (double)rtDW.ADC_Data_Model.VN7008AJ_RearLINActuatorPowerDriverC
    / 4095.0 * 5.0;

  /* MATLAB Function: '<S285>/Write' incorporates:
   *  Constant: '<S285>/Constant2'
   *  Constant: '<S285>/Constant3'
   *  DataStoreRead: '<S285>/Data Store Read'
   *  Product: '<S285>/Divide2'
   *  Product: '<S285>/Divide3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('VN7008AJ_RearLINActuatorPowerDriverC V = %f Iout = %f\n',U,I); */
    printf("VN7008AJ_RearLINActuatorPowerDriverC V = %f Iout = %f\n",
           rtb_Divide1, rtb_Divide1 / 2490.0 * 5890.0);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S285>/Write' */

  /* MATLAB Function: '<S2>/Write' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read2'
   *  DataStoreRead: '<S2>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('ST_ReservePower = %u \n',data); */
    printf("ST_ReservePower = %u \n", rtDW.ADC_Key_Data_Model.ST_ReservePower);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S2>/Write' */

  /* MATLAB Function: '<S2>/Write1' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read2'
   *  DataStoreRead: '<S2>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('ST_BATTChiller = %u \n',data); */
    printf("ST_BATTChiller = %u \n", rtDW.ADC_Key_Data_Model.ST_BATTChiller);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S2>/Write1' */

  /* MATLAB Function: '<S2>/Write2' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read2'
   *  DataStoreRead: '<S2>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('EmergencyAirCleanSwitch = %u \n',data); */
    printf("EmergencyAirCleanSwitch = %u \n",
           rtDW.ADC_Key_Data_Model.EmergencyAirCleanSwitch);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S2>/Write2' */

  /* MATLAB Function: '<S2>/Write3' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read2'
   *  DataStoreRead: '<S2>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('FireExtinguishSwitch = %u \n',data); */
    printf("FireExtinguishSwitch = %u \n",
           rtDW.ADC_Key_Data_Model.FireExtinguishSwitch);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S2>/Write3' */

  /* MATLAB Function: '<S2>/Write4' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read2'
   *  DataStoreRead: '<S2>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Ign_Wakeup = %u \n',data); */
    printf("Ign_Wakeup = %u \n", rtDW.ADC_Key_Data_Model.Ign_Wakeup);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S2>/Write4' */

  /* BusCreator: '<Root>/Bus Creator' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read'
   *  DataStoreWrite: '<Root>/Data Store Write'
   *  DataTypeConversion: '<S251>/Data Type Conversion'
   *  DataTypeConversion: '<S252>/Data Type Conversion'
   *  DataTypeConversion: '<S253>/Data Type Conversion'
   *  DataTypeConversion: '<S269>/Data Type Conversion'
   *  DataTypeConversion: '<S286>/Data Type Conversion'
   *  DataTypeConversion: '<S287>/Data Type Conversion'
   *  Logic: '<S286>/Logical Operator4'
   *  Logic: '<S287>/Logical Operator4'
   */
  CCU_Errors_Model.CCU_IncarTempErrF_Stat = (uint8_t)(rtb_LogicalOperator1_ca ||
    rtb_LogicalOperator3_f3);
  CCU_Errors_Model.CCU_IncarTempErrR_Stat = (uint8_t)(rtb_LogicalOperator1_lc ||
    rtb_LogicalOperator3_oi);
  CCU_Errors_Model.CCU_DuctTempSenErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DuctTempSenErrR_Stat = 0U;
  CCU_Errors_Model.CCU_EvaTempSenErrF_Stat = rtb_LogicalOperator1_f;
  CCU_Errors_Model.CCU_EvaTempSenErrR_Stat = rtb_LogicalOperator1_k;
  CCU_Errors_Model.CCU_DeflectorSwErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DeflectorSwErrR_Stat = 0U;
  CCU_Errors_Model.CCU_PressSenErr_Stat = rtb_LogicalOperator1_lk;
  CCU_Errors_Model.CCU_AmbienTemptSenErr_Stat = rtb_LogicalOperator1;
  CCU_Errors_Model.CCU_SealingValveErr_Stat = 0U;
  CCU_Errors_Model.CCU_ETXVerr_Stat = 0U;
  CCU_Errors_Model.CCU_HVACfanOrTXVerrF_Stat = 0U;
  CCU_Errors_Model.CCU_HVACfanOrTXVerrR_Stat = 0U;
  CCU_Errors_Model.CCU_ActuatorErrF_Stat = rtDW.CCU_ActuatorErrF_Stat_private;
  CCU_Errors_Model.CCU_ActuatorErrR_Stat = 0U;
  CCU_Errors_Model.CCU_UltravioletErr_Stat = 0U;
  CCU_Errors_Model.CCU_VinRecordErr_Stat = 0U;
  CCU_Errors_Model.CCU_AirQualSenErr_Stat = 0U;
  CCU_Errors_Model.CCU_CommErr_Stat = 0U;
  CCU_Errors_Model.CCU_TWVerr_Stat = 0U;
  CCU_Errors_Model.CCU_IonizationErr_Stat = 0U;
  CCU_Errors_Model.CCU_AromaErr_Stat = 0U;

  /* BusCreator: '<S5>/Bus Creator' incorporates:
   *  Constant: '<S5>/Constant'
   *  Constant: '<S5>/Constant1'
   *  Constant: '<S5>/Constant2'
   *  Constant: '<S5>/Constant3'
   *  DataStoreWrite: '<S5>/Data Store Write'
   */
  PWM_Get.pwmPercentFront = 30U;
  PWM_Get.pwmPercentRear = 30U;
  PWM_Get.pwmPercentFrontReserved = 30U;
  PWM_Get.pwmPercentRearReserved = 30U;

  /* Saturate: '<S8>/Saturation' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if (AMB > 1000) {
    Eva_F = 1000;
  } else if (AMB < -1000) {
    Eva_F = -1000;
  } else {
    Eva_F = AMB;
  }

  /* End of Saturate: '<S8>/Saturation' */

  /* MATLAB Function: '<S8>/Convert_g_assAMB_LV_UP' */
  /* :  c_g_assAMB_LV_UP = [-1000, g_assAMB_LV_UP(5), g_assAMB_LV_UP(4), g_assAMB_LV_UP(3), g_assAMB_LV_UP(2), g_assAMB_LV_UP(1)]; */
  tmp[0] = -1000;
  tmp[1] = g_assAMB_LV_UP[4];
  tmp[2] = g_assAMB_LV_UP[3];
  tmp[3] = g_assAMB_LV_UP[2];
  tmp[4] = g_assAMB_LV_UP[1];
  tmp[5] = g_assAMB_LV_UP[0];

  /* SwitchCase: '<S8>/Switch Case' incorporates:
   *  Lookup_n-D: '<S8>/1-D Lookup Table'
   *  Saturate: '<S8>/Saturation'
   */
  switch ((int8_t)rtConstP.uDLookupTable_tableData_h[plook_u32s16_bincka(Eva_F,
           tmp, 5U)]) {
   case 0:
    /* Outputs for IfAction SubSystem: '<S8>/Switch Case Action Subsystem' incorporates:
     *  ActionPort: '<S12>/Action Port'
     */
    /* Merge: '<S8>/Merge' incorporates:
     *  MATLAB Function: '<S12>/Convert_g_assAMB_LV_UP_1'
     *  RelationalOperator: '<S12>/Relational Operator'
     *  Switch: '<S12>/Switch'
     */
    /* :  c_g_assAMB_LV_UP_1 = g_assAMB_LV_UP(1); */
    rtB.Merge_b = (uint8_t)(Eva_F <= g_assAMB_LV_UP[0]);

    /* End of Outputs for SubSystem: '<S8>/Switch Case Action Subsystem' */
    break;

   case 1:
    /* Outputs for IfAction SubSystem: '<S8>/Switch Case Action Subsystem1' incorporates:
     *  ActionPort: '<S13>/Action Port'
     */
    /* Switch: '<S13>/Switch' incorporates:
     *  MATLAB Function: '<S13>/Convert_g_assAMB_LV_UP_2'
     *  RelationalOperator: '<S13>/Relational Operator'
     */
    /* :  c_g_assAMB_LV_DN_1 = g_assAMB_LV_DN(1); */
    /* :  c_g_assAMB_LV_UP_2 = g_assAMB_LV_UP(2); */
    if (Eva_F > g_assAMB_LV_UP[1]) {
      /* Merge: '<S8>/Merge' incorporates:
       *  MATLAB Function: '<S13>/Convert_g_assAMB_LV_DN_1'
       *  RelationalOperator: '<S13>/Relational Operator1'
       */
      rtB.Merge_b = (uint8_t)(Eva_F <= g_assAMB_LV_DN[0]);
    } else {
      /* Merge: '<S8>/Merge' incorporates:
       *  Constant: '<S13>/Constant_Lv2'
       */
      rtB.Merge_b = 2U;
    }

    /* End of Switch: '<S13>/Switch' */
    /* End of Outputs for SubSystem: '<S8>/Switch Case Action Subsystem1' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S8>/Switch Case Action Subsystem2' incorporates:
     *  ActionPort: '<S14>/Action Port'
     */
    /* Switch: '<S14>/Switch2' incorporates:
     *  MATLAB Function: '<S14>/Convert_g_assAMB_LV_UP_3'
     *  RelationalOperator: '<S14>/Relational Operator'
     */
    /* :  c_g_assAMB_LV_DN_2 = g_assAMB_LV_DN(2); */
    /* :  c_g_assAMB_LV_UP_3 = g_assAMB_LV_UP(3); */
    if (Eva_F > g_assAMB_LV_UP[2]) {
      /* Switch: '<S14>/Switch3' incorporates:
       *  MATLAB Function: '<S14>/Convert_g_assAMB_LV_DN_2'
       *  RelationalOperator: '<S14>/Relational Operator1'
       */
      if (Eva_F > g_assAMB_LV_DN[1]) {
        /* Merge: '<S8>/Merge' incorporates:
         *  Constant: '<S14>/Constant_Lv1'
         */
        rtB.Merge_b = 1U;
      } else {
        /* Merge: '<S8>/Merge' incorporates:
         *  Constant: '<S14>/Constant_Lv2'
         */
        rtB.Merge_b = 2U;
      }

      /* End of Switch: '<S14>/Switch3' */
    } else {
      /* Merge: '<S8>/Merge' incorporates:
       *  Constant: '<S14>/Constant_Lv3'
       */
      rtB.Merge_b = 3U;
    }

    /* End of Switch: '<S14>/Switch2' */
    /* End of Outputs for SubSystem: '<S8>/Switch Case Action Subsystem2' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S8>/Switch Case Action Subsystem3' incorporates:
     *  ActionPort: '<S15>/Action Port'
     */
    /* Switch: '<S15>/Switch2' incorporates:
     *  MATLAB Function: '<S15>/Convert_g_assAMB_LV_UP_4'
     *  RelationalOperator: '<S15>/Relational Operator'
     */
    /* :  c_g_assAMB_LV_DN_3 = g_assAMB_LV_DN(3); */
    /* :  c_g_assAMB_LV_UP_4 = g_assAMB_LV_UP(4); */
    if (Eva_F > g_assAMB_LV_UP[3]) {
      /* Switch: '<S15>/Switch3' incorporates:
       *  MATLAB Function: '<S15>/Convert_g_assAMB_LV_DN_3'
       *  RelationalOperator: '<S15>/Relational Operator1'
       */
      if (Eva_F > g_assAMB_LV_DN[2]) {
        /* Merge: '<S8>/Merge' incorporates:
         *  Constant: '<S15>/Constant_Lv2'
         */
        rtB.Merge_b = 2U;
      } else {
        /* Merge: '<S8>/Merge' incorporates:
         *  Constant: '<S15>/Constant_Lv3'
         */
        rtB.Merge_b = 3U;
      }

      /* End of Switch: '<S15>/Switch3' */
    } else {
      /* Merge: '<S8>/Merge' incorporates:
       *  Constant: '<S15>/Constant_Lv4'
       */
      rtB.Merge_b = 4U;
    }

    /* End of Switch: '<S15>/Switch2' */
    /* End of Outputs for SubSystem: '<S8>/Switch Case Action Subsystem3' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S8>/Switch Case Action Subsystem4' incorporates:
     *  ActionPort: '<S16>/Action Port'
     */
    /* Switch: '<S16>/Switch2' incorporates:
     *  MATLAB Function: '<S16>/Convert_g_assAMB_LV_UP_5'
     *  RelationalOperator: '<S16>/Relational Operator'
     */
    /* :  c_g_assAMB_LV_DN_4 = g_assAMB_LV_DN(4); */
    /* :  c_g_assAMB_LV_UP_5 = g_assAMB_LV_UP(5); */
    if (Eva_F > g_assAMB_LV_UP[4]) {
      /* Switch: '<S16>/Switch3' incorporates:
       *  MATLAB Function: '<S16>/Convert_g_assAMB_LV_DN_4'
       *  RelationalOperator: '<S16>/Relational Operator1'
       */
      if (Eva_F > g_assAMB_LV_DN[3]) {
        /* Merge: '<S8>/Merge' incorporates:
         *  Constant: '<S16>/Constant_Lv3'
         */
        rtB.Merge_b = 3U;
      } else {
        /* Merge: '<S8>/Merge' incorporates:
         *  Constant: '<S16>/Constant_Lv4'
         */
        rtB.Merge_b = 4U;
      }

      /* End of Switch: '<S16>/Switch3' */
    } else {
      /* Merge: '<S8>/Merge' incorporates:
       *  Constant: '<S16>/Constant_Lv5'
       */
      rtB.Merge_b = 5U;
    }

    /* End of Switch: '<S16>/Switch2' */
    /* End of Outputs for SubSystem: '<S8>/Switch Case Action Subsystem4' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S8>/Switch Case Action Subsystem5' incorporates:
     *  ActionPort: '<S17>/Action Port'
     */
    /* Switch: '<S17>/Switch1' incorporates:
     *  MATLAB Function: '<S17>/Convert_g_assAMB_LV_DN_5'
     *  RelationalOperator: '<S17>/Relational Operator'
     */
    /* :  c_g_assAMB_LV_DN_5 = g_assAMB_LV_DN(5); */
    if (Eva_F > g_assAMB_LV_DN[4]) {
      /* Merge: '<S8>/Merge' incorporates:
       *  Constant: '<S17>/Constant_Lv4'
       */
      rtB.Merge_b = 4U;
    } else {
      /* Merge: '<S8>/Merge' incorporates:
       *  Constant: '<S17>/Constant_Lv5'
       */
      rtB.Merge_b = 5U;
    }

    /* End of Switch: '<S17>/Switch1' */
    /* End of Outputs for SubSystem: '<S8>/Switch Case Action Subsystem5' */
    break;
  }

  /* End of SwitchCase: '<S8>/Switch Case' */

  /* Saturate: '<S1>/Saturation' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read1'
   */
  if (rtDW.SET_FL > 290.0) {
    rtb_Divide1 = 290.0;
  } else if (rtDW.SET_FL < 170.0) {
    rtb_Divide1 = 170.0;
  } else {
    rtb_Divide1 = rtDW.SET_FL;
  }

  /* Gain: '<S9>/Gain' incorporates:
   *  Saturate: '<S1>/Saturation'
   */
  i = 13107 * (int16_t)floor(rtb_Divide1);
  rtb_Gain_l = (uint8_t)((((uint32_t)i & 65536U) != 0U) + (i >> 17));

  /* MATLAB Function: '<S9>/Modes for levels' */
  /* :  get_modes_for_levels = [g_aucMODE_BY_SET_F_LV0; */
  /* :      g_aucMODE_BY_SET_F_LV1; */
  /* :      g_aucMODE_BY_SET_F_LV2; */
  /* :      g_aucMODE_BY_SET_F_LV3; */
  /* :      g_aucMODE_BY_SET_F_LV4; */
  /* :      g_aucMODE_BY_SET_F_LV5; */
  /* :      ]; */
  for (i = 0; i < 13; i++) {
    rtb_get_modes_for_levels[6 * i] = g_aucMODE_BY_SET_F_LV0[i];
    rtb_get_modes_for_levels[6 * i + 1] = g_aucMODE_BY_SET_F_LV1[i];
    rtb_get_modes_for_levels[6 * i + 2] = g_aucMODE_BY_SET_F_LV2[i];
    rtb_get_modes_for_levels[6 * i + 3] = g_aucMODE_BY_SET_F_LV3[i];
    rtb_get_modes_for_levels[6 * i + 4] = g_aucMODE_BY_SET_F_LV4[i];
    rtb_get_modes_for_levels[6 * i + 5] = g_aucMODE_BY_SET_F_LV5[i];
  }

  /* End of MATLAB Function: '<S9>/Modes for levels' */

  /* Lookup_n-D: '<S9>/Выбор режима Left' incorporates:
   *  Gain: '<S9>/Gain'
   *  Merge: '<S8>/Merge'
   */
  rtb_u_pe = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Gain_l,
    rtConstP.pooled61, rtConstP.pooled29, rtb_get_modes_for_levels,
    rtConstP.pooled23, 6U);

  /* MATLAB Function: '<S9>/Начальные положения заслонок left' */
  left(rtb_u_pe, rtb_vals_m);

  /* Saturate: '<S1>/Saturation1' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read2'
   */
  if (rtDW.SET_FR >= 170) {
    i = rtDW.SET_FR;
  } else {
    i = 170;
  }

  /* Gain: '<S9>/Gain2' incorporates:
   *  Saturate: '<S1>/Saturation1'
   */
  i *= 13107;
  rtb_Gain2 = (uint8_t)((((uint32_t)i & 65536U) != 0U) + (i >> 17));

  /* SwitchCase: '<S29>/Switch for Left ' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read'
   */
  switch (rtb_u_pe) {
   case 10:
    break;

   case 20:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S29>/Bilevel' incorporates:
       *  ActionPort: '<S35>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S29>/Bilevel' */
    }

    /* Outputs for IfAction SubSystem: '<S29>/Bilevel' incorporates:
     *  ActionPort: '<S35>/Action Port'
     */
    Bilevel(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S29>/Bilevel' */
    break;

   case 30:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S29>/Bilevel2' incorporates:
       *  ActionPort: '<S36>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S29>/Bilevel2' */
    }

    /* Outputs for IfAction SubSystem: '<S29>/Bilevel2' incorporates:
     *  ActionPort: '<S36>/Action Port'
     */
    Bilevel2(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S29>/Bilevel2' */
    break;

   case 40:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S29>/Afoot' incorporates:
       *  ActionPort: '<S33>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S29>/Afoot' */
    }

    /* Outputs for IfAction SubSystem: '<S29>/Afoot' incorporates:
     *  ActionPort: '<S33>/Action Port'
     */
    Afoot(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S29>/Afoot' */
    break;

   case 50:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S29>/Afoot_Summer' incorporates:
       *  ActionPort: '<S34>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S29>/Afoot_Summer' */
    }

    /* Outputs for IfAction SubSystem: '<S29>/Afoot_Summer' incorporates:
     *  ActionPort: '<S34>/Action Port'
     */
    Afoot_Summer(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S29>/Afoot_Summer' */
    break;
  }

  /* End of SwitchCase: '<S29>/Switch for Left ' */

  /* Lookup_n-D: '<S9>/Выбор режима Right' incorporates:
   *  Gain: '<S9>/Gain2'
   *  Merge: '<S8>/Merge'
   */
  rtb_u_pe = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Gain2,
    rtConstP.pooled61, rtConstP.pooled29, rtb_get_modes_for_levels,
    rtConstP.pooled23, 6U);

  /* MATLAB Function: '<S9>/Начальные положения заслонок right' */
  left(rtb_u_pe, rtb_vals_m);

  /* SwitchCase: '<S30>/Switch for Left ' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read'
   */
  switch (rtb_u_pe) {
   case 10:
    break;

   case 20:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S30>/Bilevel' incorporates:
       *  ActionPort: '<S144>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S30>/Bilevel' */
    }

    /* Outputs for IfAction SubSystem: '<S30>/Bilevel' incorporates:
     *  ActionPort: '<S144>/Action Port'
     */
    Bilevel(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S30>/Bilevel' */
    break;

   case 30:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S30>/Bilevel2' incorporates:
       *  ActionPort: '<S145>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S30>/Bilevel2' */
    }

    /* Outputs for IfAction SubSystem: '<S30>/Bilevel2' incorporates:
     *  ActionPort: '<S145>/Action Port'
     */
    Bilevel2(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S30>/Bilevel2' */
    break;

   case 40:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S30>/Afoot' incorporates:
       *  ActionPort: '<S142>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S30>/Afoot' */
    }

    /* Outputs for IfAction SubSystem: '<S30>/Afoot' incorporates:
     *  ActionPort: '<S142>/Action Port'
     */
    Afoot(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S30>/Afoot' */
    break;

   case 50:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S30>/Afoot_Summer' incorporates:
       *  ActionPort: '<S143>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S30>/Afoot_Summer' */
    }

    /* Outputs for IfAction SubSystem: '<S30>/Afoot_Summer' incorporates:
     *  ActionPort: '<S143>/Action Port'
     */
    Afoot_Summer(AMB, rtB.Merge_b, Merge, rtb_Gain_l, rtb_Gain2);

    /* End of Outputs for SubSystem: '<S30>/Afoot_Summer' */
    break;
  }

  /* End of SwitchCase: '<S30>/Switch for Left ' */

  /* MATLAB Function: '<S8>/Log Ambient Lv' */
  /* :  if (isempty(current_Ambient_Lv)) */
  if (!rtDW.current_Ambient_Lv_not_empty) {
    /* :  current_Ambient_Lv = Ambient_Lv; */
    rtDW.current_Ambient_Lv = rtB.Merge_b;
    rtDW.current_Ambient_Lv_not_empty = true;

    /* :  fprintf("13.1.3.1 Ambient level: in_Amb_Fb = %d; Set Ambient lvl (init) = %u \n", in_Amb_Fb, Ambient_Lv); */
    printf("13.1.3.1 Ambient level: in_Amb_Fb = %d; Set Ambient lvl (init) = %u \n",
           Eva_F, rtB.Merge_b);
    fflush(stdout);

    /* :  else */
    /* :  if (current_Ambient_Lv ~= Ambient_Lv) */
  } else if (rtDW.current_Ambient_Lv != rtB.Merge_b) {
    /* :  current_Ambient_Lv = Ambient_Lv; */
    rtDW.current_Ambient_Lv = rtB.Merge_b;

    /* :  fprintf("13.1.3.1 Ambient level: in_Amb_Fb = %d; Set Ambient lvl = %u \n", in_Amb_Fb, Ambient_Lv); */
    printf("13.1.3.1 Ambient level: in_Amb_Fb = %d; Set Ambient lvl = %u \n",
           Eva_F, rtB.Merge_b);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S8>/Log Ambient Lv' */

  /* DataStoreWrite: '<S3>/Data Store Write' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read1'
   */
  rtDW.SET_FR = rtDW.FIU_CCU1_MODEL.FIU_TargetTempFR_Val_ro;

  /* Gain: '<S380>/Gain1' incorporates:
   *  Bias: '<S380>/Bias'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S3>/Data Store Write1'
   *  DataTypeConversion: '<S380>/Data Type  Conversion'
   *  Gain: '<S380>/Gain'
   */
  rtDW.SET_FL = (0.5 * (double)rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro +
                 15.5) * 10.0;

  /* Switch: '<S381>/Switch' incorporates:
   *  Constant: '<S381>/Constant1'
   *  DataStoreRead: '<S381>/Data Store Read'
   *  DataStoreRead: '<S381>/Data Store Read2'
   */
  if (rtDW.stepSig_private > 0) {
    rtb_Switch_hx = rtDW.stepSig_private;
  } else {
    rtb_Switch_hx = 1;
  }

  /* End of Switch: '<S381>/Switch' */

  /* SwitchCase: '<S381>/Switch Case' */
  switch (rtb_Switch_hx) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S381>/Stop Mode' incorporates:
     *  ActionPort: '<S394>/Action Port'
     */
    /* If: '<S394>/If1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S394>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S441>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S441>/Data Store Write' */
        rtDW.MODE_private[i] = 2U;

        /* DataStoreWrite: '<S441>/Data Store Write1' incorporates:
         *  DataStoreRead: '<S441>/Data Store Read'
         */
        rtDW.COM_private[i] = rtDW.ErrorCalibration_private[i];
      }

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S441>/Constant'
       *  Sum: '<S441>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S394>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S394>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S442>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S442>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S394>/If Action Subsystem3' */
    }

    /* End of If: '<S394>/If1' */
    /* End of Outputs for SubSystem: '<S381>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S381>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S390>/Action Port'
     */
    /* If: '<S390>/If' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S390>/If Action Subsystem' incorporates:
       *  ActionPort: '<S429>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S429>/Data Store Write' */
        rtDW.POS_private[i] = 6000U;

        /* Product: '<S429>/Divide' incorporates:
         *  DataStoreRead: '<S429>/Data Store Read'
         *  DataStoreWrite: '<S429>/Data Store Write1'
         */
        rtDW.COM_private[i] = (uint8_t)(rtDW.ErrorCalibration_private[i] << 1);
      }

      /* MATLAB Function: '<S429>/Initial CPOS Min' incorporates:
       *  DataStoreRead: '<S429>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Initial CPOS Min - 6000\n'); */
        printf("LIN1 SIMULINK Initial CPOS Min - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S429>/Initial CPOS Min' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S429>/Constant'
       *  Merge: '<S390>/Merge'
       *  SignalConversion generated from: '<S429>/step'
       *  Sum: '<S429>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S390>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S390>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S430>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  Merge: '<S390>/Merge'
       *  SignalConversion generated from: '<S430>/stepIn1'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S390>/If Action Subsystem3' */
    }

    /* End of If: '<S390>/If' */
    /* End of Outputs for SubSystem: '<S381>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S381>/Normal Mode' incorporates:
     *  ActionPort: '<S393>/Action Port'
     */
    /* If: '<S393>/If1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S393>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S438>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S438>/Data Store Write' */
        rtDW.MODE_private[i] = 0U;

        /* DataStoreWrite: '<S438>/Data Store Write1' incorporates:
         *  DataStoreRead: '<S438>/Data Store Read'
         */
        rtDW.COM_private[i] = rtDW.ErrorCalibration_private[i];
      }

      /* MATLAB Function: '<S438>/Normal Mode' incorporates:
       *  DataStoreRead: '<S438>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Normal Mode\n'); */
        printf("LIN1 SIMULINK Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S438>/Normal Mode' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S438>/Constant'
       *  SignalConversion generated from: '<S438>/step'
       *  Sum: '<S438>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S393>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S393>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S439>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S439>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S393>/If Action Subsystem3' */
    }

    /* End of If: '<S393>/If1' */
    /* End of Outputs for SubSystem: '<S381>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S381>/Move to position Min' incorporates:
     *  ActionPort: '<S392>/Action Port'
     */
    /* If: '<S392>/If1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S392>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S435>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S435>/Data Store Write4' incorporates:
         *  Constant: '<S435>/Constant1'
         */
        rtDW.Autos_private[i] = 1U;

        /* DataStoreWrite: '<S435>/Data Store Write2' incorporates:
         *  Constant: '<S435>/Constant10'
         */
        rtDW.Stall_private[i] = 1U;

        /* DataStoreWrite: '<S435>/Data Store Write3' incorporates:
         *  Constant: '<S435>/Constant11'
         */
        rtDW.Lnoise_private[i] = 0U;

        /* DataStoreWrite: '<S435>/Data Store Write6' incorporates:
         *  Constant: '<S435>/Constant14'
         */
        rtDW.Coils_private[i] = 0U;

        /* DataStoreWrite: '<S435>/Data Store Write5' incorporates:
         *  Constant: '<S435>/Constant2'
         */
        rtDW.Speed_private[i] = 3U;

        /* DataStoreWrite: '<S435>/Data Store Write' */
        rtDW.POS_private[i] = 1U;

        /* Product: '<S435>/Divide' incorporates:
         *  Constant: '<S435>/Constant9'
         *  DataStoreRead: '<S435>/Data Store Read'
         *  DataStoreWrite: '<S435>/Data Store Write1'
         */
        rtDW.COM_private[i] = (uint8_t)(rtDW.ErrorCalibration_private[i] * 3U);
      }

      /* MATLAB Function: '<S435>/Move to position Min' incorporates:
       *  DataStoreRead: '<S435>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Move to position Min - 1\n'); */
        printf("LIN1 SIMULINK Move to position Min - 1\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S435>/Move to position Min' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S435>/Constant'
       *  SignalConversion generated from: '<S435>/step'
       *  Sum: '<S435>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S392>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S392>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S436>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S436>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S392>/If Action Subsystem3' */
    }

    /* End of If: '<S392>/If1' */
    /* End of Outputs for SubSystem: '<S381>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S381>/Check Stall Min' incorporates:
     *  ActionPort: '<S387>/Action Port'
     */
    /* RelationalOperator: '<S387>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  RelationalOperator: '<S387>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1);
    }

    /* End of RelationalOperator: '<S387>/Relational Operator1' */

    /* Logic: '<S387>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S387>/Relational Operator'
     */
    rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* RelationalOperator: '<S387>/Relational Operator' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 1);
    }

    /* End of RelationalOperator: '<S387>/Relational Operator' */

    /* Logic: '<S387>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S387>/Relational Operator'
     */
    rtb_LogicalOperator1_f = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_f = (rtb_LogicalOperator1_f ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* If: '<S387>/If2' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     *  DataTypeConversion: '<S387>/Data Type Conversion'
     *  DataTypeConversion: '<S387>/Data Type Conversion1'
     *  Logic: '<S387>/Logical Operator'
     *  Logic: '<S387>/Logical Operator1'
     *  Logic: '<S387>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S387>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S399>/Action Port'
       */
      /* DataStoreWrite: '<S399>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        rtDW.MinPositionCh0_private[i] =
          rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i];
      }

      /* End of DataStoreWrite: '<S399>/Data Store Write1' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S399>/Constant'
       *  Sum: '<S399>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* MATLAB Function: '<S399>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S399>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Min_position_Ch0 '); */
        printf("LIN1 SIMULINK Min_position_Ch0 ");
        fflush(stdout);

        /* :  for i = 1:numel(step) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('%d ', int16(step(i))); */
          printf("%d ", rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S399>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S387>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S387>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S400>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S400>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S387>/If Action Subsystem3' */
    }

    /* End of If: '<S387>/If2' */
    /* End of Outputs for SubSystem: '<S381>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S381>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S389>/Action Port'
     */
    /* If: '<S389>/If1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S389>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S426>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* Product: '<S426>/Divide' incorporates:
         *  DataStoreRead: '<S426>/Data Store Read'
         *  DataStoreWrite: '<S426>/Data Store Write1'
         */
        rtDW.COM_private[i] = (uint8_t)(rtDW.ErrorCalibration_private[i] << 1);

        /* DataStoreWrite: '<S426>/Data Store Write' */
        rtDW.POS_private[i] = 1U;
      }

      /* MATLAB Function: '<S426>/Initial CPOS Max' incorporates:
       *  DataStoreRead: '<S426>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Initial CPOS Max - 1\n'); */
        printf("LIN1 SIMULINK Initial CPOS Max - 1\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S426>/Initial CPOS Max' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S426>/Constant'
       *  SignalConversion generated from: '<S426>/step'
       *  Sum: '<S426>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S389>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S389>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S427>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S427>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S389>/If Action Subsystem3' */
    }

    /* End of If: '<S389>/If1' */
    /* End of Outputs for SubSystem: '<S381>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S381>/Move to position Max' incorporates:
     *  ActionPort: '<S391>/Action Port'
     */
    /* If: '<S391>/If1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S391>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S432>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S432>/Data Store Write4' incorporates:
         *  Constant: '<S432>/Constant1'
         */
        rtDW.Autos_private[i] = 1U;

        /* DataStoreWrite: '<S432>/Data Store Write2' incorporates:
         *  Constant: '<S432>/Constant10'
         */
        rtDW.Stall_private[i] = 1U;

        /* DataStoreWrite: '<S432>/Data Store Write3' incorporates:
         *  Constant: '<S432>/Constant11'
         */
        rtDW.Lnoise_private[i] = 0U;

        /* DataStoreWrite: '<S432>/Data Store Write6' incorporates:
         *  Constant: '<S432>/Constant14'
         */
        rtDW.Coils_private[i] = 0U;

        /* DataStoreWrite: '<S432>/Data Store Write5' incorporates:
         *  Constant: '<S432>/Constant2'
         */
        rtDW.Speed_private[i] = 3U;

        /* DataStoreWrite: '<S432>/Data Store Write' */
        rtDW.POS_private[i] = 6000U;

        /* Product: '<S432>/Divide' incorporates:
         *  Constant: '<S432>/Constant9'
         *  DataStoreRead: '<S432>/Data Store Read'
         *  DataStoreWrite: '<S432>/Data Store Write1'
         */
        rtDW.COM_private[i] = (uint8_t)(rtDW.ErrorCalibration_private[i] * 3U);
      }

      /* MATLAB Function: '<S432>/Move to position Max' incorporates:
       *  DataStoreRead: '<S432>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Move to position Max - 6000\n'); */
        printf("LIN1 SIMULINK Move to position Max - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S432>/Move to position Max' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S432>/Constant'
       *  SignalConversion generated from: '<S432>/step'
       *  Sum: '<S432>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S391>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S391>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S433>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S433>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S391>/If Action Subsystem3' */
    }

    /* End of If: '<S391>/If1' */
    /* End of Outputs for SubSystem: '<S381>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S381>/Check Stall Max' incorporates:
     *  ActionPort: '<S386>/Action Port'
     */
    /* RelationalOperator: '<S386>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  RelationalOperator: '<S386>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1);
    }

    /* End of RelationalOperator: '<S386>/Relational Operator1' */

    /* Logic: '<S386>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S386>/Relational Operator'
     */
    rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* RelationalOperator: '<S386>/Relational Operator' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 6000);
    }

    /* End of RelationalOperator: '<S386>/Relational Operator' */

    /* Logic: '<S386>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S386>/Relational Operator'
     */
    rtb_LogicalOperator1_f = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_f = (rtb_LogicalOperator1_f ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* If: '<S386>/If2' incorporates:
     *  DataStoreRead: '<S381>/Data Store Read1'
     *  DataStoreWrite: '<S381>/Data Store Write'
     *  DataStoreWrite: '<S381>/Data Store Write1'
     *  DataTypeConversion: '<S386>/Data Type Conversion'
     *  DataTypeConversion: '<S386>/Data Type Conversion1'
     *  Logic: '<S386>/Logical Operator'
     *  Logic: '<S386>/Logical Operator1'
     *  Logic: '<S386>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S386>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S396>/Action Port'
       */
      /* DataStoreWrite: '<S396>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        rtDW.MinPositionCh0_private[i] =
          rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i];
      }

      /* End of DataStoreWrite: '<S396>/Data Store Write1' */

      /* Merge: '<S381>/Merge' incorporates:
       *  Constant: '<S396>/Constant'
       *  Sum: '<S396>/step inc'
       */
      rtB.Merge_l = (int8_t)(rtb_Switch_hx + 1);

      /* MATLAB Function: '<S396>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S396>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN1 SIMULINK Max_position_Ch0 '); */
        printf("LIN1 SIMULINK Max_position_Ch0 ");
        fflush(stdout);

        /* :  for i = 1:numel(step) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('%d ', int16(step(i))); */
          printf("%d ", rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S396>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S386>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S386>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S397>/Action Port'
       */
      /* Merge: '<S381>/Merge' incorporates:
       *  SignalConversion generated from: '<S397>/stepIn'
       */
      rtB.Merge_l = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S386>/If Action Subsystem3' */
    }

    /* End of If: '<S386>/If2' */
    /* End of Outputs for SubSystem: '<S381>/Check Stall Max' */
    break;

   case 9:
    /* Outputs for IfAction SubSystem: '<S381>/Homing' incorporates:
     *  ActionPort: '<S388>/Action Port'
     */
    /* Product: '<S402>/Divide1' incorporates:
     *  Constant: '<S388>/ACT2'
     *  Constant: '<S402>/ACT1'
     *  DataStoreRead: '<S402>/MIN ACT1T '
     *  DataStoreWrite: '<S388>/Data Store Write1'
     *  Sum: '<S402>/ACT1T'
     */
    for (i = 0; i < 9; i++) {
      rtb_Divide1_ja[i] = (double)(int16_t)(rtConstP.ACT2_Value[i] -
        rtDW.MinPositionCh0_private[i]) / (double)rtConstP.ACT1_Value[i];
    }

    /* End of Product: '<S402>/Divide1' */

    /* SwitchCase: '<S388>/Switch Case' incorporates:
     *  DataStoreRead: '<S388>/Data Store Read4'
     */
    switch (rtDW.stepHoming_private) {
     case 0:
      /* Outputs for IfAction SubSystem: '<S388>/Switch Case Action Subsystem' incorporates:
       *  ActionPort: '<S405>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S410>/Compare' */
        rtb_Divide1 = rtb_Divide1_ja[i];

        /* Logic: '<S405>/Logical Operator' incorporates:
         *  Constant: '<S410>/Constant'
         *  Constant: '<S411>/Constant'
         *  RelationalOperator: '<S410>/Compare'
         *  RelationalOperator: '<S411>/Compare'
         */
        rtb_LogicalOperator1 = ((rtb_Divide1 >= 0.9) && (rtb_Divide1 <= 1.1));
        rtb_RelationalOperator_htm[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S412>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S412>/Data Store Read'
         *  DataStoreWrite: '<S412>/Data Store Write'
         *  Logic: '<S412>/Logical Operator'
         *  Logic: '<S412>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private[i] != 0));
      }

      /* Logic: '<S405>/Logical Operator1' */
      rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_RelationalOperator_htm[i + 1]);
      }

      /* Switch: '<S405>/Switch' incorporates:
       *  Logic: '<S405>/Logical Operator1'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S388>/Merge' incorporates:
         *  Constant: '<S405>/Constant1'
         */
        rtB.Merge_h = 4;
      } else {
        /* Merge: '<S388>/Merge' incorporates:
         *  Constant: '<S405>/Constant'
         */
        rtB.Merge_h = 1;
      }

      /* End of Switch: '<S405>/Switch' */
      /* End of Outputs for SubSystem: '<S388>/Switch Case Action Subsystem' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S388>/Switch Case Action Subsystem1' incorporates:
       *  ActionPort: '<S406>/Action Port'
       */
      /* RelationalOperator: '<S414>/Compare' incorporates:
       *  Constant: '<S414>/Constant'
       */
      for (i = 0; i < 9; i++) {
        rtb_RelationalOperator_htm[i] = (rtb_Divide1_ja[i] > 1.5);
      }

      /* End of RelationalOperator: '<S414>/Compare' */

      /* Logic: '<S413>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_RelationalOperator_htm[i + 1]);
      }

      /* DataTypeConversion: '<S413>/Data Type Conversion' incorporates:
       *  DataStoreWrite: '<S413>/Data Store Write1'
       *  Logic: '<S413>/Logical Operator'
       */
      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
      for (i = 0; i < 9; i++) {
        /* DataTypeConversion: '<S413>/Data Type Conversion1' incorporates:
         *  DataStoreWrite: '<S413>/Data Store Write2'
         */
        rtDW.COM_private[i] = rtb_RelationalOperator_htm[i];

        /* DataStoreWrite: '<S413>/Data Store Write' */
        rtDW.MODE_private[i] = 2U;
      }

      /* MATLAB Function: '<S413>/Write ERROR' incorporates:
       *  DataStoreRead: '<S413>/Data Store Read6'
       */
      /* :  if(LOGGER==1) */
      if (rtDW.LOGGER_LIN == 1.0) {
        /* :  for i = 1:numel(ErrCallibration) */
        for (i = 0; i < 9; i++) {
          /* :  if ErrCallibration(i) == 1 */
          if (rtb_RelationalOperator_htm[i]) {
            /* :  fprintf('LIN1 Failure with actuator #%d\n', int16(i)); */
            printf("LIN1 Failure with actuator #%d\n", (int16_t)(i + 1));
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S413>/Write ERROR' */

      /* DataTypeConversion: '<S406>/Data Type Conversion' incorporates:
       *  DataStoreRead: '<S406>/Data Store Read'
       *  DataStoreWrite: '<S406>/Data Store Write'
       *  Logic: '<S406>/Logical Operator'
       *  Logic: '<S406>/Logical Operator1'
       */
      for (i = 0; i < 9; i++) {
        rtDW.ErrorCalibration_private[i] = (uint8_t)
          ((!rtb_RelationalOperator_htm[i]) && (rtDW.ErrorCalibration_private[i]
            != 0));
      }

      /* End of DataTypeConversion: '<S406>/Data Type Conversion' */

      /* Merge: '<S388>/Merge' incorporates:
       *  Constant: '<S406>/Constant'
       *  Constant: '<S406>/Constant2'
       *  Sum: '<S406>/step inc'
       */
      rtB.Merge_h = 2;

      /* End of Outputs for SubSystem: '<S388>/Switch Case Action Subsystem1' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S388>/Switch Case Action Subsystem2' incorporates:
       *  ActionPort: '<S407>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* Logic: '<S407>/Logical Operator3' incorporates:
         *  Constant: '<S417>/Constant'
         *  DataStoreRead: '<S407>/Data Store Read'
         *  RelationalOperator: '<S417>/Compare'
         */
        rtb_LogicalOperator1 = ((rtb_Divide1_ja[i] <= 0.97) &&
          (rtDW.ErrorCalibration_private[i] != 0));
        rtb_RelationalOperator_htm[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S407>/Data Type Conversion' incorporates:
         *  DataStoreWrite: '<S407>/Data Store Write1'
         */
        rtDW.ErrorCalibration_private[i] = rtb_LogicalOperator1;
      }

      /* Logic: '<S407>/Logical Operator2' */
      rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_RelationalOperator_htm[i + 1]);
      }

      /* Switch: '<S407>/Switch' incorporates:
       *  Logic: '<S407>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S388>/Merge' incorporates:
         *  Constant: '<S407>/Constant3'
         */
        rtB.Merge_h = 4;
      } else {
        /* Merge: '<S388>/Merge' incorporates:
         *  Constant: '<S407>/Constant1'
         */
        rtB.Merge_h = 3;
      }

      /* End of Switch: '<S407>/Switch' */
      /* End of Outputs for SubSystem: '<S388>/Switch Case Action Subsystem2' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S388>/Switch Case Action Subsystem3' incorporates:
       *  ActionPort: '<S408>/Action Port'
       */
      /* If: '<S408>/If' incorporates:
       *  DataStoreRead: '<S408>/Data Store Read1'
       */
      if (rtDW.ErrorHomming_private < 10.0) {
        /* Outputs for IfAction SubSystem: '<S408>/If Action Subsystem' incorporates:
         *  ActionPort: '<S419>/Action Port'
         */
        /* Logic: '<S419>/AND' incorporates:
         *  DataStoreRead: '<S419>/Data Store Read'
         */
        rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private[0] != 0);
        for (i = 0; i < 8; i++) {
          rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
            (rtDW.ErrorCalibration_private[i + 1] != 0));
        }

        rtb_LogicalOperator1 = !rtb_LogicalOperator1;

        /* End of Logic: '<S419>/AND' */

        /* If: '<S419>/If' incorporates:
         *  DataStoreRead: '<S422>/Data Store Read'
         *  Sum: '<S422>/Subtract'
         *  UnitDelay: '<S422>/t_start_delay_private '
         */
        if (rtDW.t_now - rtDW.t_start_delay_private_DSTATE_h > 3000U) {
          /* Outputs for IfAction SubSystem: '<S419>/If Action Subsystem' incorporates:
           *  ActionPort: '<S421>/Action Port'
           */
          /* DataStoreWrite: '<S421>/Data Store Write' incorporates:
           *  Constant: '<S421>/Constant'
           */
          rtDW.stepSig_private = 1;

          /* DataStoreWrite: '<S421>/Data Store Write1' incorporates:
           *  Constant: '<S421>/Constant2'
           *  DataStoreRead: '<S421>/Data Store Read1'
           *  Sum: '<S421>/step inc'
           */
          rtDW.ErrorHomming_private++;

          /* SignalConversion generated from: '<S421>/Out1' */
          rtB.OutportBufferForOut1 = 2;

          /* End of Outputs for SubSystem: '<S419>/If Action Subsystem' */
        }

        /* End of If: '<S419>/If' */

        /* Merge: '<S388>/Merge' incorporates:
         *  SignalConversion generated from: '<S419>/Out2'
         */
        rtB.Merge_h = rtB.OutportBufferForOut1;

        /* Switch: '<S422>/Switch' incorporates:
         *  DataStoreRead: '<S422>/Data Store Read'
         *  Logic: '<S422>/Logical Operator3'
         *  Logic: '<S422>/Logical Operator4'
         *  UnitDelay: '<S422>/Cond_prev_private '
         *  UnitDelay: '<S422>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_dq)) {
          rtDW.t_start_delay_private_DSTATE_h = rtDW.t_now;
        }

        /* End of Switch: '<S422>/Switch' */

        /* Update for UnitDelay: '<S422>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_dq = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S408>/If Action Subsystem' */
      } else {
        /* Outputs for IfAction SubSystem: '<S408>/If Action Subsystem1' incorporates:
         *  ActionPort: '<S420>/Action Port'
         */
        /* Logic: '<S423>/Logical Operator' incorporates:
         *  DataStoreRead: '<S420>/Data Store Read'
         */
        rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private[0] != 0);
        for (i = 0; i < 8; i++) {
          rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
            (rtDW.ErrorCalibration_private[i + 1] != 0));
        }

        /* DataTypeConversion: '<S423>/Data Type Conversion' incorporates:
         *  DataStoreWrite: '<S423>/Data Store Write1'
         *  Logic: '<S423>/Logical Operator'
         */
        rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
        for (i = 0; i < 9; i++) {
          /* DataStoreWrite: '<S423>/Data Store Write2' incorporates:
           *  DataStoreRead: '<S420>/Data Store Read'
           */
          rtDW.COM_private[i] = rtDW.ErrorCalibration_private[i];

          /* DataStoreWrite: '<S423>/Data Store Write' */
          rtDW.MODE_private[i] = 2U;
        }

        /* MATLAB Function: '<S423>/Write ERROR' incorporates:
         *  DataStoreRead: '<S420>/Data Store Read'
         *  DataStoreRead: '<S423>/Data Store Read6'
         */
        /* :  if(LOGGER==1) */
        if (rtDW.LOGGER_LIN == 1.0) {
          /* :  for i = 1:numel(ErrCallibration) */
          for (i = 0; i < 9; i++) {
            /* :  if ErrCallibration(i) == 1 */
            if (rtDW.ErrorCalibration_private[i] == 1) {
              /* :  fprintf('LIN1 Failure with actuator #%d\n', int16(i)); */
              printf("LIN1 Failure with actuator #%d\n", (int16_t)(i + 1));
              fflush(stdout);
            }
          }
        }

        /* End of MATLAB Function: '<S423>/Write ERROR' */

        /* DataStoreWrite: '<S420>/Data Store Write' */
        for (i = 0; i < 9; i++) {
          rtDW.ErrorCalibration_private[i] = 0U;
        }

        /* End of DataStoreWrite: '<S420>/Data Store Write' */

        /* Merge: '<S388>/Merge' incorporates:
         *  Constant: '<S420>/Constant'
         *  SignalConversion generated from: '<S420>/Output'
         */
        rtB.Merge_h = 4;

        /* End of Outputs for SubSystem: '<S408>/If Action Subsystem1' */
      }

      /* End of If: '<S408>/If' */
      /* End of Outputs for SubSystem: '<S388>/Switch Case Action Subsystem3' */
      break;

     case 4:
      /* Outputs for IfAction SubSystem: '<S388>/Switch Case Action Subsystem4' incorporates:
       *  ActionPort: '<S409>/Action Port'
       */
      /* Merge: '<S388>/Merge' incorporates:
       *  SignalConversion generated from: '<S409>/step'
       */
      rtB.Merge_h = 0;

      /* End of Outputs for SubSystem: '<S388>/Switch Case Action Subsystem4' */
      break;
    }

    /* End of SwitchCase: '<S388>/Switch Case' */

    /* DataStoreWrite: '<S388>/Data Store Write2' */
    rtDW.stepHoming_private = rtB.Merge_h;

    /* Merge: '<S381>/Merge' incorporates:
     *  DataStoreRead: '<S388>/Data Store Read7'
     */
    rtB.Merge_l = rtDW.stepSig_private;

    /* MATLAB Function: '<S388>/MAX POSITION' incorporates:
     *  Constant: '<S388>/ACT2'
     *  DataStoreRead: '<S388>/Data Store Read5'
     *  DataStoreWrite: '<S388>/Data Store Write1'
     */
    /* :  y = step; */
    /* :  if(LOGGER==2) */
    if (rtDW.LOGGER_LIN == 2.0) {
      /* :  fprintf('LIN1 SIMULINK MAX POSITION '); */
      printf("LIN1 SIMULINK MAX POSITION ");
      fflush(stdout);

      /* :  for i = 1:numel(step) */
      for (i = 0; i < 9; i++) {
        /* :  fprintf('%d ', int16(step(i))); */
        printf("%d ", rtConstP.ACT2_Value[i]);
        fflush(stdout);
      }

      /* :  fprintf('\n'); */
      printf("\n");
      fflush(stdout);
    }

    /* End of MATLAB Function: '<S388>/MAX POSITION' */

    /* MATLAB Function: '<S388>/MIN POSITION' incorporates:
     *  DataStoreRead: '<S388>/Data Store Read3'
     *  DataStoreRead: '<S388>/Data Store Read6'
     */
    /* :  y = step; */
    /* :  if(LOGGER==2) */
    if (rtDW.LOGGER_LIN == 2.0) {
      /* :  fprintf('LIN1 SIMULINK MIN POSITION '); */
      printf("LIN1 SIMULINK MIN POSITION ");
      fflush(stdout);

      /* :  for i = 1:numel(step) */
      for (i = 0; i < 9; i++) {
        /* :  fprintf('%d ', int16(step(i))); */
        printf("%d ", rtDW.MinPositionCh0_private[i]);
        fflush(stdout);
      }

      /* :  fprintf('\n'); */
      printf("\n");
      fflush(stdout);
    }

    /* End of MATLAB Function: '<S388>/MIN POSITION' */
    /* End of Outputs for SubSystem: '<S381>/Homing' */
    break;
  }

  /* End of SwitchCase: '<S381>/Switch Case' */

  /* DataStoreWrite: '<S381>/Finish write stepSig' */
  rtDW.stepSig_private = rtB.Merge_l;
  for (i = 0; i < 9; i++) {
    /* BusCreator: '<S384>/Bus Creator' incorporates:
     *  DataStoreRead: '<S384>/Data Store Read'
     *  DataStoreRead: '<S384>/Data Store Read1'
     *  DataStoreRead: '<S384>/Data Store Read2'
     *  DataStoreRead: '<S384>/Data Store Read3'
     *  DataStoreRead: '<S384>/Data Store Read4'
     *  DataStoreRead: '<S384>/Data Store Read5'
     *  DataStoreRead: '<S384>/Data Store Read6'
     *  DataStoreRead: '<S384>/Data Store Read7'
     *  DataStoreRead: '<S384>/Data Store Read8'
     *  DataStoreWrite: '<S384>/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];

    /* DataStoreWrite: '<S385>/Data Store Write' */
    rtDW.COM_private[i] = 0U;
  }

  /* MATLAB Function: '<S381>/Write' incorporates:
   *  DataStoreRead: '<S381>/Data Store Read3'
   */
  /* :  if(LOGGER == 2) */
  if (rtDW.LOGGER_LIN == 2.0) {
    /* :  fprintf('LIN1 step = %d\n',step); */
    printf("LIN1 step = %d\n", rtb_Switch_hx);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S381>/Write' */

  /* DataStoreWrite: '<S382>/Data Store Write' incorporates:
   *  DataStoreRead: '<S382>/Data Store Read1'
   */
  rtb_Gain_l = rtDW.Actuator_Ch1_Status_Model.Busy;

  /* DataStoreWrite: '<S382>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S382>/Data Store Read1'
   */
  rtb_Gain2 = rtDW.Actuator_Ch1_Status_Model.Error_Connect;

  /* Switch: '<S382>/Switch' incorporates:
   *  Constant: '<S382>/Constant1'
   *  DataStoreRead: '<S382>/Data Store Read'
   *  DataStoreRead: '<S382>/Data Store Read2'
   */
  if (rtDW.stepSig_private_c > 0) {
    rtb_Switch_hx = rtDW.stepSig_private_c;
  } else {
    rtb_Switch_hx = 1;
  }

  /* End of Switch: '<S382>/Switch' */

  /* SwitchCase: '<S382>/Switch Case' */
  switch (rtb_Switch_hx) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S382>/Stop Mode' incorporates:
     *  ActionPort: '<S452>/Action Port'
     */
    StopMode(rtb_Switch_hx, &rtB.Merge_c, &rtb_Gain_l, rtDW.COM_private_h,
             &rtb_Gain2, rtDW.MODE_private_a);

    /* End of Outputs for SubSystem: '<S382>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S382>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S448>/Action Port'
     */
    /* If: '<S448>/If' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S448>/If Action Subsystem' incorporates:
       *  ActionPort: '<S463>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S463>/Data Store Write' */
        rtDW.POS_private_c[i] = 6000U;

        /* DataStoreWrite: '<S463>/Data Store Write1' */
        rtDW.COM_private_h[i] = 2U;
      }

      /* MATLAB Function: '<S463>/Initial CPOS Min' incorporates:
       *  DataStoreRead: '<S463>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Initial CPOS Min - 6000\n'); */
        printf("LIN2 SIMULINK Initial CPOS Min - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S463>/Initial CPOS Min' */

      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S463>/Constant'
       *  Merge: '<S448>/Merge'
       *  SignalConversion generated from: '<S463>/step'
       *  Sum: '<S463>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S448>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S448>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S464>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  Merge: '<S448>/Merge'
       *  SignalConversion generated from: '<S464>/stepIn1'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S448>/If Action Subsystem3' */
    }

    /* End of If: '<S448>/If' */
    /* End of Outputs for SubSystem: '<S382>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S382>/Normal Mode' incorporates:
     *  ActionPort: '<S451>/Action Port'
     */
    /* If: '<S451>/If1' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S451>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S472>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S472>/Data Store Write' */
        rtDW.MODE_private_a[i] = 0U;

        /* DataStoreWrite: '<S472>/Data Store Write1' */
        rtDW.COM_private_h[i] = 1U;
      }

      /* MATLAB Function: '<S472>/Normal Mode' incorporates:
       *  DataStoreRead: '<S472>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Normal Mode\n'); */
        printf("LIN2 SIMULINK Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S472>/Normal Mode' */

      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S472>/Constant'
       *  SignalConversion generated from: '<S472>/step'
       *  Sum: '<S472>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S451>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S451>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S473>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  SignalConversion generated from: '<S473>/stepIn'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S451>/If Action Subsystem3' */
    }

    /* End of If: '<S451>/If1' */
    /* End of Outputs for SubSystem: '<S382>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S382>/Move to position Min' incorporates:
     *  ActionPort: '<S450>/Action Port'
     */
    /* If: '<S450>/If1' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S450>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S469>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S469>/Data Store Write4' incorporates:
         *  Constant: '<S469>/Constant1'
         */
        rtDW.Autos_private_m[i] = 1U;

        /* DataStoreWrite: '<S469>/Data Store Write2' incorporates:
         *  Constant: '<S469>/Constant10'
         */
        rtDW.Stall_private_j[i] = 1U;

        /* DataStoreWrite: '<S469>/Data Store Write3' incorporates:
         *  Constant: '<S469>/Constant11'
         */
        rtDW.Lnoise_private_d[i] = 0U;

        /* DataStoreWrite: '<S469>/Data Store Write6' incorporates:
         *  Constant: '<S469>/Constant14'
         */
        rtDW.Coils_private_n[i] = 0U;

        /* DataStoreWrite: '<S469>/Data Store Write5' incorporates:
         *  Constant: '<S469>/Constant2'
         */
        rtDW.Speed_private_o[i] = 3U;

        /* DataStoreWrite: '<S469>/Data Store Write' */
        rtDW.POS_private_c[i] = 1U;

        /* DataStoreWrite: '<S469>/Data Store Write1' incorporates:
         *  Constant: '<S469>/Constant9'
         */
        rtDW.COM_private_h[i] = 3U;
      }

      /* MATLAB Function: '<S469>/Move to position Min' incorporates:
       *  DataStoreRead: '<S469>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Move to position Min - 1\n'); */
        printf("LIN2 SIMULINK Move to position Min - 1\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S469>/Move to position Min' */

      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S469>/Constant'
       *  SignalConversion generated from: '<S469>/step'
       *  Sum: '<S469>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S450>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S450>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S470>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  SignalConversion generated from: '<S470>/stepIn'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S450>/If Action Subsystem3' */
    }

    /* End of If: '<S450>/If1' */
    /* End of Outputs for SubSystem: '<S382>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S382>/Check Stall Min' incorporates:
     *  ActionPort: '<S446>/Action Port'
     */
    /* RelationalOperator: '<S446>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  RelationalOperator: '<S446>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1);
    }

    /* End of RelationalOperator: '<S446>/Relational Operator1' */

    /* Logic: '<S446>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S446>/Relational Operator'
     */
    rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* RelationalOperator: '<S446>/Relational Operator' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 1);
    }

    /* End of RelationalOperator: '<S446>/Relational Operator' */

    /* Logic: '<S446>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S446>/Relational Operator'
     */
    rtb_LogicalOperator1_f = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_f = (rtb_LogicalOperator1_f ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* If: '<S446>/If2' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     *  DataTypeConversion: '<S446>/Data Type Conversion'
     *  DataTypeConversion: '<S446>/Data Type Conversion1'
     *  Logic: '<S446>/Logical Operator'
     *  Logic: '<S446>/Logical Operator1'
     *  Logic: '<S446>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S446>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S457>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S457>/Constant'
       *  Sum: '<S457>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* MATLAB Function: '<S457>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S457>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Min_position_Ch0 '); */
        printf("LIN2 SIMULINK Min_position_Ch0 ");
        fflush(stdout);

        /* :  for i = 1:numel(step) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('%d ', int16(step(i))); */
          printf("%d ", rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S457>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S446>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S446>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S458>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  SignalConversion generated from: '<S458>/stepIn'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S446>/If Action Subsystem3' */
    }

    /* End of If: '<S446>/If2' */
    /* End of Outputs for SubSystem: '<S382>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S382>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S447>/Action Port'
     */
    /* If: '<S447>/If1' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S447>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S460>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S460>/Data Store Write1' */
        rtDW.COM_private_h[i] = 2U;

        /* DataStoreWrite: '<S460>/Data Store Write' */
        rtDW.POS_private_c[i] = 1U;
      }

      /* MATLAB Function: '<S460>/Initial CPOS Max' incorporates:
       *  DataStoreRead: '<S460>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Initial CPOS Max - 1\n'); */
        printf("LIN2 SIMULINK Initial CPOS Max - 1\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S460>/Initial CPOS Max' */

      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S460>/Constant'
       *  SignalConversion generated from: '<S460>/step'
       *  Sum: '<S460>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S447>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S447>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S461>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  SignalConversion generated from: '<S461>/stepIn'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S447>/If Action Subsystem3' */
    }

    /* End of If: '<S447>/If1' */
    /* End of Outputs for SubSystem: '<S382>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S382>/Move to position Max' incorporates:
     *  ActionPort: '<S449>/Action Port'
     */
    /* If: '<S449>/If1' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S449>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S466>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S466>/Data Store Write4' incorporates:
         *  Constant: '<S466>/Constant1'
         */
        rtDW.Autos_private_m[i] = 1U;

        /* DataStoreWrite: '<S466>/Data Store Write2' incorporates:
         *  Constant: '<S466>/Constant10'
         */
        rtDW.Stall_private_j[i] = 1U;

        /* DataStoreWrite: '<S466>/Data Store Write3' incorporates:
         *  Constant: '<S466>/Constant11'
         */
        rtDW.Lnoise_private_d[i] = 0U;

        /* DataStoreWrite: '<S466>/Data Store Write6' incorporates:
         *  Constant: '<S466>/Constant14'
         */
        rtDW.Coils_private_n[i] = 0U;

        /* DataStoreWrite: '<S466>/Data Store Write5' incorporates:
         *  Constant: '<S466>/Constant2'
         */
        rtDW.Speed_private_o[i] = 3U;

        /* DataStoreWrite: '<S466>/Data Store Write' */
        rtDW.POS_private_c[i] = 6000U;

        /* DataStoreWrite: '<S466>/Data Store Write1' incorporates:
         *  Constant: '<S466>/Constant9'
         */
        rtDW.COM_private_h[i] = 3U;
      }

      /* MATLAB Function: '<S466>/Move to position Max' incorporates:
       *  DataStoreRead: '<S466>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Move to position Max - 6000\n'); */
        printf("LIN2 SIMULINK Move to position Max - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S466>/Move to position Max' */

      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S466>/Constant'
       *  SignalConversion generated from: '<S466>/step'
       *  Sum: '<S466>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S449>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S449>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S467>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  SignalConversion generated from: '<S467>/stepIn'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S449>/If Action Subsystem3' */
    }

    /* End of If: '<S449>/If1' */
    /* End of Outputs for SubSystem: '<S382>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S382>/Check Stall Max' incorporates:
     *  ActionPort: '<S445>/Action Port'
     */
    /* RelationalOperator: '<S445>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  RelationalOperator: '<S445>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1);
    }

    /* End of RelationalOperator: '<S445>/Relational Operator1' */

    /* Logic: '<S445>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S445>/Relational Operator'
     */
    rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* RelationalOperator: '<S445>/Relational Operator' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 6000);
    }

    /* End of RelationalOperator: '<S445>/Relational Operator' */

    /* Logic: '<S445>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S445>/Relational Operator'
     */
    rtb_LogicalOperator1_f = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_f = (rtb_LogicalOperator1_f ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* If: '<S445>/If2' incorporates:
     *  DataStoreRead: '<S382>/Data Store Read1'
     *  DataStoreWrite: '<S382>/Data Store Write'
     *  DataStoreWrite: '<S382>/Data Store Write1'
     *  DataTypeConversion: '<S445>/Data Type Conversion'
     *  DataTypeConversion: '<S445>/Data Type Conversion1'
     *  Logic: '<S445>/Logical Operator'
     *  Logic: '<S445>/Logical Operator1'
     *  Logic: '<S445>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S445>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S454>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  Constant: '<S454>/Constant'
       *  Sum: '<S454>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_hx + 1);

      /* MATLAB Function: '<S454>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S454>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN2 SIMULINK Max_position_Ch0 '); */
        printf("LIN2 SIMULINK Max_position_Ch0 ");
        fflush(stdout);

        /* :  for i = 1:numel(step) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('%d ', int16(step(i))); */
          printf("%d ", rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S454>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S445>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S445>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S455>/Action Port'
       */
      /* Merge: '<S382>/Merge' incorporates:
       *  SignalConversion generated from: '<S455>/stepIn'
       */
      rtB.Merge_c = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S445>/If Action Subsystem3' */
    }

    /* End of If: '<S445>/If2' */
    /* End of Outputs for SubSystem: '<S382>/Check Stall Max' */
    break;

   case 9:
    break;
  }

  /* End of SwitchCase: '<S382>/Switch Case' */

  /* DataStoreWrite: '<S382>/Finish write stepSig' */
  rtDW.stepSig_private_c = rtB.Merge_c;
  for (i = 0; i < 9; i++) {
    /* BusCreator: '<S443>/Bus Creator' incorporates:
     *  DataStoreRead: '<S443>/Data Store Read'
     *  DataStoreRead: '<S443>/Data Store Read1'
     *  DataStoreRead: '<S443>/Data Store Read2'
     *  DataStoreRead: '<S443>/Data Store Read3'
     *  DataStoreRead: '<S443>/Data Store Read4'
     *  DataStoreRead: '<S443>/Data Store Read5'
     *  DataStoreRead: '<S443>/Data Store Read6'
     *  DataStoreRead: '<S443>/Data Store Read7'
     *  DataStoreRead: '<S443>/Data Store Read8'
     *  DataStoreWrite: '<S443>/Data Store Write'
     */
    Actuator_Ch1_Command_Model.POS[i] = rtDW.POS_private_c[i];
    Actuator_Ch1_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_p[i];
    Actuator_Ch1_Command_Model.MODE[i] = rtDW.MODE_private_a[i];
    Actuator_Ch1_Command_Model.COM[i] = rtDW.COM_private_h[i];
    Actuator_Ch1_Command_Model.Stall_SET[i] = rtDW.Stall_private_j[i];
    Actuator_Ch1_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_d[i];
    Actuator_Ch1_Command_Model.Autos_SET[i] = rtDW.Autos_private_m[i];
    Actuator_Ch1_Command_Model.Speed_SET[i] = rtDW.Speed_private_o[i];
    Actuator_Ch1_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_n[i];

    /* DataStoreWrite: '<S444>/Data Store Write' */
    rtDW.COM_private_h[i] = 0U;
  }

  /* MATLAB Function: '<S382>/Write Ignition' incorporates:
   *  DataStoreRead: '<S382>/Data Store Read3'
   */
  /* :  if(LOGGER==2) */
  if (rtDW.LOGGER_LIN == 2.0) {
    /* :  fprintf('LIN2 step = %d\n',step); */
    printf("LIN2 step = %d\n", rtb_Switch_hx);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S382>/Write Ignition' */

  /* DataStoreWrite: '<S383>/Data Store Write' incorporates:
   *  DataStoreRead: '<S383>/Data Store Read1'
   */
  rtb_Gain_l = rtDW.Actuator_Ch2_Status_Model.Busy;

  /* DataStoreWrite: '<S383>/Data Store Write1' incorporates:
   *  DataStoreRead: '<S383>/Data Store Read1'
   */
  rtb_Gain2 = rtDW.Actuator_Ch2_Status_Model.Error_Connect;

  /* Switch: '<S383>/Switch' incorporates:
   *  Constant: '<S383>/Constant1'
   *  DataStoreRead: '<S383>/Data Store Read'
   *  DataStoreRead: '<S383>/Data Store Read2'
   */
  if (rtDW.stepSig_private_p > 0) {
    rtb_Switch_hx = rtDW.stepSig_private_p;
  } else {
    rtb_Switch_hx = 1;
  }

  /* End of Switch: '<S383>/Switch' */

  /* SwitchCase: '<S383>/Switch Case' */
  switch (rtb_Switch_hx) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S383>/Stop Mode' incorporates:
     *  ActionPort: '<S486>/Action Port'
     */
    StopMode(rtb_Switch_hx, &rtB.Merge_cs, &rtb_Gain_l, rtDW.COM_private_j,
             &rtb_Gain2, rtDW.MODE_private_an);

    /* End of Outputs for SubSystem: '<S383>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S383>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S482>/Action Port'
     */
    /* If: '<S482>/If' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S482>/If Action Subsystem' incorporates:
       *  ActionPort: '<S497>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S497>/Data Store Write' */
        rtDW.POS_private_a[i] = 6000U;

        /* DataStoreWrite: '<S497>/Data Store Write1' */
        rtDW.COM_private_j[i] = 2U;
      }

      /* MATLAB Function: '<S497>/Initial CPOS Min' incorporates:
       *  DataStoreRead: '<S497>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Initial CPOS Min - 6000\n'); */
        printf("LIN3 SIMULINK Initial CPOS Min - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S497>/Initial CPOS Min' */

      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S497>/Constant'
       *  Merge: '<S482>/Merge'
       *  SignalConversion generated from: '<S497>/step'
       *  Sum: '<S497>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S482>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S482>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S498>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  Merge: '<S482>/Merge'
       *  SignalConversion generated from: '<S498>/stepIn1'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S482>/If Action Subsystem3' */
    }

    /* End of If: '<S482>/If' */
    /* End of Outputs for SubSystem: '<S383>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S383>/Normal Mode' incorporates:
     *  ActionPort: '<S485>/Action Port'
     */
    /* MATLAB Function: '<S485>/Write Ignition' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreRead: '<S485>/Data Store Read3'
     *  DataStoreWrite: '<S383>/Data Store Write'
     */
    /* :  if(LOGGER==2) */
    if (rtDW.LOGGER_LIN == 2.0) {
      /* :  fprintf('Busy_private = %u\n',step); */
      printf("Busy_private = %u\n", rtDW.Actuator_Ch2_Status_Model.Busy);
      fflush(stdout);
    }

    /* End of MATLAB Function: '<S485>/Write Ignition' */

    /* MATLAB Function: '<S485>/Write Ignition1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     */
    /* :  if(LOGGER==2) */
    if (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 2) {
      /* :  fprintf('Error_Connect_private = %u\n',step); */
      printf("Error_Connect_private = %u\n",
             rtDW.Actuator_Ch2_Status_Model.Error_Connect);
      fflush(stdout);
    }

    /* End of MATLAB Function: '<S485>/Write Ignition1' */

    /* If: '<S485>/If1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S485>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S506>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S506>/Data Store Write' */
        rtDW.MODE_private_an[i] = 0U;

        /* DataStoreWrite: '<S506>/Data Store Write1' */
        rtDW.COM_private_j[i] = 1U;
      }

      /* MATLAB Function: '<S506>/Normal Mode' incorporates:
       *  DataStoreRead: '<S506>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Normal Mode\n'); */
        printf("LIN3 SIMULINK Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S506>/Normal Mode' */

      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S506>/Constant'
       *  SignalConversion generated from: '<S506>/step'
       *  Sum: '<S506>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S485>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S485>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S507>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  SignalConversion generated from: '<S507>/stepIn'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S485>/If Action Subsystem3' */
    }

    /* End of If: '<S485>/If1' */
    /* End of Outputs for SubSystem: '<S383>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S383>/Move to position Min' incorporates:
     *  ActionPort: '<S484>/Action Port'
     */
    /* If: '<S484>/If1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S484>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S503>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S503>/Data Store Write4' incorporates:
         *  Constant: '<S503>/Constant1'
         */
        rtDW.Autos_private_j[i] = 1U;

        /* DataStoreWrite: '<S503>/Data Store Write2' incorporates:
         *  Constant: '<S503>/Constant10'
         */
        rtDW.Stall_private_n[i] = 1U;

        /* DataStoreWrite: '<S503>/Data Store Write3' incorporates:
         *  Constant: '<S503>/Constant11'
         */
        rtDW.Lnoise_private_j[i] = 0U;

        /* DataStoreWrite: '<S503>/Data Store Write6' incorporates:
         *  Constant: '<S503>/Constant14'
         */
        rtDW.Coils_private_f[i] = 0U;

        /* DataStoreWrite: '<S503>/Data Store Write5' incorporates:
         *  Constant: '<S503>/Constant2'
         */
        rtDW.Speed_private_e[i] = 3U;

        /* DataStoreWrite: '<S503>/Data Store Write' */
        rtDW.POS_private_a[i] = 1U;

        /* DataStoreWrite: '<S503>/Data Store Write1' incorporates:
         *  Constant: '<S503>/Constant9'
         */
        rtDW.COM_private_j[i] = 3U;
      }

      /* MATLAB Function: '<S503>/Move to position Min' incorporates:
       *  DataStoreRead: '<S503>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Move to position Min - 1\n'); */
        printf("LIN3 SIMULINK Move to position Min - 1\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S503>/Move to position Min' */

      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S503>/Constant'
       *  SignalConversion generated from: '<S503>/step'
       *  Sum: '<S503>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S484>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S484>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S504>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  SignalConversion generated from: '<S504>/stepIn'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S484>/If Action Subsystem3' */
    }

    /* End of If: '<S484>/If1' */
    /* End of Outputs for SubSystem: '<S383>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S383>/Check Stall Min' incorporates:
     *  ActionPort: '<S480>/Action Port'
     */
    /* RelationalOperator: '<S480>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  RelationalOperator: '<S480>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1);
    }

    /* End of RelationalOperator: '<S480>/Relational Operator1' */

    /* Logic: '<S480>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S480>/Relational Operator'
     */
    rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* RelationalOperator: '<S480>/Relational Operator' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 1);
    }

    /* End of RelationalOperator: '<S480>/Relational Operator' */

    /* Logic: '<S480>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S480>/Relational Operator'
     */
    rtb_LogicalOperator1_f = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_f = (rtb_LogicalOperator1_f ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* If: '<S480>/If2' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     *  DataTypeConversion: '<S480>/Data Type Conversion'
     *  DataTypeConversion: '<S480>/Data Type Conversion1'
     *  Logic: '<S480>/Logical Operator'
     *  Logic: '<S480>/Logical Operator1'
     *  Logic: '<S480>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S480>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S491>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S491>/Constant'
       *  Sum: '<S491>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* MATLAB Function: '<S491>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S491>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Min_position_Ch0 '); */
        printf("LIN3 SIMULINK Min_position_Ch0 ");
        fflush(stdout);

        /* :  for i = 1:numel(step) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('%d ', int16(step(i))); */
          printf("%d ", rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S491>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S480>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S480>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S492>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  SignalConversion generated from: '<S492>/stepIn'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S480>/If Action Subsystem3' */
    }

    /* End of If: '<S480>/If2' */
    /* End of Outputs for SubSystem: '<S383>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S383>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S481>/Action Port'
     */
    /* If: '<S481>/If1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S481>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S494>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S494>/Data Store Write1' */
        rtDW.COM_private_j[i] = 2U;

        /* DataStoreWrite: '<S494>/Data Store Write' */
        rtDW.POS_private_a[i] = 1U;
      }

      /* MATLAB Function: '<S494>/Initial CPOS Max' incorporates:
       *  DataStoreRead: '<S494>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Initial CPOS Max - 1\n'); */
        printf("LIN3 SIMULINK Initial CPOS Max - 1\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S494>/Initial CPOS Max' */

      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S494>/Constant'
       *  SignalConversion generated from: '<S494>/step'
       *  Sum: '<S494>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S481>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S481>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S495>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  SignalConversion generated from: '<S495>/stepIn'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S481>/If Action Subsystem3' */
    }

    /* End of If: '<S481>/If1' */
    /* End of Outputs for SubSystem: '<S383>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S383>/Move to position Max' incorporates:
     *  ActionPort: '<S483>/Action Port'
     */
    /* If: '<S483>/If1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S483>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S500>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S500>/Data Store Write4' incorporates:
         *  Constant: '<S500>/Constant1'
         */
        rtDW.Autos_private_j[i] = 1U;

        /* DataStoreWrite: '<S500>/Data Store Write2' incorporates:
         *  Constant: '<S500>/Constant10'
         */
        rtDW.Stall_private_n[i] = 1U;

        /* DataStoreWrite: '<S500>/Data Store Write3' incorporates:
         *  Constant: '<S500>/Constant11'
         */
        rtDW.Lnoise_private_j[i] = 0U;

        /* DataStoreWrite: '<S500>/Data Store Write6' incorporates:
         *  Constant: '<S500>/Constant14'
         */
        rtDW.Coils_private_f[i] = 0U;

        /* DataStoreWrite: '<S500>/Data Store Write5' incorporates:
         *  Constant: '<S500>/Constant2'
         */
        rtDW.Speed_private_e[i] = 3U;

        /* DataStoreWrite: '<S500>/Data Store Write' */
        rtDW.POS_private_a[i] = 6000U;

        /* DataStoreWrite: '<S500>/Data Store Write1' incorporates:
         *  Constant: '<S500>/Constant9'
         */
        rtDW.COM_private_j[i] = 3U;
      }

      /* MATLAB Function: '<S500>/Move to position Max' incorporates:
       *  DataStoreRead: '<S500>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Move to position Max - 6000\n'); */
        printf("LIN3 SIMULINK Move to position Max - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S500>/Move to position Max' */

      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S500>/Constant'
       *  SignalConversion generated from: '<S500>/step'
       *  Sum: '<S500>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* End of Outputs for SubSystem: '<S483>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S483>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S501>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  SignalConversion generated from: '<S501>/stepIn'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S483>/If Action Subsystem3' */
    }

    /* End of If: '<S483>/If1' */
    /* End of Outputs for SubSystem: '<S383>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S383>/Check Stall Max' incorporates:
     *  ActionPort: '<S479>/Action Port'
     */
    /* RelationalOperator: '<S479>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  RelationalOperator: '<S479>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1);
    }

    /* End of RelationalOperator: '<S479>/Relational Operator1' */

    /* Logic: '<S479>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S479>/Relational Operator'
     */
    rtb_LogicalOperator1 = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* RelationalOperator: '<S479>/Relational Operator' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_htm[i] =
        (rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 6000);
    }

    /* End of RelationalOperator: '<S479>/Relational Operator' */

    /* Logic: '<S479>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S479>/Relational Operator'
     */
    rtb_LogicalOperator1_f = rtb_RelationalOperator_htm[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_f = (rtb_LogicalOperator1_f ||
        rtb_RelationalOperator_htm[i + 1]);
    }

    /* If: '<S479>/If2' incorporates:
     *  DataStoreRead: '<S383>/Data Store Read1'
     *  DataStoreWrite: '<S383>/Data Store Write'
     *  DataStoreWrite: '<S383>/Data Store Write1'
     *  DataTypeConversion: '<S479>/Data Type Conversion'
     *  DataTypeConversion: '<S479>/Data Type Conversion1'
     *  Logic: '<S479>/Logical Operator'
     *  Logic: '<S479>/Logical Operator1'
     *  Logic: '<S479>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S479>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S488>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  Constant: '<S488>/Constant'
       *  Sum: '<S488>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_hx + 1);

      /* MATLAB Function: '<S488>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S488>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER==2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN3 SIMULINK Max_position_Ch0 '); */
        printf("LIN3 SIMULINK Max_position_Ch0 ");
        fflush(stdout);

        /* :  for i = 1:numel(step) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('%d ', int16(step(i))); */
          printf("%d ", rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S488>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S479>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S479>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S489>/Action Port'
       */
      /* Merge: '<S383>/Merge' incorporates:
       *  SignalConversion generated from: '<S489>/stepIn'
       */
      rtB.Merge_cs = rtb_Switch_hx;

      /* End of Outputs for SubSystem: '<S479>/If Action Subsystem3' */
    }

    /* End of If: '<S479>/If2' */
    /* End of Outputs for SubSystem: '<S383>/Check Stall Max' */
    break;

   case 9:
    break;
  }

  /* End of SwitchCase: '<S383>/Switch Case' */

  /* Outport: '<Root>/Out1' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read10'
   */
  rtY.Out1 = CCU_Errors_Model;

  /* DataStoreWrite: '<S383>/Finish write stepSig' */
  rtDW.stepSig_private_p = rtB.Merge_cs;
  for (i = 0; i < 9; i++) {
    /* BusCreator: '<S477>/Bus Creator' incorporates:
     *  DataStoreRead: '<S477>/Data Store Read'
     *  DataStoreRead: '<S477>/Data Store Read1'
     *  DataStoreRead: '<S477>/Data Store Read2'
     *  DataStoreRead: '<S477>/Data Store Read3'
     *  DataStoreRead: '<S477>/Data Store Read4'
     *  DataStoreRead: '<S477>/Data Store Read5'
     *  DataStoreRead: '<S477>/Data Store Read6'
     *  DataStoreRead: '<S477>/Data Store Read7'
     *  DataStoreRead: '<S477>/Data Store Read8'
     *  DataStoreWrite: '<S477>/Data Store Write'
     */
    Actuator_Ch2_Command_Model.POS[i] = rtDW.POS_private_a[i];
    Actuator_Ch2_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_f[i];
    Actuator_Ch2_Command_Model.MODE[i] = rtDW.MODE_private_an[i];
    Actuator_Ch2_Command_Model.COM[i] = rtDW.COM_private_j[i];
    Actuator_Ch2_Command_Model.Stall_SET[i] = rtDW.Stall_private_n[i];
    Actuator_Ch2_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_j[i];
    Actuator_Ch2_Command_Model.Autos_SET[i] = rtDW.Autos_private_j[i];
    Actuator_Ch2_Command_Model.Speed_SET[i] = rtDW.Speed_private_e[i];
    Actuator_Ch2_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_f[i];

    /* DataStoreWrite: '<S478>/Data Store Write' */
    rtDW.COM_private_j[i] = 0U;
  }

  /* MATLAB Function: '<S383>/Write Ignition' incorporates:
   *  DataStoreRead: '<S383>/Data Store Read3'
   */
  /* :  if(LOGGER==2) */
  if (rtDW.LOGGER_LIN == 2.0) {
    /* :  fprintf('LIN3 step = %d\n',step); */
    printf("LIN3 step = %d\n", rtb_Switch_hx);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S383>/Write Ignition' */

  /* DataStoreWrite: '<S4>/Data Store Write' incorporates:
   *  Constant: '<S4>/Constant'
   */
  rtDW.LOGGER_LIN = 2.0;

  /* If: '<S6>/если SC front не завершен' incorporates:
   *  DataStoreRead: '<S6>/Data Store Read1'
   */
  if (rtDW.start_control_finished_front == 0) {
    /* Outputs for IfAction SubSystem: '<S6>/Start Control Front' incorporates:
     *  ActionPort: '<S517>/Action Port'
     */
    /* SwitchCase: '<S517>/Switch Case' incorporates:
     *  DataStoreRead: '<S517>/Data Store Read'
     */
    switch (rtDW.step_start_controle_front) {
     case -1:
      /* Outputs for IfAction SubSystem: '<S517>/Step -1 F' incorporates:
       *  ActionPort: '<S519>/Action Port'
       */
      /* SwitchCase: '<S519>/Switch Case' incorporates:
       *  DataStoreWrite: '<S8>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S519>/Level 0' incorporates:
         *  ActionPort: '<S524>/Action Port'
         */
        /* MATLAB Function: '<S524>/g_assSTART_ENTER_INCAR' */
        g_assSTART_ENTER_INCAR_a(rtB.Merge_b, &AMB);

        /* MATLAB Function: '<S524>/g_ausSTART_ENTER_SETTEMP' */
        /* :  out = g_ausSTART_ENTER_SETTEMP(LVL+1); */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        /* Switch: '<S524>/Switch' incorporates:
         *  Constant: '<S524>/AUTO'
         *  DataStoreRead: '<S524>/Data Store Read'
         *  DataStoreRead: '<S524>/Data Store Read1'
         *  DataStoreRead: '<S524>/Data Store Read2'
         *  Logic: '<S524>/AND'
         *  MATLAB Function: '<S524>/g_ausSTART_ENTER_SETTEMP'
         *  RelationalOperator: '<S524>/Relational Operator'
         *  RelationalOperator: '<S524>/Relational Operator1'
         *  RelationalOperator: '<S524>/Relational Operator2'
         */
        if ((Incar_FL > AMB) && (rtDW.MODE_DRIVER == 1.0) && (rtDW.SET_FL <
             g_ausSTART_ENTER_SETTEMP[i - 1])) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S524>/Constant1'
           *  SignalConversion generated from: '<S524>/step'
           */
          rtB.Merge_i = 0;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S524>/Constant'
           *  SignalConversion generated from: '<S524>/step'
           */
          rtB.Merge_i = -1;
        }

        /* End of Switch: '<S524>/Switch' */
        /* End of Outputs for SubSystem: '<S519>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S519>/Level 1' incorporates:
         *  ActionPort: '<S525>/Action Port'
         */
        /* MATLAB Function: '<S525>/g_assSTART_ENTER_INCAR' */
        g_assSTART_ENTER_INCAR_a(rtB.Merge_b, &AMB);

        /* MATLAB Function: '<S525>/g_ausSTART_ENTER_SETTEMP' */
        /* :  out = int16(g_ausSTART_ENTER_SETTEMP(LVL+1)); */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        Blower_FR = g_ausSTART_ENTER_SETTEMP[i - 1];
        if (Blower_FR > 32767) {
          Blower_FR = 32767U;
        }

        /* Switch: '<S525>/Switch' incorporates:
         *  Constant: '<S525>/AUTO'
         *  DataStoreRead: '<S525>/Data Store Read'
         *  DataStoreRead: '<S525>/Data Store Read1'
         *  DataStoreRead: '<S525>/Data Store Read2'
         *  Logic: '<S525>/AND'
         *  MATLAB Function: '<S525>/g_ausSTART_ENTER_SETTEMP'
         *  RelationalOperator: '<S525>/Relational Operator'
         *  RelationalOperator: '<S525>/Relational Operator1'
         *  RelationalOperator: '<S525>/Relational Operator2'
         */
        if ((Incar_FL > AMB) && (rtDW.MODE_DRIVER == 1.0) && (rtDW.SET_FL <
             Blower_FR)) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S525>/Constant1'
           */
          rtB.Merge_i = 0;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S525>/Constant'
           */
          rtB.Merge_i = -1;
        }

        /* End of Switch: '<S525>/Switch' */
        /* End of Outputs for SubSystem: '<S519>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S519>/Level 2' incorporates:
         *  ActionPort: '<S526>/Action Port'
         */
        /* Merge: '<S517>/Merge' incorporates:
         *  Constant: '<S526>/Constant'
         *  SignalConversion generated from: '<S526>/step'
         */
        rtB.Merge_i = 0;

        /* End of Outputs for SubSystem: '<S519>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S519>/Level 3' incorporates:
         *  ActionPort: '<S527>/Action Port'
         */
        Level3(&rtB.Merge_i, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);

        /* End of Outputs for SubSystem: '<S519>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S519>/Level 4' incorporates:
         *  ActionPort: '<S528>/Action Port'
         */
        Level3(&rtB.Merge_i, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);

        /* End of Outputs for SubSystem: '<S519>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S519>/Level 5' incorporates:
         *  ActionPort: '<S529>/Action Port'
         */
        Level3(&rtB.Merge_i, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);

        /* End of Outputs for SubSystem: '<S519>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S519>/Switch Case' */
      /* End of Outputs for SubSystem: '<S517>/Step -1 F' */
      break;

     case 0:
      /* Outputs for IfAction SubSystem: '<S517>/Step 0 F' incorporates:
       *  ActionPort: '<S520>/Action Port'
       */
      /* SwitchCase: '<S520>/Switch Case' incorporates:
       *  DataStoreWrite: '<S8>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S520>/Level 0' incorporates:
         *  ActionPort: '<S537>/Action Port'
         */
        Level0(&rtB.Merge_i);

        /* End of Outputs for SubSystem: '<S520>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S520>/Level 1' incorporates:
         *  ActionPort: '<S538>/Action Port'
         */
        Level0(&rtB.Merge_i);

        /* End of Outputs for SubSystem: '<S520>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S520>/Level 2' incorporates:
         *  ActionPort: '<S539>/Action Port'
         */
        Level0(&rtB.Merge_i);

        /* End of Outputs for SubSystem: '<S520>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S520>/Level 3' incorporates:
         *  ActionPort: '<S540>/Action Port'
         */
        /* DataStoreWrite: '<S540>/Data Store Write6' incorporates:
         *  Constant: '<S540>/Constant3'
         */
        rtDW.Blower_FL = 20U;

        /* DataStoreWrite: '<S540>/Data Store Write11' incorporates:
         *  Constant: '<S540>/Constant5'
         */
        rtDW.Dtg_FUL = 60U;

        /* DataStoreWrite: '<S540>/Data Store Write13' incorporates:
         *  Constant: '<S540>/Constant7'
         */
        rtDW.Dtg_FLL = 80U;

        /* DataStoreWrite: '<S540>/Data Store Write' incorporates:
         *  MATLAB Function: '<S540>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S540>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S540>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* DataStoreWrite: '<S540>/Data Store Write3' incorporates:
         *  Constant: '<S540>/Mode - def'
         */
        rtDW.Mode_FL = 80U;

        /* DataStoreWrite: '<S540>/Data Store Write7' incorporates:
         *  Constant: '<S540>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* DataStoreWrite: '<S540>/Data Store Write8' incorporates:
         *  Constant: '<S540>/Valve open'
         */
        rtb_u_pe = 1U;

        /* DataStoreWrite: '<S540>/Data Store Write9' incorporates:
         *  Constant: '<S540>/Valve open'
         */
        Valve_2_way = 1U;

        /* MATLAB Function: '<S540>/g_assSTART_COOLANT_STEP0_TO_1 ' */
        /* :  out = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 1 - 2)); */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        rtb_dt_du = (uint32_t)i - 2U;
        if ((uint32_t)i - 2U > (uint32_t)i) {
          rtb_dt_du = 0U;
        }

        /* Merge: '<S517>/Merge' incorporates:
         *  DataStoreRead: '<S540>/Engine coolant temp'
         *  MATLAB Function: '<S540>/g_assSTART_COOLANT_STEP0_TO_1 '
         *  RelationalOperator: '<S540>/Relational Operator'
         *  Switch: '<S540>/Switch'
         */
        rtB.Merge_i = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1[(int32_t)
          rtb_dt_du - 1]);

        /* End of Outputs for SubSystem: '<S520>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S520>/Level 4' incorporates:
         *  ActionPort: '<S541>/Action Port'
         */
        /* DataStoreWrite: '<S541>/Data Store Write6' incorporates:
         *  Constant: '<S541>/Constant3'
         */
        rtDW.Blower_FL = 20U;

        /* DataStoreWrite: '<S541>/Data Store Write11' incorporates:
         *  Constant: '<S541>/Constant5'
         */
        rtDW.Dtg_FUL = 60U;

        /* DataStoreWrite: '<S541>/Data Store Write13' incorporates:
         *  Constant: '<S541>/Constant7'
         */
        rtDW.Dtg_FLL = 80U;

        /* DataStoreWrite: '<S541>/Data Store Write' incorporates:
         *  MATLAB Function: '<S541>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S541>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S541>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* DataStoreWrite: '<S541>/Data Store Write3' incorporates:
         *  Constant: '<S541>/Mode - def'
         */
        rtDW.Mode_FL = 80U;

        /* DataStoreWrite: '<S541>/Data Store Write7' incorporates:
         *  Constant: '<S541>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* DataStoreWrite: '<S541>/Data Store Write8' incorporates:
         *  Constant: '<S541>/Valve open'
         */
        rtb_u_pe = 1U;

        /* DataStoreWrite: '<S541>/Data Store Write9' incorporates:
         *  Constant: '<S541>/Valve open'
         */
        Valve_2_way = 1U;

        /* MATLAB Function: '<S541>/g_assSTART_COOLANT_STEP0_TO_1 ' */
        g_assSTART_COOLANT_STEP0_TO_1_k(rtB.Merge_b, &Incar_FL);

        /* Merge: '<S517>/Merge' incorporates:
         *  DataStoreRead: '<S541>/Engine coolant temp'
         *  RelationalOperator: '<S541>/Relational Operator'
         *  Switch: '<S541>/Switch'
         */
        rtB.Merge_i = (int8_t)(rtDW.ECT > Incar_FL);

        /* End of Outputs for SubSystem: '<S520>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S520>/Level 5' incorporates:
         *  ActionPort: '<S542>/Action Port'
         */
        /* DataStoreWrite: '<S542>/Data Store Write6' incorporates:
         *  Constant: '<S542>/Constant3'
         */
        rtDW.Blower_FL = 20U;

        /* DataStoreWrite: '<S542>/Data Store Write11' incorporates:
         *  Constant: '<S542>/Constant5'
         */
        rtDW.Dtg_FUL = 80U;

        /* DataStoreWrite: '<S542>/Data Store Write13' incorporates:
         *  Constant: '<S542>/Constant7'
         */
        rtDW.Dtg_FLL = 80U;

        /* DataStoreWrite: '<S542>/Data Store Write' incorporates:
         *  MATLAB Function: '<S542>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S542>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S542>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* DataStoreWrite: '<S542>/Data Store Write3' incorporates:
         *  Constant: '<S542>/Mode - def'
         */
        rtDW.Mode_FL = 80U;

        /* DataStoreWrite: '<S542>/Data Store Write7' incorporates:
         *  Constant: '<S542>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* DataStoreWrite: '<S542>/Data Store Write8' incorporates:
         *  Constant: '<S542>/Valve open'
         */
        rtb_u_pe = 1U;

        /* DataStoreWrite: '<S542>/Data Store Write9' incorporates:
         *  Constant: '<S542>/Valve open'
         */
        Valve_2_way = 1U;

        /* MATLAB Function: '<S542>/g_assSTART_COOLANT_STEP0_TO_1 ' */
        g_assSTART_COOLANT_STEP0_TO_1_k(rtB.Merge_b, &Incar_FL);

        /* Merge: '<S517>/Merge' incorporates:
         *  DataStoreRead: '<S542>/Engine coolant temp'
         *  RelationalOperator: '<S542>/Relational Operator'
         *  Switch: '<S542>/Switch'
         */
        rtB.Merge_i = (int8_t)(rtDW.ECT > Incar_FL);

        /* End of Outputs for SubSystem: '<S520>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S520>/Switch Case' */
      /* End of Outputs for SubSystem: '<S517>/Step 0 F' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S517>/Step 1 F' incorporates:
       *  ActionPort: '<S521>/Action Port'
       */
      /* SwitchCase: '<S521>/Switch Case' incorporates:
       *  DataStoreWrite: '<S8>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S521>/Level 0' incorporates:
         *  ActionPort: '<S552>/Action Port'
         */
        /* DataStoreWrite: '<S552>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S552>/3 way valve status'
         */
        uwayvalvestatus(rtB.Merge_b, &rtb_u_pe);

        /* DataStoreWrite: '<S552>/Data Store Write' incorporates:
         *  MATLAB Function: '<S552>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S552>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S552>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* DataStoreWrite: '<S552>/Data Store Write3' incorporates:
         *  MATLAB Function: '<S552>/mode FR step 1'
         */
        modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);

        /* DataStoreWrite: '<S552>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S552>/window heating'
         */
        windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S552>/Data Store Write6' incorporates:
         *  MATLAB Function: '<S552>/blower FR'
         */
        blowerFR(rtB.Merge_b, &rtDW.Blower_FL);

        /* DataStoreWrite: '<S552>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S552>/Dtg_FrontUpper_X'
         */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S552>/Data Store Write13' incorporates:
         *  MATLAB Function: '<S552>/Dtg_FrontLower_X'
         */
        Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);

        /* DataStoreWrite: '<S552>/Data Store Write7' incorporates:
         *  Constant: '<S552>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* RelationalOperator: '<S552>/Equal' incorporates:
         *  DataStoreRead: '<S552>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S552>/Incar temp goto from step 1 to step 2 ' */
        Incartempgotofromstep1tostep2(rtB.Merge_b, &AMB);

        /* MATLAB Function: '<S552>/Time goto from step 1 to step 2 ' */
        /* :  out = int16(g_ausSTART_TIME_STEP1_TO_2(LVL + 1)); */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        Blower_FR = g_ausSTART_TIME_STEP1_TO_2[i - 1];
        if (Blower_FR > 32767) {
          Blower_FR = 32767U;
        }

        /* Switch: '<S552>/Switch' incorporates:
         *  DataStoreRead: '<S552>/incar temp'
         *  DataStoreRead: '<S562>/Data Store Read4'
         *  Gain: '<S552>/из сек в мс'
         *  Logic: '<S552>/Logical Operator'
         *  MATLAB Function: '<S552>/Time goto from step 1 to step 2 '
         *  RelationalOperator: '<S552>/Relational Operator'
         *  RelationalOperator: '<S552>/Relational Operator1'
         *  Sum: '<S562>/Subtract'
         *  UnitDelay: '<S562>/t_start_delay_private '
         */
        if ((Incar_FL < AMB) || (rtDW.t_now -
             rtDW.t_start_delay_private_DSTATE_i > (uint16_t)(1000 * Blower_FR)))
        {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S552>/go to next step'
           *  SignalConversion generated from: '<S552>/step'
           */
          rtB.Merge_i = 2;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S552>/stay at step 1'
           *  SignalConversion generated from: '<S552>/step'
           */
          rtB.Merge_i = 1;
        }

        /* End of Switch: '<S552>/Switch' */

        /* Switch: '<S562>/Switch' incorporates:
         *  DataStoreRead: '<S562>/Data Store Read4'
         *  Logic: '<S562>/Logical Operator3'
         *  Logic: '<S562>/Logical Operator4'
         *  UnitDelay: '<S562>/Cond_prev_private '
         *  UnitDelay: '<S562>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_it)) {
          rtDW.t_start_delay_private_DSTATE_i = rtDW.t_now;
        }

        /* End of Switch: '<S562>/Switch' */

        /* Update for UnitDelay: '<S562>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_it = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S521>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S521>/Level 1' incorporates:
         *  ActionPort: '<S553>/Action Port'
         */
        /* DataStoreWrite: '<S553>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S553>/3 way valve status'
         */
        uwayvalvestatus(rtB.Merge_b, &rtb_u_pe);

        /* DataStoreWrite: '<S553>/Data Store Write' incorporates:
         *  MATLAB Function: '<S553>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S553>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S553>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* DataStoreWrite: '<S553>/Data Store Write3' incorporates:
         *  MATLAB Function: '<S553>/mode FR step 1'
         */
        modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);

        /* DataStoreWrite: '<S553>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S553>/window heating'
         */
        windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S553>/Data Store Write6' incorporates:
         *  MATLAB Function: '<S553>/blower FR'
         */
        blowerFR(rtB.Merge_b, &rtDW.Blower_FL);

        /* DataStoreWrite: '<S553>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S553>/Dtg_FrontUpper_X'
         */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S553>/Data Store Write13' incorporates:
         *  MATLAB Function: '<S553>/Dtg_FrontLower_X'
         */
        Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);

        /* DataStoreWrite: '<S553>/Data Store Write7' incorporates:
         *  Constant: '<S553>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* RelationalOperator: '<S553>/Equal' incorporates:
         *  DataStoreRead: '<S553>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S553>/Incar temp goto from step 1 to step 2 ' */
        Incartempgotofromstep1tostep2(rtB.Merge_b, &AMB);

        /* MATLAB Function: '<S553>/Time goto from step 1 to step 2 ' */
        Timegotofromstep1tostep2(rtB.Merge_b, &Eva_F);

        /* RelationalOperator: '<S553>/Relational Operator1' incorporates:
         *  DataStoreRead: '<S573>/Data Store Read4'
         *  Gain: '<S553>/из сек в мс'
         *  Sum: '<S573>/Subtract'
         *  UnitDelay: '<S573>/t_start_delay_private '
         */
        rtb_LogicalOperator1_f = (rtDW.t_now -
          rtDW.t_start_delay_private_DSTATE_gu > (uint32_t)(1000 * Eva_F));

        /* Switch: '<S573>/Switch' incorporates:
         *  DataStoreRead: '<S573>/Data Store Read4'
         *  Logic: '<S573>/Logical Operator3'
         *  Logic: '<S573>/Logical Operator4'
         *  UnitDelay: '<S573>/Cond_prev_private '
         *  UnitDelay: '<S573>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_l)) {
          rtDW.t_start_delay_private_DSTATE_gu = rtDW.t_now;
        }

        /* End of Switch: '<S573>/Switch' */

        /* Switch: '<S553>/Switch' incorporates:
         *  DataStoreRead: '<S553>/incar temp'
         *  Logic: '<S553>/Logical Operator'
         *  RelationalOperator: '<S553>/Relational Operator'
         */
        if ((Incar_FL < AMB) || rtb_LogicalOperator1_f) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S553>/go to next step'
           */
          rtB.Merge_i = 2;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S553>/stay at step 1'
           */
          rtB.Merge_i = 1;
        }

        /* End of Switch: '<S553>/Switch' */

        /* Update for UnitDelay: '<S573>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_l = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S521>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S521>/Level 2' incorporates:
         *  ActionPort: '<S554>/Action Port'
         */
        /* Merge: '<S517>/Merge' incorporates:
         *  Constant: '<S554>/Constant'
         *  SignalConversion generated from: '<S554>/step'
         */
        rtB.Merge_i = 2;

        /* End of Outputs for SubSystem: '<S521>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S521>/Level 3' incorporates:
         *  ActionPort: '<S555>/Action Port'
         */
        /* DataStoreWrite: '<S555>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S555>/3 way valve status'
         */
        uwayvalvestatus(rtB.Merge_b, &rtb_u_pe);

        /* DataStoreWrite: '<S555>/Data Store Write' incorporates:
         *  MATLAB Function: '<S555>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S555>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S555>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* DataStoreWrite: '<S555>/Data Store Write3' incorporates:
         *  MATLAB Function: '<S555>/mode FR step 1'
         */
        modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);

        /* DataStoreWrite: '<S555>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S555>/window heating'
         */
        windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* MATLAB Function: '<S586>/blower min max' */
        blowerminmax(rtB.Merge_b, rtb_out_fw);

        /* MATLAB Function: '<S586>/ECT min max' */
        ECTminmax(rtB.Merge_b, rtb_out_nh);

        /* DataStoreWrite: '<S555>/Data Store Write6' incorporates:
         *  DataStoreRead: '<S586>/engine coolant temp'
         *  Lookup_n-D: '<S586>/blower для текущего ECT'
         */
        rtDW.Blower_FL = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_nh,
          rtb_out_fw, 1U);

        /* DataStoreWrite: '<S555>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S555>/Dtg_FrontUpper_X'
         */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S555>/Data Store Write13' incorporates:
         *  MATLAB Function: '<S555>/Dtg_FrontLower_X'
         */
        Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);

        /* DataStoreWrite: '<S555>/Data Store Write7' incorporates:
         *  Constant: '<S555>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* RelationalOperator: '<S555>/Equal' incorporates:
         *  DataStoreRead: '<S555>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S555>/Incar temp goto from step 1 to step 2 ' */
        Incartempgotofromstep1tostep2(rtB.Merge_b, &AMB);

        /* Sum: '<S584>/Subtract' incorporates:
         *  DataStoreRead: '<S584>/Data Store Read4'
         *  UnitDelay: '<S584>/t_start_delay_private '
         */
        rtb_dt_h = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_nk;

        /* MATLAB Function: '<S555>/Time goto from step 1 to step 2 ' */
        Timegotofromstep1tostep2(rtB.Merge_b, &Eva_F);

        /* Switch: '<S584>/Switch' incorporates:
         *  DataStoreRead: '<S584>/Data Store Read4'
         *  Logic: '<S584>/Logical Operator3'
         *  Logic: '<S584>/Logical Operator4'
         *  UnitDelay: '<S584>/Cond_prev_private '
         *  UnitDelay: '<S584>/t_start_delay_private '
         */
        /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(LVL + 1 - 3)); */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_a)) {
          rtDW.t_start_delay_private_DSTATE_nk = rtDW.t_now;
        }

        /* End of Switch: '<S584>/Switch' */

        /* MATLAB Function: '<S555>/g_assSTART_COOLANT_TO_STEP2 ' */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
        rtb_dt_du = (uint32_t)i - 3U;

        /* MW:end MISRA2012:D4.1 CERT-C:INT30-C */
        if ((uint32_t)i - 3U > (uint32_t)i) {
          rtb_dt_du = 0U;
        }

        /* Switch: '<S555>/Switch' incorporates:
         *  DataStoreRead: '<S555>/engine coolant temp'
         *  DataStoreRead: '<S555>/incar temp'
         *  Gain: '<S555>/из сек в мс'
         *  Logic: '<S555>/Logical Operator'
         *  MATLAB Function: '<S555>/g_assSTART_COOLANT_TO_STEP2 '
         *  RelationalOperator: '<S555>/Relational Operator'
         *  RelationalOperator: '<S555>/Relational Operator1'
         *  RelationalOperator: '<S555>/Relational Operator2'
         */
        if ((Incar_FL < AMB) || (rtb_dt_h > (uint32_t)(1000 * Eva_F)) ||
            (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[(int32_t)rtb_dt_du - 1])) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S555>/go to next step 2'
           */
          rtB.Merge_i = 2;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S555>/stay at step 1'
           */
          rtB.Merge_i = 1;
        }

        /* End of Switch: '<S555>/Switch' */

        /* Update for UnitDelay: '<S584>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_a = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S521>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S521>/Level 4' incorporates:
         *  ActionPort: '<S556>/Action Port'
         */
        Level4(&rtB.Merge_i, &rtDW.Blower_FL, &Blower_FR, &rtDW.Dtg_FLL,
               &Valve_2_way, &rtDW.Dtg_FUL, &Dtg_FUR, &rtDW.ECT,
               &El_window_heating, &Incar_FL, &rtb_Gain2, &rtb_Gain_l,
               &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtb_Divide1, &rtb_u_pe,
               &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level4_lz);

        /* End of Outputs for SubSystem: '<S521>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S521>/Level 5' incorporates:
         *  ActionPort: '<S557>/Action Port'
         */
        Level4(&rtB.Merge_i, &rtDW.Blower_FL, &Blower_FR, &rtDW.Dtg_FLL,
               &Valve_2_way, &rtDW.Dtg_FUL, &Dtg_FUR, &rtDW.ECT,
               &El_window_heating, &Incar_FL, &rtb_Gain2, &rtb_Gain_l,
               &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtb_Divide1, &rtb_u_pe,
               &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level5_l);

        /* End of Outputs for SubSystem: '<S521>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S521>/Switch Case' */
      /* End of Outputs for SubSystem: '<S517>/Step 1 F' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S517>/Step 2 F' incorporates:
       *  ActionPort: '<S522>/Action Port'
       */
      /* SwitchCase: '<S522>/Switch Case' incorporates:
       *  DataStoreWrite: '<S8>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S522>/Level 0' incorporates:
         *  ActionPort: '<S620>/Action Port'
         */
        /* DataStoreWrite: '<S620>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S620>/3 way valve status'
         */
        uwayvalvestatus_m(rtB.Merge_b, &rtb_u_pe);

        /* MATLAB Function: '<S627>/step' */
        Dtg_FrontLower_X(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S627>/time for step' */
        timeforstep(rtB.Merge_b, &rtb_Gain2);

        /* Switch: '<S627>/Switch' incorporates:
         *  Constant: '<S636>/epsilon'
         *  DataStoreRead: '<S627>/Текущее значение blower '
         *  DataStoreRead: '<S627>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S636>/Relational Operator'
         *  RelationalOperator: '<S640>/Relational Operator'
         *  Sum: '<S636>/Add'
         *  Switch: '<S640>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
          /* DataStoreWrite: '<S620>/Data Store Write13' */
          rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
        } else {
          if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
            /* Switch: '<S640>/Switch' incorporates:
             *  Constant: '<S640>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S640>/Switch' incorporates:
             *  Constant: '<S640>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S620>/Data Store Write13' incorporates:
           *  Constant: '<S627>/Constant'
           *  DataStoreRead: '<S627>/текущее время в мс'
           *  Product: '<S627>/Product1'
           *  Product: '<S627>/change rate (dtg//sec)'
           *  Product: '<S627>/скорость в мс'
           *  Product: '<S627>/шаг изменения'
           *  Sum: '<S627>/Add'
           *  Sum: '<S637>/Subtract'
           *  Switch: '<S640>/Switch'
           *  UnitDelay: '<S637>/Unit Delay'
           */
          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_l / (double)rtb_Gain2 /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_lc) * (double)i
            + (double)rtDW.Dtg_FLL);
        }

        /* End of Switch: '<S627>/Switch' */

        /* MATLAB Function: '<S628>/step' */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S628>/time for step' */
        timeforstep_a(rtB.Merge_b, &rtb_Gain2);

        /* Switch: '<S628>/Switch' incorporates:
         *  Constant: '<S641>/epsilon'
         *  DataStoreRead: '<S628>/Текущее значение blower '
         *  DataStoreRead: '<S628>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S641>/Relational Operator'
         *  RelationalOperator: '<S645>/Relational Operator'
         *  Sum: '<S641>/Add'
         *  Switch: '<S645>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
          /* DataStoreWrite: '<S620>/Data Store Write11' */
          rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
        } else {
          if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
            /* Switch: '<S645>/Switch' incorporates:
             *  Constant: '<S645>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S645>/Switch' incorporates:
             *  Constant: '<S645>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S620>/Data Store Write11' incorporates:
           *  Constant: '<S628>/Constant'
           *  DataStoreRead: '<S628>/текущее время в мс'
           *  Product: '<S628>/Product1'
           *  Product: '<S628>/change rate (dtg//sec)'
           *  Product: '<S628>/скорость в мс'
           *  Product: '<S628>/шаг изменения'
           *  Sum: '<S628>/Add'
           *  Sum: '<S642>/Subtract'
           *  Switch: '<S645>/Switch'
           *  UnitDelay: '<S642>/Unit Delay'
           */
          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_l / (double)rtb_Gain2 /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_jz) * (double)i
            + (double)rtDW.Dtg_FUL);
        }

        /* End of Switch: '<S628>/Switch' */

        /* DataStoreWrite: '<S620>/Data Store Write' incorporates:
         *  MATLAB Function: '<S620>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S620>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S620>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* Sum: '<S651>/Add' incorporates:
         *  DataStoreRead: '<S634>/Текущее значение blower '
         *  DataStoreRead: '<S634>/значение auto (в соответствии с логикой)'
         */
        rtb_Gain_l = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);

        /* RelationalOperator: '<S651>/Relational Operator' incorporates:
         *  Constant: '<S651>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_Gain_l <= 0.01);

        /* MATLAB Function: '<S634>/step' */
        step_l(rtB.Merge_b, &rtb_Gain2);

        /* MATLAB Function: '<S634>/time for step' */
        timeforstep_f(rtB.Merge_b, &rtb_Gain_l);

        /* Switch: '<S634>/Switch' incorporates:
         *  DataStoreRead: '<S634>/Текущее значение blower '
         *  DataStoreRead: '<S634>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S655>/Relational Operator'
         *  Switch: '<S655>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S620>/Data Store Write3' incorporates:
           *  DataStoreRead: '<S634>/значение auto (в соответствии с логикой)'
           */
          rtDW.Mode_FL = rtDW.Mode_logic_FL;
        } else {
          if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
            /* Switch: '<S655>/Switch' incorporates:
             *  Constant: '<S655>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S655>/Switch' incorporates:
             *  Constant: '<S655>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S620>/Data Store Write3' incorporates:
           *  Constant: '<S634>/Constant'
           *  DataStoreRead: '<S634>/Текущее значение blower '
           *  DataStoreRead: '<S634>/текущее время в мс'
           *  Product: '<S634>/Product1'
           *  Product: '<S634>/change rate (step//sec)'
           *  Product: '<S634>/скорость в мс'
           *  Product: '<S634>/шаг изменения'
           *  Sum: '<S634>/Add'
           *  Sum: '<S652>/Subtract'
           *  Switch: '<S655>/Switch'
           *  UnitDelay: '<S652>/Unit Delay'
           */
          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain2 / (double)rtb_Gain_l /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_d) * (double)i
            + (double)rtDW.Mode_FL);
        }

        /* End of Switch: '<S634>/Switch' */

        /* Sum: '<S646>/Add' incorporates:
         *  DataStoreRead: '<S631>/Текущее значение blower '
         *  DataStoreRead: '<S631>/значение auto (в соответствии с логикой)'
         */
        /* :  out = g_aucSTART_ELEC_WINDOW(LVL + 1 + 6); */
        Blower_FR = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);

        /* RelationalOperator: '<S646>/Relational Operator' incorporates:
         *  Constant: '<S646>/epsilon'
         */
        rtb_LogicalOperator1 = (Blower_FR <= 0.01);

        /* MATLAB Function: '<S631>/blower step' */
        blowerstep(rtB.Merge_b, &rtb_out_jk);

        /* MATLAB Function: '<S631>/blower time for step' */
        blowertimeforstep(rtB.Merge_b, &Blower_FR);

        /* Switch: '<S631>/Switch' incorporates:
         *  DataStoreRead: '<S631>/Текущее значение blower '
         *  DataStoreRead: '<S631>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S650>/Relational Operator'
         *  Switch: '<S650>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S620>/Data Store Write6' incorporates:
           *  DataStoreRead: '<S631>/значение auto (в соответствии с логикой)'
           */
          rtDW.Blower_FL = rtDW.Blower_logic_FL;
        } else {
          if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
            /* Switch: '<S650>/Switch' incorporates:
             *  Constant: '<S650>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S650>/Switch' incorporates:
             *  Constant: '<S650>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S620>/Data Store Write6' incorporates:
           *  Constant: '<S631>/Constant'
           *  DataStoreRead: '<S631>/Текущее значение blower '
           *  DataStoreRead: '<S631>/текущее время в мс'
           *  Product: '<S631>/Product1'
           *  Product: '<S631>/change rate (step//sec)'
           *  Product: '<S631>/скорость в мс'
           *  Product: '<S631>/шаг изменения'
           *  Sum: '<S631>/Add'
           *  Sum: '<S647>/Subtract'
           *  Switch: '<S650>/Switch'
           *  UnitDelay: '<S647>/Unit Delay'
           */
          rtDW.Blower_FL = (uint16_t)((double)rtb_out_jk / (double)Blower_FR /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_n) * (double)i
            + (double)rtDW.Blower_FL);
        }

        /* End of Switch: '<S631>/Switch' */

        /* DataStoreWrite: '<S620>/Data Store Write7' incorporates:
         *  Constant: '<S620>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* RelationalOperator: '<S620>/Equal' incorporates:
         *  DataStoreRead: '<S620>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* Sum: '<S629>/Subtract' incorporates:
         *  DataStoreRead: '<S629>/Data Store Read4'
         *  UnitDelay: '<S629>/t_start_delay_private '
         */
        rtb_dt_du = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_n;

        /* Switch: '<S629>/Switch' incorporates:
         *  DataStoreRead: '<S629>/Data Store Read4'
         *  Logic: '<S629>/Logical Operator3'
         *  Logic: '<S629>/Logical Operator4'
         *  UnitDelay: '<S629>/Cond_prev_private '
         *  UnitDelay: '<S629>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_p)) {
          rtDW.t_start_delay_private_DSTATE_n = rtDW.t_now;
        }

        /* End of Switch: '<S629>/Switch' */

        /* MATLAB Function: '<S620>/Time goto from step 2 to step 3 ' */
        Timegotofromstep2tostep3(rtB.Merge_b, &Incar_FL);

        /* Switch: '<S620>/Switch' incorporates:
         *  Gain: '<S620>/из сек в мс'
         *  RelationalOperator: '<S620>/Relational Operator1'
         */
        if (rtb_dt_du > (uint32_t)(1000 * Incar_FL)) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S620>/go to next step'
           */
          rtB.Merge_i = 2;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S620>/stay at step 1'
           */
          rtB.Merge_i = 1;
        }

        /* End of Switch: '<S620>/Switch' */

        /* Update for UnitDelay: '<S637>/Unit Delay' incorporates:
         *  DataStoreRead: '<S627>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_lc = rtDW.t_now;

        /* Update for UnitDelay: '<S642>/Unit Delay' incorporates:
         *  DataStoreRead: '<S628>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_jz = rtDW.t_now;

        /* Update for UnitDelay: '<S652>/Unit Delay' incorporates:
         *  DataStoreRead: '<S634>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_d = rtDW.t_now;

        /* Update for UnitDelay: '<S647>/Unit Delay' incorporates:
         *  DataStoreRead: '<S631>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_n = rtDW.t_now;

        /* Update for UnitDelay: '<S629>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_p = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S522>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S522>/Level 1' incorporates:
         *  ActionPort: '<S621>/Action Port'
         */
        /* DataStoreWrite: '<S621>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S621>/3 way valve status'
         */
        uwayvalvestatus_m(rtB.Merge_b, &rtb_u_pe);

        /* MATLAB Function: '<S657>/step' */
        Dtg_FrontLower_X(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S657>/time for step' */
        timeforstep(rtB.Merge_b, &rtb_Gain2);

        /* Switch: '<S657>/Switch' incorporates:
         *  Constant: '<S666>/epsilon'
         *  DataStoreRead: '<S657>/Текущее значение blower '
         *  DataStoreRead: '<S657>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S666>/Relational Operator'
         *  RelationalOperator: '<S670>/Relational Operator'
         *  Sum: '<S666>/Add'
         *  Switch: '<S670>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
          /* DataStoreWrite: '<S621>/Data Store Write13' */
          rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
        } else {
          if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
            /* Switch: '<S670>/Switch' incorporates:
             *  Constant: '<S670>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S670>/Switch' incorporates:
             *  Constant: '<S670>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S621>/Data Store Write13' incorporates:
           *  Constant: '<S657>/Constant'
           *  DataStoreRead: '<S657>/текущее время в мс'
           *  Product: '<S657>/Product1'
           *  Product: '<S657>/change rate (dtg//sec)'
           *  Product: '<S657>/скорость в мс'
           *  Product: '<S657>/шаг изменения'
           *  Sum: '<S657>/Add'
           *  Sum: '<S667>/Subtract'
           *  Switch: '<S670>/Switch'
           *  UnitDelay: '<S667>/Unit Delay'
           */
          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_l / (double)rtb_Gain2 /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p) * (double)i
            + (double)rtDW.Dtg_FLL);
        }

        /* End of Switch: '<S657>/Switch' */

        /* MATLAB Function: '<S658>/step' */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S658>/time for step' */
        timeforstep_a(rtB.Merge_b, &rtb_Gain2);

        /* Switch: '<S658>/Switch' incorporates:
         *  Constant: '<S671>/epsilon'
         *  DataStoreRead: '<S658>/Текущее значение blower '
         *  DataStoreRead: '<S658>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S671>/Relational Operator'
         *  RelationalOperator: '<S675>/Relational Operator'
         *  Sum: '<S671>/Add'
         *  Switch: '<S675>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
          /* DataStoreWrite: '<S621>/Data Store Write11' */
          rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
        } else {
          if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
            /* Switch: '<S675>/Switch' incorporates:
             *  Constant: '<S675>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S675>/Switch' incorporates:
             *  Constant: '<S675>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S621>/Data Store Write11' incorporates:
           *  Constant: '<S658>/Constant'
           *  DataStoreRead: '<S658>/текущее время в мс'
           *  Product: '<S658>/Product1'
           *  Product: '<S658>/change rate (dtg//sec)'
           *  Product: '<S658>/скорость в мс'
           *  Product: '<S658>/шаг изменения'
           *  Sum: '<S658>/Add'
           *  Sum: '<S672>/Subtract'
           *  Switch: '<S675>/Switch'
           *  UnitDelay: '<S672>/Unit Delay'
           */
          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_l / (double)rtb_Gain2 /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_g) * (double)i
            + (double)rtDW.Dtg_FUL);
        }

        /* End of Switch: '<S658>/Switch' */

        /* DataStoreWrite: '<S621>/Data Store Write' incorporates:
         *  MATLAB Function: '<S621>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S621>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S621>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* Sum: '<S681>/Add' incorporates:
         *  DataStoreRead: '<S664>/Текущее значение blower '
         *  DataStoreRead: '<S664>/значение auto (в соответствии с логикой)'
         */
        rtb_Gain_l = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);

        /* MATLAB Function: '<S664>/step' */
        step_l(rtB.Merge_b, &rtb_Gain2);

        /* MATLAB Function: '<S664>/time for step' */
        timeforstep_f(rtB.Merge_b, &rtb_u_pe);

        /* Switch: '<S664>/Switch' incorporates:
         *  Constant: '<S681>/epsilon'
         *  DataStoreRead: '<S664>/Текущее значение blower '
         *  DataStoreRead: '<S664>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S681>/Relational Operator'
         *  RelationalOperator: '<S685>/Relational Operator'
         *  Switch: '<S685>/Switch'
         */
        if (rtb_Gain_l <= 0.01) {
          /* DataStoreWrite: '<S621>/Data Store Write3' incorporates:
           *  DataStoreRead: '<S664>/значение auto (в соответствии с логикой)'
           */
          rtDW.Mode_FL = rtDW.Mode_logic_FL;
        } else {
          if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
            /* Switch: '<S685>/Switch' incorporates:
             *  Constant: '<S685>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S685>/Switch' incorporates:
             *  Constant: '<S685>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S621>/Data Store Write3' incorporates:
           *  Constant: '<S664>/Constant'
           *  DataStoreRead: '<S664>/Текущее значение blower '
           *  DataStoreRead: '<S664>/текущее время в мс'
           *  Product: '<S664>/Product1'
           *  Product: '<S664>/change rate (step//sec)'
           *  Product: '<S664>/скорость в мс'
           *  Product: '<S664>/шаг изменения'
           *  Sum: '<S664>/Add'
           *  Sum: '<S682>/Subtract'
           *  Switch: '<S685>/Switch'
           *  UnitDelay: '<S682>/Unit Delay'
           */
          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain2 / (double)rtb_u_pe / 1000.0
            * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_l) * (double)i +
            (double)rtDW.Mode_FL);
        }

        /* End of Switch: '<S664>/Switch' */

        /* MATLAB Function: '<S621>/window heating' */
        windowheating_k(rtB.Merge_b, &rtb_Gain_l);

        /* Sum: '<S676>/Add' incorporates:
         *  DataStoreRead: '<S661>/Текущее значение blower '
         *  DataStoreRead: '<S661>/значение auto (в соответствии с логикой)'
         */
        Blower_FR = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);

        /* RelationalOperator: '<S676>/Relational Operator' incorporates:
         *  Constant: '<S676>/epsilon'
         */
        rtb_LogicalOperator1 = (Blower_FR <= 0.01);

        /* MATLAB Function: '<S661>/blower step' */
        blowerstep(rtB.Merge_b, &rtb_out_jk);

        /* MATLAB Function: '<S661>/blower time for step' */
        blowertimeforstep(rtB.Merge_b, &Blower_FR);

        /* Switch: '<S661>/Switch' incorporates:
         *  DataStoreRead: '<S661>/Текущее значение blower '
         *  DataStoreRead: '<S661>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S680>/Relational Operator'
         *  Switch: '<S680>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S621>/Data Store Write6' incorporates:
           *  DataStoreRead: '<S661>/значение auto (в соответствии с логикой)'
           */
          rtDW.Blower_FL = rtDW.Blower_logic_FL;
        } else {
          if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
            /* Switch: '<S680>/Switch' incorporates:
             *  Constant: '<S680>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S680>/Switch' incorporates:
             *  Constant: '<S680>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S621>/Data Store Write6' incorporates:
           *  Constant: '<S661>/Constant'
           *  DataStoreRead: '<S661>/Текущее значение blower '
           *  DataStoreRead: '<S661>/текущее время в мс'
           *  Product: '<S661>/Product1'
           *  Product: '<S661>/change rate (step//sec)'
           *  Product: '<S661>/скорость в мс'
           *  Product: '<S661>/шаг изменения'
           *  Sum: '<S661>/Add'
           *  Sum: '<S677>/Subtract'
           *  Switch: '<S680>/Switch'
           *  UnitDelay: '<S677>/Unit Delay'
           */
          rtDW.Blower_FL = (uint16_t)((double)rtb_out_jk / (double)Blower_FR /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gw) * (double)i
            + (double)rtDW.Blower_FL);
        }

        /* End of Switch: '<S661>/Switch' */

        /* DataStoreWrite: '<S621>/Data Store Write7' incorporates:
         *  Constant: '<S621>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* RelationalOperator: '<S621>/Equal' incorporates:
         *  DataStoreRead: '<S621>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* Sum: '<S659>/Subtract' incorporates:
         *  DataStoreRead: '<S659>/Data Store Read4'
         *  UnitDelay: '<S659>/t_start_delay_private '
         */
        rtb_dt_du = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_bd;

        /* Switch: '<S659>/Switch' incorporates:
         *  DataStoreRead: '<S659>/Data Store Read4'
         *  Logic: '<S659>/Logical Operator3'
         *  Logic: '<S659>/Logical Operator4'
         *  UnitDelay: '<S659>/Cond_prev_private '
         *  UnitDelay: '<S659>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_d)) {
          rtDW.t_start_delay_private_DSTATE_bd = rtDW.t_now;
        }

        /* End of Switch: '<S659>/Switch' */

        /* MATLAB Function: '<S621>/Time goto from step 2 to step 3 ' */
        Timegotofromstep2tostep3(rtB.Merge_b, &Incar_FL);

        /* Switch: '<S621>/Switch' incorporates:
         *  Gain: '<S621>/из сек в мс'
         *  RelationalOperator: '<S621>/Relational Operator1'
         */
        if (rtb_dt_du > (uint32_t)(1000 * Incar_FL)) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S621>/go to next step'
           */
          rtB.Merge_i = 2;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S621>/stay at step 1'
           */
          rtB.Merge_i = 1;
        }

        /* End of Switch: '<S621>/Switch' */

        /* Update for UnitDelay: '<S667>/Unit Delay' incorporates:
         *  DataStoreRead: '<S657>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_p = rtDW.t_now;

        /* Update for UnitDelay: '<S672>/Unit Delay' incorporates:
         *  DataStoreRead: '<S658>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_g = rtDW.t_now;

        /* Update for UnitDelay: '<S682>/Unit Delay' incorporates:
         *  DataStoreRead: '<S664>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_l = rtDW.t_now;

        /* Update for UnitDelay: '<S677>/Unit Delay' incorporates:
         *  DataStoreRead: '<S661>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_gw = rtDW.t_now;

        /* Update for UnitDelay: '<S659>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_d = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S522>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S522>/Level 2' incorporates:
         *  ActionPort: '<S622>/Action Port'
         */
        /* Merge: '<S517>/Merge' incorporates:
         *  Constant: '<S622>/Constant'
         *  SignalConversion generated from: '<S622>/step'
         */
        rtB.Merge_i = 3;

        /* End of Outputs for SubSystem: '<S522>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S522>/Level 3' incorporates:
         *  ActionPort: '<S623>/Action Port'
         */
        Level3_d(&rtB.Merge_i, &Autodefog, &rtDW.Blower_FL, &Blower_FR,
                 &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, &rtb_Gain_l, &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR,
                 &rtDW.Mode_logic_FL, &rtb_Divide1, &rtb_u_pe,
                 &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level3_dl);

        /* End of Outputs for SubSystem: '<S522>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S522>/Level 4' incorporates:
         *  ActionPort: '<S624>/Action Port'
         */
        Level3_d(&rtB.Merge_i, &Autodefog, &rtDW.Blower_FL, &Blower_FR,
                 &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, &rtb_Gain_l, &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR,
                 &rtDW.Mode_logic_FL, &rtb_Divide1, &rtb_u_pe,
                 &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level4_g);

        /* End of Outputs for SubSystem: '<S522>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S522>/Level 5' incorporates:
         *  ActionPort: '<S625>/Action Port'
         */
        /* DataStoreWrite: '<S625>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S625>/3 way valve status'
         */
        uwayvalvestatus_m(rtB.Merge_b, &rtb_u_pe);

        /* MATLAB Function: '<S749>/step' */
        Dtg_FrontLower_X(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S749>/time for step' */
        timeforstep(rtB.Merge_b, &rtb_Gain2);

        /* Switch: '<S749>/Switch' incorporates:
         *  Constant: '<S759>/epsilon'
         *  DataStoreRead: '<S749>/Текущее значение blower '
         *  DataStoreRead: '<S749>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S759>/Relational Operator'
         *  RelationalOperator: '<S763>/Relational Operator'
         *  Sum: '<S759>/Add'
         *  Switch: '<S763>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
          /* DataStoreWrite: '<S625>/Data Store Write13' */
          rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
        } else {
          if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
            /* Switch: '<S763>/Switch' incorporates:
             *  Constant: '<S763>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S763>/Switch' incorporates:
             *  Constant: '<S763>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S625>/Data Store Write13' incorporates:
           *  Constant: '<S749>/Constant'
           *  DataStoreRead: '<S749>/текущее время в мс'
           *  Product: '<S749>/Product1'
           *  Product: '<S749>/change rate (dtg//sec)'
           *  Product: '<S749>/скорость в мс'
           *  Product: '<S749>/шаг изменения'
           *  Sum: '<S749>/Add'
           *  Sum: '<S760>/Subtract'
           *  Switch: '<S763>/Switch'
           *  UnitDelay: '<S760>/Unit Delay'
           */
          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Gain_l / (double)rtb_Gain2 /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE) * (double)i +
            (double)rtDW.Dtg_FLL);
        }

        /* End of Switch: '<S749>/Switch' */

        /* MATLAB Function: '<S750>/step' */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S750>/time for step' */
        timeforstep_a(rtB.Merge_b, &rtb_Gain2);

        /* Switch: '<S750>/Switch' incorporates:
         *  Constant: '<S764>/epsilon'
         *  DataStoreRead: '<S750>/Текущее значение blower '
         *  DataStoreRead: '<S750>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S764>/Relational Operator'
         *  RelationalOperator: '<S768>/Relational Operator'
         *  Sum: '<S764>/Add'
         *  Switch: '<S768>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
          /* DataStoreWrite: '<S625>/Data Store Write11' */
          rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
        } else {
          if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
            /* Switch: '<S768>/Switch' incorporates:
             *  Constant: '<S768>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S768>/Switch' incorporates:
             *  Constant: '<S768>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S625>/Data Store Write11' incorporates:
           *  Constant: '<S750>/Constant'
           *  DataStoreRead: '<S750>/текущее время в мс'
           *  Product: '<S750>/Product1'
           *  Product: '<S750>/change rate (dtg//sec)'
           *  Product: '<S750>/скорость в мс'
           *  Product: '<S750>/шаг изменения'
           *  Sum: '<S750>/Add'
           *  Sum: '<S765>/Subtract'
           *  Switch: '<S768>/Switch'
           *  UnitDelay: '<S765>/Unit Delay'
           */
          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Gain_l / (double)rtb_Gain2 /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_b) * (double)i
            + (double)rtDW.Dtg_FUL);
        }

        /* End of Switch: '<S750>/Switch' */

        /* DataStoreWrite: '<S625>/Data Store Write' incorporates:
         *  MATLAB Function: '<S625>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S625>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S625>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Gain2);

        /* MATLAB Function: '<S625>/autodemist (autodefog)' */
        autodemistautodefog(rtB.Merge_b, &rtb_Gain_l);

        /* Sum: '<S774>/Add' incorporates:
         *  DataStoreRead: '<S757>/Текущее значение blower '
         *  DataStoreRead: '<S757>/значение auto (в соответствии с логикой)'
         */
        rtb_Gain2 = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);

        /* MATLAB Function: '<S757>/step' */
        step_l(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S757>/time for step' */
        timeforstep_f(rtB.Merge_b, &rtb_u_pe);

        /* Switch: '<S757>/Switch' incorporates:
         *  Constant: '<S774>/epsilon'
         *  DataStoreRead: '<S757>/Текущее значение blower '
         *  DataStoreRead: '<S757>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S774>/Relational Operator'
         *  RelationalOperator: '<S778>/Relational Operator'
         *  Switch: '<S778>/Switch'
         */
        if (rtb_Gain2 <= 0.01) {
          /* DataStoreWrite: '<S625>/Data Store Write3' incorporates:
           *  DataStoreRead: '<S757>/значение auto (в соответствии с логикой)'
           */
          rtDW.Mode_FL = rtDW.Mode_logic_FL;
        } else {
          if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
            /* Switch: '<S778>/Switch' incorporates:
             *  Constant: '<S778>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S778>/Switch' incorporates:
             *  Constant: '<S778>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S625>/Data Store Write3' incorporates:
           *  Constant: '<S757>/Constant'
           *  DataStoreRead: '<S757>/Текущее значение blower '
           *  DataStoreRead: '<S757>/текущее время в мс'
           *  Product: '<S757>/Product1'
           *  Product: '<S757>/change rate (step//sec)'
           *  Product: '<S757>/скорость в мс'
           *  Product: '<S757>/шаг изменения'
           *  Sum: '<S757>/Add'
           *  Sum: '<S775>/Subtract'
           *  Switch: '<S778>/Switch'
           *  UnitDelay: '<S775>/Unit Delay'
           */
          rtDW.Mode_FL = (uint8_t)((double)rtb_Gain_l / (double)rtb_u_pe /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_m) * (double)i
            + (double)rtDW.Mode_FL);
        }

        /* End of Switch: '<S757>/Switch' */

        /* MATLAB Function: '<S625>/window heating' */
        windowheating_k(rtB.Merge_b, &rtb_Gain2);

        /* Sum: '<S769>/Add' incorporates:
         *  DataStoreRead: '<S754>/Текущее значение blower '
         *  DataStoreRead: '<S754>/значение auto (в соответствии с логикой)'
         */
        Blower_FR = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);

        /* RelationalOperator: '<S769>/Relational Operator' incorporates:
         *  Constant: '<S769>/epsilon'
         */
        rtb_LogicalOperator1 = (Blower_FR <= 0.01);

        /* MATLAB Function: '<S754>/blower step' */
        blowerstep(rtB.Merge_b, &rtb_out_jk);

        /* MATLAB Function: '<S754>/blower time for step' */
        blowertimeforstep(rtB.Merge_b, &Blower_FR);

        /* Switch: '<S754>/Switch' incorporates:
         *  DataStoreRead: '<S754>/Текущее значение blower '
         *  DataStoreRead: '<S754>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S773>/Relational Operator'
         *  Switch: '<S773>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S625>/Data Store Write6' incorporates:
           *  DataStoreRead: '<S754>/значение auto (в соответствии с логикой)'
           */
          rtDW.Blower_FL = rtDW.Blower_logic_FL;
        } else {
          if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
            /* Switch: '<S773>/Switch' incorporates:
             *  Constant: '<S773>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S773>/Switch' incorporates:
             *  Constant: '<S773>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S625>/Data Store Write6' incorporates:
           *  Constant: '<S754>/Constant'
           *  DataStoreRead: '<S754>/Текущее значение blower '
           *  DataStoreRead: '<S754>/текущее время в мс'
           *  Product: '<S754>/Product1'
           *  Product: '<S754>/change rate (step//sec)'
           *  Product: '<S754>/скорость в мс'
           *  Product: '<S754>/шаг изменения'
           *  Sum: '<S754>/Add'
           *  Sum: '<S770>/Subtract'
           *  Switch: '<S773>/Switch'
           *  UnitDelay: '<S770>/Unit Delay'
           */
          rtDW.Blower_FL = (uint16_t)((double)rtb_out_jk / (double)Blower_FR /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_j) * (double)i
            + (double)rtDW.Blower_FL);
        }

        /* End of Switch: '<S754>/Switch' */

        /* DataStoreWrite: '<S625>/Data Store Write7' incorporates:
         *  Constant: '<S625>/Recirc logic Partial REC'
         */
        rtb_Divide1 = 1.0;

        /* RelationalOperator: '<S625>/Equal' incorporates:
         *  DataStoreRead: '<S625>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S625>/Time goto from step 2 to step 3 ' */
        Timegotofromstep2tostep3(rtB.Merge_b, &Incar_FL);

        /* RelationalOperator: '<S625>/Relational Operator1' incorporates:
         *  DataStoreRead: '<S751>/Data Store Read4'
         *  Gain: '<S625>/из сек в мс'
         *  Sum: '<S751>/Subtract'
         *  UnitDelay: '<S751>/t_start_delay_private '
         */
        rtb_LogicalOperator1_f = (rtDW.t_now -
          rtDW.t_start_delay_private_DSTATE_g > (uint32_t)(1000 * Incar_FL));

        /* Switch: '<S751>/Switch' incorporates:
         *  DataStoreRead: '<S751>/Data Store Read4'
         *  Logic: '<S751>/Logical Operator3'
         *  Logic: '<S751>/Logical Operator4'
         *  UnitDelay: '<S751>/Cond_prev_private '
         *  UnitDelay: '<S751>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_fw)) {
          rtDW.t_start_delay_private_DSTATE_g = rtDW.t_now;
        }

        /* End of Switch: '<S751>/Switch' */

        /* Switch: '<S625>/Switch' incorporates:
         *  DataStoreRead: '<S625>/Data Store Read'
         *  Logic: '<S625>/Logical Operator'
         */
        if (rtb_LogicalOperator1_f || rtDW.HI_logic_on) {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S625>/go to next step'
           */
          rtB.Merge_i = 2;
        } else {
          /* Merge: '<S517>/Merge' incorporates:
           *  Constant: '<S625>/stay at step 1'
           */
          rtB.Merge_i = 1;
        }

        /* End of Switch: '<S625>/Switch' */

        /* Update for UnitDelay: '<S760>/Unit Delay' incorporates:
         *  DataStoreRead: '<S749>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE = rtDW.t_now;

        /* Update for UnitDelay: '<S765>/Unit Delay' incorporates:
         *  DataStoreRead: '<S750>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_b = rtDW.t_now;

        /* Update for UnitDelay: '<S775>/Unit Delay' incorporates:
         *  DataStoreRead: '<S757>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_m = rtDW.t_now;

        /* Update for UnitDelay: '<S770>/Unit Delay' incorporates:
         *  DataStoreRead: '<S754>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_j = rtDW.t_now;

        /* Update for UnitDelay: '<S751>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_fw = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S522>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S522>/Switch Case' */
      /* End of Outputs for SubSystem: '<S517>/Step 2 F' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S517>/Step 3' incorporates:
       *  ActionPort: '<S523>/Action Port'
       */
      Step3(&rtB.Merge_i, &rtDW.start_control_finished_front);

      /* End of Outputs for SubSystem: '<S517>/Step 3' */
      break;
    }

    /* End of SwitchCase: '<S517>/Switch Case' */

    /* DataStoreWrite: '<S517>/Data Store Write' */
    rtDW.step_start_controle_front = rtB.Merge_i;

    /* End of Outputs for SubSystem: '<S6>/Start Control Front' */
  }

  /* End of If: '<S6>/если SC front не завершен' */

  /* If: '<S6>/если SC rear не завершен1' incorporates:
   *  DataStoreRead: '<S6>/Data Store Read3'
   */
  if (rtDW.start_control_finished_rear == 0.0) {
    /* Outputs for IfAction SubSystem: '<S6>/Start Control Rear' incorporates:
     *  ActionPort: '<S518>/Action Port'
     */
    /* SwitchCase: '<S518>/Switch Case' incorporates:
     *  DataStoreRead: '<S518>/Data Store Read'
     */
    switch (rtDW.step_start_controle_rear) {
     case -1:
      /* Outputs for IfAction SubSystem: '<S518>/Step -1 F' incorporates:
       *  ActionPort: '<S779>/Action Port'
       */
      /* SwitchCase: '<S779>/Switch Case' incorporates:
       *  DataStoreRead: '<S779>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S779>/Level 0' incorporates:
         *  ActionPort: '<S784>/Action Port'
         */
        /* MATLAB Function: '<S784>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S784>/Data Store Read4'
         */
        /* :  out = int16(g_assSTART_ENTER_INCAR(LVL + 1 + 6)); */
        g_ausSTART_ENTER_SETTEMP_p(rtB.Merge_b, &Incar_FL);

        /* MATLAB Function: '<S784>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S784>/Data Store Read3'
         */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        tmp_0 = (int32_t)((uint32_t)i + 6U);
        if ((uint32_t)i + 6U > 255U) {
          tmp_0 = 255;
        }

        /* Switch: '<S784>/Switch' incorporates:
         *  Constant: '<S784>/AUTO'
         *  DataStoreRead: '<S3>/Data Store Read2'
         *  DataStoreRead: '<S784>/Data Store Read'
         *  DataStoreRead: '<S784>/Data Store Read1'
         *  DataStoreWrite: '<S3>/Data Store Write2'
         *  Logic: '<S784>/AND'
         *  MATLAB Function: '<S784>/g_assSTART_ENTER_INCAR'
         *  RelationalOperator: '<S784>/Relational Operator'
         *  RelationalOperator: '<S784>/Relational Operator1'
         *  RelationalOperator: '<S784>/Relational Operator2'
         */
        if ((Incar_RR > g_assSTART_ENTER_INCAR[tmp_0 - 1]) &&
            (rtDW.MODE_RR_passenger == 1.0) &&
            (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro < Incar_FL)) {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S784>/Constant1'
           */
          rtB.Merge_d = 0;
        } else {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S784>/Constant'
           */
          rtB.Merge_d = -1;
        }

        /* End of Switch: '<S784>/Switch' */
        /* End of Outputs for SubSystem: '<S779>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S779>/Level 1' incorporates:
         *  ActionPort: '<S785>/Action Port'
         */
        /* MATLAB Function: '<S785>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S785>/Data Store Read3'
         */
        g_assSTART_ENTER_INCAR_l(rtB.Merge_b, &Incar_FL);

        /* MATLAB Function: '<S785>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S785>/Data Store Read4'
         */
        g_ausSTART_ENTER_SETTEMP_p(rtB.Merge_b, &AMB);

        /* Switch: '<S785>/Switch' incorporates:
         *  Constant: '<S785>/AUTO'
         *  DataStoreRead: '<S3>/Data Store Read2'
         *  DataStoreRead: '<S785>/Data Store Read'
         *  DataStoreRead: '<S785>/Data Store Read1'
         *  DataStoreWrite: '<S3>/Data Store Write2'
         *  Logic: '<S785>/AND'
         *  RelationalOperator: '<S785>/Relational Operator'
         *  RelationalOperator: '<S785>/Relational Operator1'
         *  RelationalOperator: '<S785>/Relational Operator2'
         */
        if ((Incar_RR > Incar_FL) && (rtDW.MODE_RR_passenger == 1.0) &&
            (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro < AMB)) {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S785>/Constant1'
           */
          rtB.Merge_d = 0;
        } else {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S785>/Constant'
           */
          rtB.Merge_d = -1;
        }

        /* End of Switch: '<S785>/Switch' */
        /* End of Outputs for SubSystem: '<S779>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S779>/Level 2' incorporates:
         *  ActionPort: '<S786>/Action Port'
         */
        /* MATLAB Function: '<S786>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S786>/Data Store Read3'
         */
        g_assSTART_ENTER_INCAR_l(rtB.Merge_b, &Incar_FL);

        /* MATLAB Function: '<S786>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S786>/Data Store Read4'
         */
        g_ausSTART_ENTER_SETTEMP_p(rtB.Merge_b, &AMB);

        /* Switch: '<S786>/Switch' incorporates:
         *  Constant: '<S786>/AUTO'
         *  DataStoreRead: '<S3>/Data Store Read2'
         *  DataStoreRead: '<S786>/Data Store Read'
         *  DataStoreRead: '<S786>/Data Store Read1'
         *  DataStoreWrite: '<S3>/Data Store Write2'
         *  Logic: '<S786>/AND'
         *  RelationalOperator: '<S786>/Relational Operator'
         *  RelationalOperator: '<S786>/Relational Operator1'
         *  RelationalOperator: '<S786>/Relational Operator2'
         */
        if ((Incar_RR < Incar_FL) && (rtDW.MODE_RR_passenger == 1.0) &&
            (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro > AMB)) {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S786>/Constant1'
           */
          rtB.Merge_d = 0;
        } else {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S786>/Constant'
           */
          rtB.Merge_d = -1;
        }

        /* End of Switch: '<S786>/Switch' */
        /* End of Outputs for SubSystem: '<S779>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S779>/Level 3' incorporates:
         *  ActionPort: '<S787>/Action Port'
         */
        /* MATLAB Function: '<S787>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S787>/Data Store Read4'
         */
        g_assSTART_ENTER_INCAR_l(rtB.Merge_b, &Incar_FL);

        /* MATLAB Function: '<S787>/g_assSTART_ENTER_COOLANT ' incorporates:
         *  DataStoreRead: '<S787>/Data Store Read3'
         */
        g_assSTART_ENTER_COOLANT_i(rtB.Merge_b, &AMB);

        /* MATLAB Function: '<S787>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S787>/Data Store Read6'
         */
        /* :  out = int16(g_ausSTART_ENTER_SETTEMP(LVL+1+6)); */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

        tmp_0 = (int32_t)((uint32_t)i + 6U);
        if ((uint32_t)i + 6U > 255U) {
          tmp_0 = 255;
        }

        Blower_FR = g_ausSTART_ENTER_SETTEMP[tmp_0 - 1];
        if (Blower_FR > 32767) {
          Blower_FR = 32767U;
        }

        /* Switch: '<S787>/Switch' incorporates:
         *  Constant: '<S787>/AUTO'
         *  DataStoreRead: '<S3>/Data Store Read2'
         *  DataStoreRead: '<S787>/Data Store Read'
         *  DataStoreRead: '<S787>/Data Store Read1'
         *  DataStoreRead: '<S787>/Data Store Read2'
         *  DataStoreWrite: '<S3>/Data Store Write2'
         *  Logic: '<S787>/AND'
         *  Logic: '<S787>/AND1'
         *  MATLAB Function: '<S787>/g_ausSTART_ENTER_SETTEMP'
         *  RelationalOperator: '<S787>/Relational Operator'
         *  RelationalOperator: '<S787>/Relational Operator1'
         *  RelationalOperator: '<S787>/Relational Operator2'
         *  RelationalOperator: '<S787>/Relational Operator3'
         */
        if (((Incar_RR < Incar_FL) || (rtDW.ECT < AMB)) &&
            (rtDW.MODE_RR_passenger == 1.0) &&
            (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro > Blower_FR)) {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S787>/Constant1'
           */
          rtB.Merge_d = 0;
        } else {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S787>/Constant'
           */
          rtB.Merge_d = -1;
        }

        /* End of Switch: '<S787>/Switch' */
        /* End of Outputs for SubSystem: '<S779>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S779>/Level 4' incorporates:
         *  ActionPort: '<S788>/Action Port'
         */
        Level4_i(&rtB.Merge_d, &rtDW.ECT, &Incar_RR, &rtB.Merge_b,
                 &rtDW.MODE_RR_passenger);

        /* End of Outputs for SubSystem: '<S779>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S779>/Level 5' incorporates:
         *  ActionPort: '<S789>/Action Port'
         */
        Level4_i(&rtB.Merge_d, &rtDW.ECT, &Incar_RR, &rtB.Merge_b,
                 &rtDW.MODE_RR_passenger);

        /* End of Outputs for SubSystem: '<S779>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S779>/Switch Case' */
      /* End of Outputs for SubSystem: '<S518>/Step -1 F' */
      break;

     case 0:
      /* Outputs for IfAction SubSystem: '<S518>/Step 0 F' incorporates:
       *  ActionPort: '<S780>/Action Port'
       */
      /* SwitchCase: '<S780>/Switch Case' incorporates:
       *  DataStoreRead: '<S780>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S780>/Level 0' incorporates:
         *  ActionPort: '<S803>/Action Port'
         */
        Level0(&rtB.Merge_d);

        /* End of Outputs for SubSystem: '<S780>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S780>/Level 1' incorporates:
         *  ActionPort: '<S804>/Action Port'
         */
        Level0(&rtB.Merge_d);

        /* End of Outputs for SubSystem: '<S780>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S780>/Level 2' incorporates:
         *  ActionPort: '<S805>/Action Port'
         */
        /* DataStoreWrite: '<S805>/Data Store Write5' incorporates:
         *  Constant: '<S805>/Constant2'
         */
        rtDW.Blower_RR = 10U;

        /* DataStoreWrite: '<S805>/Data Store Write10' incorporates:
         *  Constant: '<S805>/Constant4'
         */
        rtDW.Dtg_RR = 65U;

        /* MATLAB Function: '<S805>/incar filter up' incorporates:
         *  DataStoreRead: '<S805>/Data Store Read1'
         */
        incarfilterup_d(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S805>/incar filter down' incorporates:
         *  DataStoreRead: '<S805>/Data Store Read2'
         */
        incarfilterdown_j(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S805>/Data Store Write2' incorporates:
         *  Constant: '<S805>/Mode - foot'
         */
        rtDW.Mode_RR = 60U;

        /* MATLAB Function: '<S805>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
         *  DataStoreRead: '<S805>/Data Store Read3'
         */
        /* :  out = int16(g_assSTART_COOLANT_STEP0_TO_1(LVL + 3)); */
        i = (int32_t)(rtB.Merge_b + 3U);
        if (rtB.Merge_b + 3U > 255U) {
          i = 255;
        }

        /* Merge: '<S518>/Merge' incorporates:
         *  DataStoreRead: '<S805>/Engine coolant temp'
         *  MATLAB Function: '<S805>/g_assSTART_COOLANT_STEP0_TO_1 '
         *  RelationalOperator: '<S805>/Relational Operator'
         *  Switch: '<S805>/Switch'
         */
        rtB.Merge_d = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1[i - 1]);

        /* End of Outputs for SubSystem: '<S780>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S780>/Level 3' incorporates:
         *  ActionPort: '<S806>/Action Port'
         */
        /* DataStoreWrite: '<S806>/Data Store Write5' incorporates:
         *  Constant: '<S806>/Constant2'
         */
        rtDW.Blower_RR = 10U;

        /* DataStoreWrite: '<S806>/Data Store Write10' incorporates:
         *  Constant: '<S806>/Constant4'
         */
        rtDW.Dtg_RR = 65U;

        /* MATLAB Function: '<S806>/incar filter up' incorporates:
         *  DataStoreRead: '<S806>/Data Store Read1'
         */
        incarfilterup_d(rtB.Merge_b, &rtb_Gain_l);

        /* MATLAB Function: '<S806>/incar filter down' incorporates:
         *  DataStoreRead: '<S806>/Data Store Read2'
         */
        incarfilterdown_j(rtB.Merge_b, &rtb_Gain_l);

        /* DataStoreWrite: '<S806>/Data Store Write2' incorporates:
         *  Constant: '<S806>/Mode - foot'
         */
        rtDW.Mode_RR = 60U;

        /* MATLAB Function: '<S806>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
         *  DataStoreRead: '<S806>/Data Store Read3'
         */
        g_assSTART_COOLANT_STEP0_TO_1_g(rtB.Merge_b, &Incar_RR);

        /* Merge: '<S518>/Merge' incorporates:
         *  DataStoreRead: '<S806>/Engine coolant temp'
         *  RelationalOperator: '<S806>/Relational Operator'
         *  Switch: '<S806>/Switch'
         */
        rtB.Merge_d = (int8_t)(rtDW.ECT > Incar_RR);

        /* End of Outputs for SubSystem: '<S780>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S780>/Level 4' incorporates:
         *  ActionPort: '<S807>/Action Port'
         */
        Level4_h(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Gain2, &rtb_Gain_l, &rtB.Merge_b,
                 &El_window_heating, &rtDW.Mode_RR, &Valve_2_way, &rtb_u_pe);

        /* End of Outputs for SubSystem: '<S780>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S780>/Level 5' incorporates:
         *  ActionPort: '<S808>/Action Port'
         */
        Level4_h(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Gain2, &rtb_Gain_l, &rtB.Merge_b,
                 &El_window_heating, &rtDW.Mode_RR, &Valve_2_way, &rtb_u_pe);

        /* End of Outputs for SubSystem: '<S780>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S780>/Switch Case' */
      /* End of Outputs for SubSystem: '<S518>/Step 0 F' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S518>/Step 1 F' incorporates:
       *  ActionPort: '<S781>/Action Port'
       */
      /* SwitchCase: '<S781>/Switch Case' incorporates:
       *  DataStoreRead: '<S781>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S781>/Level 0' incorporates:
         *  ActionPort: '<S821>/Action Port'
         */
        Level0_h(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &Incar_RR, &rtb_Gain2, &rtb_Gain_l, &rtB.Merge_b,
                 &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1, &Valve_2_way,
                 &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level0_he);

        /* End of Outputs for SubSystem: '<S781>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S781>/Level 1' incorporates:
         *  ActionPort: '<S822>/Action Port'
         */
        Level0_h(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &Incar_RR, &rtb_Gain2, &rtb_Gain_l, &rtB.Merge_b,
                 &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1, &Valve_2_way,
                 &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level1_h);

        /* End of Outputs for SubSystem: '<S781>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S781>/Level 2' incorporates:
         *  ActionPort: '<S823>/Action Port'
         */
        /* DataStoreWrite: '<S823>/Data Store Write2' incorporates:
         *  DataStoreRead: '<S823>/Data Store Read1'
         *  DataStoreRead: '<S823>/Data Store Read2'
         *  DataStoreRead: '<S823>/Data Store Read5'
         *  DataStoreRead: '<S823>/Data Store Read6'
         *  MATLAB Function: '<S823>/2 way valve'
         *  MATLAB Function: '<S823>/incar filter down'
         *  MATLAB Function: '<S823>/incar filter up'
         *  MATLAB Function: '<S823>/mode rear step 1'
         */
        uwayvalve(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterup_d(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterdown_j(rtB.Merge_b, &rtDW.Mode_RR);
        moderearstep1(rtB.Merge_b, &rtDW.Mode_RR);

        /* MATLAB Function: '<S850>/blower start finish' incorporates:
         *  DataStoreRead: '<S823>/Data Store Read7'
         */
        blowerstartfinish(rtB.Merge_b, rtb_out_fw);

        /* MATLAB Function: '<S850>/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_nh[0] = g_assSTART_COOLANT_STEP0_TO_1[4];
        rtb_out_nh[1] = g_assSTART_COOLANT_TO_STEP2[1];

        /* Lookup_n-D: '<S850>/blower для текущего ECT' incorporates:
         *  DataStoreRead: '<S850>/engine coolant temp'
         *  DataStoreWrite: '<S823>/Data Store Write5'
         */
        rtDW.Blower_RR = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_nh,
          rtb_out_fw, 1U);

        /* DataStoreWrite: '<S823>/Data Store Write10' incorporates:
         *  DataStoreRead: '<S823>/Data Store Read8'
         *  MATLAB Function: '<S823>/Dtg_rear'
         */
        Dtg_rear(rtB.Merge_b, &rtDW.Dtg_RR);

        /* RelationalOperator: '<S823>/Equal' incorporates:
         *  DataStoreRead: '<S823>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 1);

        /* MATLAB Function: '<S823>/Incar temp goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S823>/Data Store Read3'
         */
        Incartempgotofromstep1tostep2_b(rtB.Merge_b, &Incar_FL);

        /* Sum: '<S848>/Subtract' incorporates:
         *  DataStoreRead: '<S848>/Data Store Read4'
         *  UnitDelay: '<S848>/t_start_delay_private '
         */
        rtb_dt_du = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_l;

        /* MATLAB Function: '<S823>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S823>/Data Store Read4'
         */
        Timegotofromstep1tostep2_h(rtB.Merge_b, &AMB);

        /* Switch: '<S848>/Switch' incorporates:
         *  DataStoreRead: '<S848>/Data Store Read4'
         *  Logic: '<S848>/Logical Operator3'
         *  Logic: '<S848>/Logical Operator4'
         *  UnitDelay: '<S848>/Cond_prev_private '
         *  UnitDelay: '<S848>/t_start_delay_private '
         */
        /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(2)); */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_hp)) {
          rtDW.t_start_delay_private_DSTATE_l = rtDW.t_now;
        }

        /* End of Switch: '<S848>/Switch' */

        /* Switch: '<S823>/Switch' incorporates:
         *  DataStoreRead: '<S823>/engine coolant temp'
         *  DataStoreRead: '<S823>/incar temp'
         *  Gain: '<S823>/из сек в мс'
         *  Logic: '<S823>/Logical Operator'
         *  MATLAB Function: '<S823>/g_assSTART_COOLANT_TO_STEP2 '
         *  RelationalOperator: '<S823>/Relational Operator'
         *  RelationalOperator: '<S823>/Relational Operator1'
         *  RelationalOperator: '<S823>/Relational Operator2'
         */
        if ((Incar_RR > Incar_FL) || (rtb_dt_du > (uint16_t)(1000 * AMB)) ||
            (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[1])) {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S823>/go to next step'
           */
          rtB.Merge_d = 2;
        } else {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S823>/stay at step 1'
           */
          rtB.Merge_d = 1;
        }

        /* End of Switch: '<S823>/Switch' */

        /* Update for UnitDelay: '<S848>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_hp = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S781>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S781>/Level 3' incorporates:
         *  ActionPort: '<S824>/Action Port'
         */
        /* DataStoreWrite: '<S824>/Data Store Write2' incorporates:
         *  DataStoreRead: '<S824>/Data Store Read1'
         *  DataStoreRead: '<S824>/Data Store Read2'
         *  DataStoreRead: '<S824>/Data Store Read5'
         *  DataStoreRead: '<S824>/Data Store Read6'
         *  MATLAB Function: '<S824>/2 way valve'
         *  MATLAB Function: '<S824>/incar filter down'
         *  MATLAB Function: '<S824>/incar filter up'
         *  MATLAB Function: '<S824>/mode rear step 1'
         */
        uwayvalve(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterup_d(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterdown_j(rtB.Merge_b, &rtDW.Mode_RR);
        moderearstep1(rtB.Merge_b, &rtDW.Mode_RR);

        /* MATLAB Function: '<S862>/blower start finish' incorporates:
         *  DataStoreRead: '<S824>/Data Store Read7'
         */
        blowerstartfinish(rtB.Merge_b, rtb_out_fw);

        /* MATLAB Function: '<S862>/ECT min max' incorporates:
         *  DataStoreRead: '<S824>/Data Store Read7'
         */
        ECTminmax_h(rtB.Merge_b, rtb_out_nh);

        /* Lookup_n-D: '<S862>/blower для текущего ECT' incorporates:
         *  DataStoreRead: '<S862>/engine coolant temp'
         *  DataStoreWrite: '<S824>/Data Store Write5'
         */
        rtDW.Blower_RR = look1_iu16bs16lu64n32_binlcse(rtDW.ECT, rtb_out_nh,
          rtb_out_fw, 1U);

        /* DataStoreWrite: '<S824>/Data Store Write10' incorporates:
         *  DataStoreRead: '<S824>/Data Store Read8'
         *  MATLAB Function: '<S824>/Dtg_rear'
         */
        Dtg_rear(rtB.Merge_b, &rtDW.Dtg_RR);

        /* RelationalOperator: '<S824>/Equal' incorporates:
         *  DataStoreRead: '<S824>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 1);

        /* MATLAB Function: '<S824>/Incar temp goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S824>/Data Store Read3'
         */
        Incartempgotofromstep1tostep2_b(rtB.Merge_b, &Incar_FL);

        /* Sum: '<S860>/Subtract' incorporates:
         *  DataStoreRead: '<S860>/Data Store Read4'
         *  UnitDelay: '<S860>/t_start_delay_private '
         */
        rtb_dt_du = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_m;

        /* MATLAB Function: '<S824>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S824>/Data Store Read4'
         */
        Timegotofromstep1tostep2_h(rtB.Merge_b, &AMB);

        /* Switch: '<S860>/Switch' incorporates:
         *  DataStoreRead: '<S860>/Data Store Read4'
         *  Logic: '<S860>/Logical Operator3'
         *  Logic: '<S860>/Logical Operator4'
         *  UnitDelay: '<S860>/Cond_prev_private '
         *  UnitDelay: '<S860>/t_start_delay_private '
         */
        /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(3)); */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_im)) {
          rtDW.t_start_delay_private_DSTATE_m = rtDW.t_now;
        }

        /* End of Switch: '<S860>/Switch' */

        /* Switch: '<S824>/Switch' incorporates:
         *  DataStoreRead: '<S824>/engine coolant temp'
         *  DataStoreRead: '<S824>/incar temp'
         *  Gain: '<S824>/из сек в мс'
         *  Logic: '<S824>/Logical Operator'
         *  MATLAB Function: '<S824>/g_assSTART_COOLANT_TO_STEP2 '
         *  RelationalOperator: '<S824>/Relational Operator'
         *  RelationalOperator: '<S824>/Relational Operator1'
         *  RelationalOperator: '<S824>/Relational Operator2'
         */
        if ((Incar_RR > Incar_FL) || (rtb_dt_du > (uint16_t)(1000 * AMB)) ||
            (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[2])) {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S824>/go to next step'
           */
          rtB.Merge_d = 2;
        } else {
          /* Merge: '<S518>/Merge' incorporates:
           *  Constant: '<S824>/stay at step 1'
           */
          rtB.Merge_d = 1;
        }

        /* End of Switch: '<S824>/Switch' */

        /* Update for UnitDelay: '<S860>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_im = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S781>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S781>/Level 4' incorporates:
         *  ActionPort: '<S825>/Action Port'
         */
        Level4_d(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &Incar_RR, &rtb_Gain2, &rtb_Gain_l,
                 &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1,
                 &Valve_2_way, &rtDW.step_start_controle_rear, &rtDW.t_now,
                 &rtDW.Level4_di);

        /* End of Outputs for SubSystem: '<S781>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S781>/Level 5' incorporates:
         *  ActionPort: '<S826>/Action Port'
         */
        Level4_d(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &Incar_RR, &rtb_Gain2, &rtb_Gain_l,
                 &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Divide1,
                 &Valve_2_way, &rtDW.step_start_controle_rear, &rtDW.t_now,
                 &rtDW.Level5_p);

        /* End of Outputs for SubSystem: '<S781>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S781>/Switch Case' */
      /* End of Outputs for SubSystem: '<S518>/Step 1 F' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S518>/Step 2 F' incorporates:
       *  ActionPort: '<S782>/Action Port'
       */
      /* SwitchCase: '<S782>/Switch Case' incorporates:
       *  DataStoreRead: '<S782>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S782>/Level 0' incorporates:
         *  ActionPort: '<S891>/Action Port'
         */
        Level0_j(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR,
                 &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
                 &rtDW.Dtg_logic_RR, &rtb_Gain2, &rtb_Gain_l, &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.Level0_jq);

        /* End of Outputs for SubSystem: '<S782>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S782>/Level 1' incorporates:
         *  ActionPort: '<S892>/Action Port'
         */
        Level0_j(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR,
                 &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
                 &rtDW.Dtg_logic_RR, &rtb_Gain2, &rtb_Gain_l, &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.Level1_ha);

        /* End of Outputs for SubSystem: '<S782>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S782>/Level 2' incorporates:
         *  ActionPort: '<S893>/Action Port'
         */
        Level2(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &rtDW.Blower_logic_RR,
               &Dtg_FUR, &rtDW.Dtg_RR, &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on,
               &rtb_Gain2, &rtb_Gain_l, &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.Level2_al);

        /* End of Outputs for SubSystem: '<S782>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S782>/Level 3' incorporates:
         *  ActionPort: '<S894>/Action Port'
         */
        Level2(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &rtDW.Blower_logic_RR,
               &Dtg_FUR, &rtDW.Dtg_RR, &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on,
               &rtb_Gain2, &rtb_Gain_l, &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_n);

        /* End of Outputs for SubSystem: '<S782>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S782>/Level 4' incorporates:
         *  ActionPort: '<S895>/Action Port'
         */
        Level2(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &rtDW.Blower_logic_RR,
               &Dtg_FUR, &rtDW.Dtg_RR, &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on,
               &rtb_Gain2, &rtb_Gain_l, &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_c);

        /* End of Outputs for SubSystem: '<S782>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S782>/Level 5' incorporates:
         *  ActionPort: '<S896>/Action Port'
         */
        Level2(&rtB.Merge_d, &Blower_FR, &rtDW.Blower_RR, &rtDW.Blower_logic_RR,
               &Dtg_FUR, &rtDW.Dtg_RR, &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on,
               &rtb_Gain2, &rtb_Gain_l, &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: '<S782>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S782>/Switch Case' */
      /* End of Outputs for SubSystem: '<S518>/Step 2 F' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S518>/Step 3' incorporates:
       *  ActionPort: '<S783>/Action Port'
       */
      Step3(&rtB.Merge_d, &rtDW.start_control_finished_front);

      /* End of Outputs for SubSystem: '<S518>/Step 3' */
      break;
    }

    /* End of SwitchCase: '<S518>/Switch Case' */

    /* DataStoreWrite: '<S518>/Data Store Write' */
    rtDW.step_start_controle_rear = rtB.Merge_d;

    /* End of Outputs for SubSystem: '<S6>/Start Control Rear' */
  }

  /* End of If: '<S6>/если SC rear не завершен1' */

  /* Test Sequence: '<Root>/Test Sequence' */
  if (rtDW.temporalCounter_i1 < 7U) {
    rtDW.temporalCounter_i1++;
  }

  if (rtDW.is_active_c371_HVAC_model == 0U) {
    rtDW.is_active_c371_HVAC_model = 1U;
    rtDW.temporalCounter_i1 = 0U;
    rtDW.is_c371_HVAC_model = IN_step_1;

    /* :  ADC_Data_Model.Sensor_Ambient_Temp= uint16(300); */
    rtDW.ADC_Data_Model.Sensor_Ambient_Temp = 300U;

    /* :  FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro = uint8(13); */
    rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro = 13U;

    /* :  ADC_Data_Model.IGN_ANS = uint16(300); */
    rtDW.ADC_Data_Model.IGN_ANS = 300U;

    /* :  t_now = uint32(0); */
    rtDW.t_now = 0U;
  } else {
    switch (rtDW.is_c371_HVAC_model) {
     case IN_step_1:
      /* :  sf_internal_predicateOutput = after(2, sec); */
      if (rtDW.temporalCounter_i1 >= 2U) {
        rtDW.temporalCounter_i1 = 0U;
        rtDW.is_c371_HVAC_model = IN_step_2;

        /* :  ADC_Data_Model.Sensor_Ambient_Temp = uint16(800); */
        rtDW.ADC_Data_Model.Sensor_Ambient_Temp = 800U;

        /* :  t_now = uint32(2000); */
        rtDW.t_now = 2000U;
      } else {
        /* :  ADC_Data_Model.Sensor_Ambient_Temp= uint16(300); */
        rtDW.ADC_Data_Model.Sensor_Ambient_Temp = 300U;

        /* :  FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro = uint8(13); */
        rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro = 13U;

        /* :  ADC_Data_Model.IGN_ANS = uint16(300); */
        rtDW.ADC_Data_Model.IGN_ANS = 300U;

        /* :  t_now = uint32(0); */
        rtDW.t_now = 0U;
      }
      break;

     case IN_step_2:
      /* :  sf_internal_predicateOutput = after(5, sec); */
      if (rtDW.temporalCounter_i1 >= 5U) {
        rtDW.is_c371_HVAC_model = IN_step_3;

        /* :  ADC_Data_Model.IGN_ANS = uint16(0); */
        rtDW.ADC_Data_Model.IGN_ANS = 0U;
      } else {
        /* :  ADC_Data_Model.Sensor_Ambient_Temp = uint16(800); */
        rtDW.ADC_Data_Model.Sensor_Ambient_Temp = 800U;

        /* :  t_now = uint32(2000); */
        rtDW.t_now = 2000U;
      }
      break;

     default:
      /* case IN_step_3: */
      /* :  ADC_Data_Model.IGN_ANS = uint16(0); */
      rtDW.ADC_Data_Model.IGN_ANS = 0U;
      break;
    }
  }

  /* End of Test Sequence: '<Root>/Test Sequence' */

  /* Update for UnitDelay: '<S296>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE = rtb_FailCond;

  /* Update for UnitDelay: '<S303>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_h = rtb_FailCond_f;

  /* Update for UnitDelay: '<S310>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_i = rtb_FailCond_g;

  /* Update for UnitDelay: '<S332>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_e = rtb_FailCond_mg;

  /* Update for UnitDelay: '<S358>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_c = rtb_FailCond_e;

  /* Update for UnitDelay: '<S359>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_b = rtb_FailCond_a;

  /* Update for UnitDelay: '<S372>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_j = rtb_FailCond_l;

  /* Update for UnitDelay: '<S373>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_f = rtb_FailCond_b;
}

/* Model initialize function */
void HVAC_model_initialize(void)
{
  {
    int32_t i;

    /* Start for DataStoreMemory: '<S381>/Data Store Memory1' */
    for (i = 0; i < 9; i++) {
      rtDW.ErrorCalibration_private[i] = 1U;
    }

    /* End of Start for DataStoreMemory: '<S381>/Data Store Memory1' */

    /* Start for DataStoreMemory: '<S6>/Data Store Memory' */
    rtDW.step_start_controle_front = -1;

    /* Start for DataStoreMemory: '<S6>/Data Store Memory1' */
    rtDW.step_start_controle_rear = -1;

    /* Start for DataStoreMemory: '<Root>/Data Store Memory42' */
    rtDW.ADC_Data_Model = rtConstP.DataStoreMemory42_InitialValue;

    /* Start for DataStoreMemory: '<Root>/Data Store Memory5' */
    rtDW.t_now = 10U;

    /* SystemInitialize for IfAction SubSystem: '<S381>/Homing' */
    /* SystemInitialize for IfAction SubSystem: '<S388>/Switch Case Action Subsystem3' */
    /* SystemInitialize for IfAction SubSystem: '<S408>/If Action Subsystem' */
    /* SystemInitialize for IfAction SubSystem: '<S419>/If Action Subsystem' */
    /* SystemInitialize for SignalConversion generated from: '<S421>/Out1' */
    rtB.OutportBufferForOut1 = 2;

    /* End of SystemInitialize for SubSystem: '<S419>/If Action Subsystem' */
    /* End of SystemInitialize for SubSystem: '<S408>/If Action Subsystem' */
    /* End of SystemInitialize for SubSystem: '<S388>/Switch Case Action Subsystem3' */
    /* End of SystemInitialize for SubSystem: '<S381>/Homing' */
  }
}

/* Model terminate function */
void HVAC_model_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */