/*
 * File: HVAC_model.c
 *
 * Code generated for Simulink model 'HVAC_model'.
 *
 * Model version                  : 1.923
 * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
 * C/C++ source code generated on : Wed May 13 17:12:51 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 <string.h>
#include "HVAC_model_types.h"
#include "Rs_Cal_Base.h"

const CmdBusPWMGet HVAC_model_rtZCmdBusPWMGet = {
  0U,                                  /* pwmPercentFront */
  0U,                                  /* pwmPercentRear */
  0U,                                  /* pwmPercentFrontReserved */
  0U                                   /* pwmPercentRearReserved */
};                                     /* CmdBusPWMGet ground */

const CmdBusError HVAC_model_rtZCmdBusError = {
  0U,                                  /* CCU_IncarTempErrF_Stat */
  0U,                                  /* CCU_IncarTempErrR_Stat */
  0U,                                  /* CCU_DuctTempSenErrF_Stat */
  0U,                                  /* CCU_DuctTempSenErrR_Stat */
  0U,                                  /* CCU_EvaTempSenErrF_Stat */
  0U,                                  /* CCU_EvaTempSenErrR_Stat */
  0U,                                  /* CCU_DeflectorSwErrF_Stat */
  0U,                                  /* CCU_DeflectorSwErrR_Stat */
  0U,                                  /* CCU_PressSenErr_Stat */
  0U,                                  /* CCU_AmbienTemptSenErr_Stat */
  0U,                                  /* CCU_SealingValveErr_Stat */
  0U,                                  /* CCU_ETXVerr_Stat */
  0U,                                  /* CCU_HVACfanOrTXVerrF_Stat */
  0U,                                  /* CCU_HVACfanOrTXVerrR_Stat */
  0U,                                  /* CCU_ActuatorErrF_Stat */
  0U,                                  /* CCU_ActuatorErrR_Stat */
  0U,                                  /* CCU_UltravioletErr_Stat */
  0U,                                  /* CCU_VinRecordErr_Stat */
  0U,                                  /* CCU_AirQualSenErr_Stat */
  0U,                                  /* CCU_CommErr_Stat */
  0U,                                  /* CCU_TWVerr_Stat */
  0U,                                  /* CCU_IonizationErr_Stat */
  0U                                   /* CCU_AromaErr_Stat */
};                                     /* CmdBusError ground */

const ActuatorCmdBusInput HVAC_model_rtZActuatorCmdBusInput = {
  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_CPOS_ALL */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Emrf_Slave */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Mode_Slave */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Err1_Supply */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Err2_Communication */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Err3_Temperature */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Err4_Permanent_Electrical */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Stall_Slave */

  {
    0, 0, 0, 0, 0, 0, 0, 0, 0 }
  ,                                    /* in_Act_Reset */
  0U,                                  /* Busy */
  0U                                   /* Error_Connect */
};                                     /* ActuatorCmdBusInput ground */

const CmdBusStatus HVAC_model_rtZCmdBusStatus = {
  0,                                   /* Battery */
  0,                                   /* AMB */
  0,                                   /* Incar_FL */
  0,                                   /* Incar_FR */
  0,                                   /* Incar_RL */
  0,                                   /* Incar_RR */
  0,                                   /* Eva_F */
  0,                                   /* Eva_R */
  0,                                   /* Pressure */
  0,                                   /* Duct_FL_Upper */
  0,                                   /* Duct_FL_Lower */
  0,                                   /* Duct_FR_Upper */
  0,                                   /* Duct_FR_Lower */
  0,                                   /* Duct_RL */
  0,                                   /* Duct_RR */
  0,                                   /* Duct_Side_FL */
  0,                                   /* Duct_Side_FR */
  0,                                   /* Duct_Side_RL */
  0,                                   /* Duct_Side_RR */
  0                                    /* AQS */
};                                     /* CmdBusStatus ground */

const ActuatorCmdBus HVAC_model_rtZActuatorCmdBus = {
  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* POS */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* BUS_ADR */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* MODE */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* COM */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* Stall_SET */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* Lnoise_SET */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* Autos_SET */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  ,                                    /* Speed_SET */

  {
    0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U }
  /* Coils_Stop_SET */
};                                     /* ActuatorCmdBus ground */

/* Exported block states */
ActuatorCmdBusInput Actuator_Ch0_Status_Model;/* '<Root>/Data Store Memory61' */
ActuatorCmdBusInput Actuator_Ch1_Status_Model;/* '<Root>/Data Store Memory62' */
ActuatorCmdBusInput Actuator_Ch2_Status_Model;/* '<Root>/Data Store Memory63' */
ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S597>/Data Store Memory15' */
ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S598>/Data Store Memory15' */
ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S599>/Data Store Memory15' */
CmdBusStatus Status_Sensor_Model;      /* '<S3>/Data Store Memory' */
CmdBusError CCU_Errors_Model;          /* '<Root>/Data Store Memory3' */
CmdBusPWMGet PWM_Get;                  /* '<Root>/Data Store Memory128' */

/* 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_;
int16_t look1_is16lu64n32tu16Ds32Is16_binlcs(int16_t u0, const int16_t bp0[],
  const uint16_t table[], uint32_t maxIndex)
{
  uint64_t frac;
  uint32_t iLeft;
  uint16_t yL_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'
   */
  if (u0 <= bp0[0U]) {
    iLeft = 0U;
    frac = 0ULL;
  } 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;
    }

    int16_t bpLeftVar;
    bpLeftVar = bp0[iLeft];
    frac = ((uint64_t)(uint32_t)(u0 - bpLeftVar) << 32) / (uint32_t)(bp0[iLeft +
      1U] - bpLeftVar);
  } 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'
   */
  yL_0d0 = table[iLeft];
  return (int16_t)((int16_t)(((table[iLeft + 1U] - yL_0d0) * (int64_t)frac) >>
    32) + (int16_t)yL_0d0);
}

uint32_t binsearch_u32s16(int16_t u_2, 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_2 < 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;
}

double look1_is16td_binlc(int16_t u0, const int16_t bp0[], const double table[],
  uint32_t maxIndex)
{
  double frac;
  double yL_0d0;
  uint32_t iLeft;

  /* 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;
    }

    int16_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: 'wrapping'
   */
  yL_0d0 = table[iLeft];
  return (table[iLeft + 1U] - yL_0d0) * frac + yL_0d0;
}

int16_t look1_iu16bs16lu64n32ts16Ds32_binlcs(uint16_t u0, const int16_t bp0[],
  const int16_t table[], uint32_t maxIndex)
{
  uint64_t frac;
  uint32_t iLeft;
  int16_t yL_0d0;
  uint16_t tmp;

  /* 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'
   */
  tmp = u0;
  if (u0 > 32767) {
    tmp = 32767U;
  }

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

    /* Binary Search */
    bpIdx = maxIndex >> 1U;
    iLeft = 0U;
    iRght = maxIndex;
    while (iRght - iLeft > 1U) {
      if ((int16_t)tmp < 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'
   */
  yL_0d0 = table[iLeft];
  return (int16_t)((int16_t)(((table[iLeft + 1U] - yL_0d0) * (int64_t)frac) >>
    32) + yL_0d0);
}

uint32_t plook_u32s16_bincka(int16_t u_3, 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_3 <= bp[0U]) {
    bpIndex = 0U;
  } else if (u_3 < bp[maxIndex]) {
    bpIndex = binsearch_u32s16(u_3, bp, maxIndex >> 1U, maxIndex);
  } else {
    bpIndex = maxIndex;
  }

  return bpIndex;
}

/*
 * Output and update for atomic system:
 *    '<S56>/обычное понижение темп.'
 *    '<S62>/обычное повышение темп.'
 *    '<S28>/обычное понижение темп.'
 *    '<S34>/обычное повышение темп.'
 *    '<S88>/обычное понижение темп.'
 *    '<S94>/обычное повышение темп.'
 */
void u(int16_t rtu_lvl, uint8_t *rty_f_g_aucAMBRATE_FALLING)
{
  int32_t tmp;

  /* :  f_g_aucAMBRATE_FALLING = g_aucAMBRATE_FALLING(lvl + 1); */
  tmp = rtu_lvl + 1;
  if (rtu_lvl + 1 > 32767) {
    tmp = 32767;
  }

  *rty_f_g_aucAMBRATE_FALLING = g_aucAMBRATE_FALLING[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S51>/включен ускоренный режим'
 *    '<S23>/включен ускоренный режим'
 *    '<S83>/включен ускоренный режим'
 */
void u_d(int16_t rtu_amb_raw, int16_t rtu_lvl, uint8_t *rty_out, const double
         *rtd_AMB_store, double *rtd_KEEP_FALLING_UNTIL_LIMIT)
{
  int32_t tmp;

  /* If: '<S53>/If' incorporates:
   *  Abs: '<S53>/ABS(AMBraw - AMB)'
   *  DataStoreRead: '<S53>/Read Amb'
   *  MATLAB Function: '<S53>/AMBRATE_RISING_DIFF[8]'
   *  RelationalOperator: '<S53>/Relational Operator'
   *  Sum: '<S53>/Add'
   */
  /* :  f_g_aucAMBRATE_FALLING_DIFF = g_aucAMBRATE_FALLING_DIFF(8); */
  if (fabs((double)rtu_amb_raw - *rtd_AMB_store) <= g_aucAMBRATE_FALLING_DIFF[7])
  {
    /* Outputs for IfAction SubSystem: '<S53>/Отключаем ускоренный режим' incorporates:
     *  ActionPort: '<S56>/Action Port'
     */
    /* DataStoreWrite: '<S56>/Data Store Write' incorporates:
     *  Constant: '<S56>/Constant'
     */
    *rtd_KEEP_FALLING_UNTIL_LIMIT = 0.0;

    /* SignalConversion generated from: '<S53>/out' incorporates:
     *  MATLAB Function: '<S56>/обычное понижение темп.'
     *  Merge: '<S53>/Merge'
     */
    u(rtu_lvl, rty_out);

    /* End of Outputs for SubSystem: '<S53>/Отключаем ускоренный режим' */
  } else {
    /* Outputs for IfAction SubSystem: '<S53>/Продолжаем в ускоренном' incorporates:
     *  ActionPort: '<S57>/Action Port'
     */
    /* MATLAB Function: '<S57>/ускоренное повышение темп.' */
    /* :  f_g_aucAMBRATE_FALLING_DIFF = g_aucAMBRATE_FALLING_DIFF(lvl + 1); */
    tmp = rtu_lvl + 1;
    if (rtu_lvl + 1 > 32767) {
      tmp = 32767;
    }

    /* SignalConversion generated from: '<S53>/out' incorporates:
     *  MATLAB Function: '<S57>/ускоренное повышение темп.'
     *  Merge: '<S53>/Merge'
     */
    *rty_out = g_aucAMBRATE_FALLING_DIFF[tmp - 1];

    /* End of Outputs for SubSystem: '<S53>/Продолжаем в ускоренном' */
  }

  /* End of If: '<S53>/If' */
}

/*
 * Output and update for action system:
 *    '<S51>/обычный режим'
 *    '<S23>/обычный режим'
 *    '<S83>/обычный режим'
 */
void u_c(int16_t rtu_amb_raw, int16_t rtu_lvl, uint8_t *rty_riseperminute, const
         double *rtd_AMB_store, double *rtd_KEEP_FALLING_UNTIL_LIMIT)
{
  int32_t tmp;

  /* If: '<S54>/If' incorporates:
   *  Abs: '<S54>/ABS(AMBraw - AMB)'
   *  DataStoreRead: '<S54>/Read Amb'
   *  MATLAB Function: '<S54>/AMBRATE_FALLING_DIFF[7]'
   *  RelationalOperator: '<S54>/Relational Operator'
   *  Sum: '<S54>/Add'
   */
  /* :  f_g_aucAMBRATE_FALLING_DIFF = g_aucAMBRATE_FALLING_DIFF(7); */
  if (fabs((double)rtu_amb_raw - *rtd_AMB_store) > g_aucAMBRATE_FALLING_DIFF[6])
  {
    /* Outputs for IfAction SubSystem: '<S54>/включаем ускоренный режим' incorporates:
     *  ActionPort: '<S61>/Action Port'
     */
    /* DataStoreWrite: '<S61>/Data Store Write' incorporates:
     *  Constant: '<S61>/Constant'
     */
    *rtd_KEEP_FALLING_UNTIL_LIMIT = 1.0;

    /* MATLAB Function: '<S61>/ускоренное повышение темп.' */
    /* :  f_g_aucAMBRATE_FALLING_DIFF_LVL = g_aucAMBRATE_FALLING_DIFF(lvl + 1); */
    tmp = rtu_lvl + 1;
    if (rtu_lvl + 1 > 32767) {
      tmp = 32767;
    }

    /* SignalConversion generated from: '<S54>/rise per minute' incorporates:
     *  MATLAB Function: '<S61>/ускоренное повышение темп.'
     *  Merge: '<S54>/Merge'
     */
    *rty_riseperminute = g_aucAMBRATE_FALLING_DIFF[tmp - 1];

    /* End of Outputs for SubSystem: '<S54>/включаем ускоренный режим' */
  } else {
    /* Outputs for IfAction SubSystem: '<S54>/обычный режим повышения' incorporates:
     *  ActionPort: '<S62>/Action Port'
     */
    /* SignalConversion generated from: '<S54>/rise per minute' incorporates:
     *  MATLAB Function: '<S62>/обычное повышение темп.'
     *  Merge: '<S54>/Merge'
     */
    u(rtu_lvl, rty_riseperminute);

    /* End of Outputs for SubSystem: '<S54>/обычный режим повышения' */
  }

  /* End of If: '<S54>/If' */
}

/*
 * Output and update for atomic system:
 *    '<S68>/обычное повышение темп.'
 *    '<S74>/обычное повышение темп.'
 *    '<S40>/обычное повышение темп.'
 *    '<S46>/обычное повышение темп.'
 *    '<S100>/обычное повышение темп.'
 *    '<S106>/обычное повышение темп.'
 */
void u_b(int16_t rtu_lvl, uint8_t *rty_f_g_aucAMBRATE_RISING)
{
  int32_t tmp;

  /* :  f_g_aucAMBRATE_RISING = g_aucAMBRATE_RISING(lvl + 1); */
  tmp = rtu_lvl + 1;
  if (rtu_lvl + 1 > 32767) {
    tmp = 32767;
  }

  *rty_f_g_aucAMBRATE_RISING = g_aucAMBRATE_RISING[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S69>/ускоренное повышение темп.'
 *    '<S73>/ускоренное повышение темп.'
 *    '<S41>/ускоренное повышение темп.'
 *    '<S45>/ускоренное повышение темп.'
 *    '<S101>/ускоренное повышение темп.'
 *    '<S105>/ускоренное повышение темп.'
 */
void u_g(int16_t rtu_lvl, uint8_t *rty_f_g_aucAMBRATE_RISING_DIFF_LVL)
{
  int32_t tmp;

  /* :  f_g_aucAMBRATE_RISING_DIFF_LVL = g_aucAMBRATE_RISING_DIFF(lvl + 1); */
  tmp = rtu_lvl + 1;
  if (rtu_lvl + 1 > 32767) {
    tmp = 32767;
  }

  *rty_f_g_aucAMBRATE_RISING_DIFF_LVL = g_aucAMBRATE_RISING_DIFF[tmp - 1];
}

/*
 * Output and update for action system:
 *    '<S52>/включен ускоренный режим'
 *    '<S24>/включен ускоренный режим'
 *    '<S84>/включен ускоренный режим'
 */
void u_h(int16_t rtu_amb_raw, int16_t rtu_lvl, uint8_t *rty_out, const double
         *rtd_AMB_store, double *rtd_KEEP_RISING_UNTIL_LIMIT)
{
  /* If: '<S65>/If' incorporates:
   *  Abs: '<S65>/ABS(AMBraw - AMB)'
   *  DataStoreRead: '<S65>/Read Amb'
   *  MATLAB Function: '<S65>/AMBRATE_RISING_DIFF[8]'
   *  RelationalOperator: '<S65>/Relational Operator'
   *  Sum: '<S65>/Add'
   */
  /* :  f_g_aucAMBRATE_RISING_DIFF = g_aucAMBRATE_RISING_DIFF(8); */
  if (fabs((double)rtu_amb_raw - *rtd_AMB_store) <= g_aucAMBRATE_RISING_DIFF[7])
  {
    /* Outputs for IfAction SubSystem: '<S65>/Отключаем ускоренный режим' incorporates:
     *  ActionPort: '<S68>/Action Port'
     */
    /* DataStoreWrite: '<S68>/Data Store Write' incorporates:
     *  Constant: '<S68>/Constant'
     */
    *rtd_KEEP_RISING_UNTIL_LIMIT = 0.0;

    /* SignalConversion generated from: '<S68>/out' incorporates:
     *  MATLAB Function: '<S68>/обычное повышение темп.'
     */
    u_b(rtu_lvl, rty_out);

    /* End of Outputs for SubSystem: '<S65>/Отключаем ускоренный режим' */
  } else {
    /* Outputs for IfAction SubSystem: '<S65>/Продолжаем в ускоренном' incorporates:
     *  ActionPort: '<S69>/Action Port'
     */
    /* SignalConversion generated from: '<S69>/out' incorporates:
     *  MATLAB Function: '<S69>/ускоренное повышение темп.'
     */
    u_g(rtu_lvl, rty_out);

    /* End of Outputs for SubSystem: '<S65>/Продолжаем в ускоренном' */
  }

  /* End of If: '<S65>/If' */
}

/*
 * Output and update for action system:
 *    '<S52>/обычный режим'
 *    '<S24>/обычный режим'
 *    '<S84>/обычный режим'
 */
void u_a(int16_t rtu_amb_raw, int16_t rtu_lvl, uint8_t *rty_riseperminute, const
         double *rtd_AMB_store, double *rtd_KEEP_RISING_UNTIL_LIMIT)
{
  /* If: '<S66>/If' incorporates:
   *  Abs: '<S66>/ABS(AMBraw - AMB)'
   *  DataStoreRead: '<S66>/Read Amb'
   *  MATLAB Function: '<S66>/AMBRATE_RISING_DIFF[7]'
   *  RelationalOperator: '<S66>/Relational Operator'
   *  Sum: '<S66>/Add'
   */
  /* :  f_g_aucAMBRATE_RISING_DIFF = g_aucAMBRATE_RISING_DIFF(7); */
  if (fabs((double)rtu_amb_raw - *rtd_AMB_store) > g_aucAMBRATE_RISING_DIFF[6])
  {
    /* Outputs for IfAction SubSystem: '<S66>/включаем ускоренный режим' incorporates:
     *  ActionPort: '<S73>/Action Port'
     */
    /* DataStoreWrite: '<S73>/Data Store Write' incorporates:
     *  Constant: '<S73>/Constant'
     */
    *rtd_KEEP_RISING_UNTIL_LIMIT = 1.0;

    /* SignalConversion generated from: '<S73>/out' incorporates:
     *  MATLAB Function: '<S73>/ускоренное повышение темп.'
     */
    u_g(rtu_lvl, rty_riseperminute);

    /* End of Outputs for SubSystem: '<S66>/включаем ускоренный режим' */
  } else {
    /* Outputs for IfAction SubSystem: '<S66>/обычный режим повышения' incorporates:
     *  ActionPort: '<S74>/Action Port'
     */
    /* SignalConversion generated from: '<S74>/out' incorporates:
     *  MATLAB Function: '<S74>/обычное повышение темп.'
     */
    u_b(rtu_lvl, rty_riseperminute);

    /* End of Outputs for SubSystem: '<S66>/обычный режим повышения' */
  }

  /* End of If: '<S66>/If' */
}

/*
 * Output and update for atomic system:
 *    '<S192>/get_tg_FLL_for_LVL'
 *    '<S220>/get_tg_FLL_for_LVL'
 *    '<S168>/get_tg_for_LVL'
 *    '<S301>/get_tg_FLL_for_LVL'
 *    '<S329>/get_tg_FLL_for_LVL'
 *    '<S277>/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:
 *    '<S199>/get_tg_FLL_for_LVL'
 *    '<S227>/get_tg_FLL_for_LVL'
 *    '<S174>/get_tg_FLL_for_LVL'
 *    '<S308>/get_tg_FLL_for_LVL'
 *    '<S336>/get_tg_FLL_for_LVL'
 *    '<S283>/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:
 *    '<S189>/g_assFLOW_BI_AMB_TGT'
 *    '<S190>/g_assFLOW_BI_AMB_TGT'
 *    '<S298>/g_assFLOW_BI_AMB_TGT'
 *    '<S299>/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:
 *    '<S130>/Bilevel'
 *    '<S131>/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_fou;
  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: '<S192>/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_fou);

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

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

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

  /* Switch: '<S187>/Switch1' incorporates:
   *  Gain: '<S187>/Gain6'
   *  Sum: '<S187>/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: '<S187>/g_aucFLOW_BI_FOOT_PLUS_LEFT' incorporates:
     *  MATLAB Function: '<S192>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S187>/Gain6' incorporates:
     *  MATLAB Function: '<S187>/g_aucFLOW_BI_FOOT_PLUS_LEFT'
     *  Product: '<S187>/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: '<S187>/Switch1' */

  /* MATLAB Function: '<S187>/g_aucFLOW_BI_FOOT_VALVE_MAX1' incorporates:
   *  MATLAB Function: '<S192>/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: '<S187>/g_aucFLOW_BI_FOOT_VALVE_MAX1' */

  /* MATLAB Function: '<S187>/g_aucFLOW_BI_FOOT_VALVE_MIN1' incorporates:
   *  MATLAB Function: '<S192>/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: '<S187>/g_aucFLOW_BI_FOOT_VALVE_MIN1' */

  /* MATLAB Function: '<S199>/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_fou);

  /* MATLAB Function: '<S199>/g_assFLOW_BI_TEMP_TGT_RIGHT' incorporates:
   *  MATLAB Function: '<S192>/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: '<S199>/ 1' incorporates:
   *  MATLAB Function: '<S199>/g_assFLOW_BI_TEMP_TGT_RIGHT'
   */
  rtb_u_fou = (int16_t)(g_assFLOW_BI_TEMP_TGT[tmp - 1] - rtb_u_fou);

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

  /* Switch: '<S188>/Switch3' incorporates:
   *  Gain: '<S188>/Gain7'
   *  Sum: '<S188>/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: '<S188>/g_aucFLOW_BI_FOOT_PLUS_RIGHT' incorporates:
     *  MATLAB Function: '<S192>/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: '<S188>/Gain7' incorporates:
     *  MATLAB Function: '<S188>/g_aucFLOW_BI_FOOT_PLUS_RIGHT'
     *  Product: '<S188>/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: '<S188>/Switch3' */

  /* MATLAB Function: '<S188>/g_aucFLOW_BI_FOOT_VALVE_MAX2' incorporates:
   *  MATLAB Function: '<S192>/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: '<S188>/g_aucFLOW_BI_FOOT_VALVE_MAX2' */

  /* MATLAB Function: '<S188>/g_aucFLOW_BI_FOOT_VALVE_MIN2' incorporates:
   *  MATLAB Function: '<S192>/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: '<S188>/g_aucFLOW_BI_FOOT_VALVE_MIN2' */

  /* MATLAB Function: '<S189>/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_fou);

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

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

  /* Product: '<S189>/Умножили' incorporates:
   *  Gain: '<S189>/Gain'
   *  Gain: '<S189>/Gain2'
   *  MATLAB Function: '<S189>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_fou = (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: '<S189>/Data Type Conversion' incorporates:
   *  Sum: '<S189>/ '
   *  Switch: '<S205>/Switch2'
   */
  rtb_Switch2_a_idx_0 = (uint16_t)((uint16_t)((rty_Out1[0] - rtb_u_fou) >> 1) <<
    1);
  rtb_Switch2_a_idx_1 = (uint16_t)((uint16_t)((rty_Out1[1] - rtb_u_fou) >> 1) <<
    1);

  /* MATLAB Function: '<S189>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S192>/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: '<S189>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S189>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S192>/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: '<S189>/g_aucFLOW_BI_VENT_VALVE_MIN' */

  /* MATLAB Function: '<S190>/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_fou);

  /* MATLAB Function: '<S190>/g_aucFLOW_BI_VENT_PLUS' incorporates:
   *  MATLAB Function: '<S192>/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: '<S190>/Gain2' incorporates:
   *  Sum: '<S190>/deg'
   */
  tmp_0 = (int16_t)(rtb_u_fou - rtu_Amb_Fb) * 13107;

  /* Product: '<S190>/Умножили' incorporates:
   *  Gain: '<S190>/Gain'
   *  Gain: '<S190>/Gain2'
   *  MATLAB Function: '<S190>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_fou = (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: '<S190>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S192>/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: '<S190>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S190>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S192>/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: '<S190>/g_aucFLOW_BI_VENT_VALVE_MIN' */

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

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

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

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

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

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

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

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

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

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

/*
 * Output and update for atomic system:
 *    '<S217>/g_assFLOW_BI_AMB_TGT'
 *    '<S218>/g_assFLOW_BI_AMB_TGT'
 *    '<S326>/g_assFLOW_BI_AMB_TGT'
 *    '<S327>/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:
 *    '<S130>/Bilevel2'
 *    '<S131>/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_cgj;
  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: '<S220>/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_cgj);

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

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

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

  /* Switch: '<S215>/Switch1' incorporates:
   *  Gain: '<S215>/Gain6'
   *  Sum: '<S215>/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: '<S215>/g_aucFLOW_BI_FOOT_PLUS_LEFT' incorporates:
     *  MATLAB Function: '<S220>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S215>/Gain6' incorporates:
     *  MATLAB Function: '<S215>/g_aucFLOW_BI_FOOT_PLUS_LEFT'
     *  Product: '<S215>/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: '<S215>/Switch1' */

  /* MATLAB Function: '<S215>/g_aucFLOW_BI_FOOT_VALVE_MAX1' incorporates:
   *  MATLAB Function: '<S220>/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: '<S215>/g_aucFLOW_BI_FOOT_VALVE_MAX1' */

  /* MATLAB Function: '<S215>/g_aucFLOW_BI_FOOT_VALVE_MIN1' incorporates:
   *  MATLAB Function: '<S220>/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: '<S215>/g_aucFLOW_BI_FOOT_VALVE_MIN1' */

  /* MATLAB Function: '<S227>/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_cgj);

  /* MATLAB Function: '<S227>/g_assFLOW_BI2_TEMP_TGT_RIGHT' incorporates:
   *  MATLAB Function: '<S220>/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: '<S227>/ 1' incorporates:
   *  MATLAB Function: '<S227>/g_assFLOW_BI2_TEMP_TGT_RIGHT'
   */
  rtb_u_cgj = (int16_t)(g_assFLOW_BI2_TEMP_TGT[tmp - 1] - rtb_u_cgj);

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

  /* Switch: '<S216>/Switch3' incorporates:
   *  Gain: '<S216>/Gain7'
   *  Sum: '<S216>/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: '<S216>/g_aucFLOW_BI_FOOT_PLUS_RIGHT' incorporates:
     *  MATLAB Function: '<S220>/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: '<S216>/Gain7' incorporates:
     *  MATLAB Function: '<S216>/g_aucFLOW_BI_FOOT_PLUS_RIGHT'
     *  Product: '<S216>/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: '<S216>/Switch3' */

  /* MATLAB Function: '<S216>/g_aucFLOW_BI_FOOT_VALVE_MAX2' incorporates:
   *  MATLAB Function: '<S220>/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: '<S216>/g_aucFLOW_BI_FOOT_VALVE_MAX2' */

  /* MATLAB Function: '<S216>/g_aucFLOW_BI_FOOT_VALVE_MIN2' incorporates:
   *  MATLAB Function: '<S220>/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: '<S216>/g_aucFLOW_BI_FOOT_VALVE_MIN2' */

  /* MATLAB Function: '<S217>/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_cgj);

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

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

  /* Product: '<S217>/Умножили' incorporates:
   *  Gain: '<S217>/Gain'
   *  Gain: '<S217>/Gain2'
   *  MATLAB Function: '<S217>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_cgj = (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: '<S217>/Data Type Conversion' incorporates:
   *  Sum: '<S217>/ '
   *  Switch: '<S233>/Switch2'
   */
  rtb_Switch2_i_idx_0 = (uint16_t)((uint16_t)((rty_Out1[0] - rtb_u_cgj) >> 1) <<
    1);
  rtb_Switch2_i_idx_1 = (uint16_t)((uint16_t)((rty_Out1[1] - rtb_u_cgj) >> 1) <<
    1);

  /* MATLAB Function: '<S217>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S220>/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: '<S217>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S217>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S220>/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: '<S217>/g_aucFLOW_BI_VENT_VALVE_MIN' */

  /* MATLAB Function: '<S218>/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_cgj);

  /* MATLAB Function: '<S218>/g_aucFLOW_BI_VENT_PLUS' incorporates:
   *  MATLAB Function: '<S220>/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: '<S218>/Gain2' incorporates:
   *  Sum: '<S218>/deg'
   */
  tmp_0 = (int16_t)(rtb_u_cgj - rtu_Amb_Fb) * 13107;

  /* Product: '<S218>/Умножили' incorporates:
   *  Gain: '<S218>/Gain'
   *  Gain: '<S218>/Gain2'
   *  MATLAB Function: '<S218>/g_aucFLOW_BI_VENT_PLUS'
   */
  rtb_u_cgj = (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: '<S218>/g_aucFLOW_BI_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S220>/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: '<S218>/g_aucFLOW_BI_VENT_VALVE_MAX' */

  /* MATLAB Function: '<S218>/g_aucFLOW_BI_VENT_VALVE_MIN' incorporates:
   *  MATLAB Function: '<S220>/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: '<S218>/g_aucFLOW_BI_VENT_VALVE_MIN' */

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

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

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

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

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

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

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

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

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

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

/*
 * Output and update for atomic system:
 *    '<S139>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S140>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S248>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S249>/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:
 *    '<S141>/g_assFLOW_AF_AMB_TGT'
 *    '<S142>/g_assFLOW_AF_AMB_TGT'
 *    '<S166>/g_assFLOW_AF_AMB_TGT'
 *    '<S250>/g_assFLOW_AF_AMB_TGT'
 *    '<S251>/g_assFLOW_AF_AMB_TGT'
 *    '<S275>/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:
 *    '<S130>/Afoot'
 *    '<S131>/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: '<S144>/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: '<S144>/g_assFLOW_BI2_TEMP_TGT_LEFT' */
  i = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    i = 255;
  }

  /* MATLAB Function: '<S144>/get_tg_for_LVL' incorporates:
   *  MATLAB Function: '<S144>/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: '<S144>/Gain6' incorporates:
   *  MATLAB Function: '<S144>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   *  MATLAB Function: '<S144>/get_tg_for_LVL'
   *  Sum: '<S144>/ 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: '<S139>/Switch1' incorporates:
   *  Gain: '<S139>/Gain6'
   *  Sum: '<S139>/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: '<S139>/g_aucFLOW_AF_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S144>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    i = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      i = 255;
    }

    /* Gain: '<S139>/Gain6' incorporates:
     *  MATLAB Function: '<S139>/g_aucFLOW_AF_FOOT_PLUS'
     *  Product: '<S139>/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: '<S139>/Switch1' */

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

  /* Switch: '<S143>/Switch2' incorporates:
   *  RelationalOperator: '<S143>/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: '<S143>/Switch2' */

  /* MATLAB Function: '<S150>/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: '<S150>/g_aucFLOW_AF_BLR_AF_TGT' incorporates:
   *  MATLAB Function: '<S144>/g_assFLOW_BI2_TEMP_TGT_LEFT'
   */
  i = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    i = 255;
  }

  /* MATLAB Function: '<S150>/get_vtg_for_LVL' incorporates:
   *  MATLAB Function: '<S144>/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: '<S150>/ 1' incorporates:
   *  MATLAB Function: '<S150>/g_aucFLOW_AF_BLR_AF_TGT'
   *  MATLAB Function: '<S150>/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: '<S150>/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: '<S140>/Switch3' incorporates:
   *  Gain: '<S140>/Gain7'
   *  Sum: '<S140>/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: '<S140>/g_aucFLOW_AF_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S144>/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: '<S140>/Gain7' incorporates:
     *  MATLAB Function: '<S140>/g_aucFLOW_AF_FOOT_PLUS'
     *  Product: '<S140>/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: '<S140>/Switch3' */

  /* MATLAB Function: '<S140>/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: '<S141>/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: '<S141>/deg' */
  rtb_deg_en -= rtu_Amb_Fb;

  /* Gain: '<S141>/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: '<S141>/if (deg < 0)' incorporates:
   *  Sum: '<S141>/ '
   *  Switch: '<S155>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_ar_idx_0 = rty_Out1[0];
    rtb_Switch2_ar_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S141>/g_aucFLOW_AF_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S144>/g_assFLOW_BI2_TEMP_TGT_LEFT'
     */
    i = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      i = 255;
    }

    /* Product: '<S141>/Умножили' incorporates:
     *  Gain: '<S141>/Gain'
     *  MATLAB Function: '<S141>/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: '<S141>/if (deg < 0)' */

  /* MATLAB Function: '<S141>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S144>/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: '<S141>/g_aucFLOW_AF_VENT_VALVE_MAX' */

  /* Switch: '<S155>/Switch2' incorporates:
   *  RelationalOperator: '<S155>/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: '<S155>/Switch2' */

  /* MATLAB Function: '<S142>/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: '<S142>/Gain2' incorporates:
   *  Sum: '<S142>/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: '<S142>/if (deg < 0)' incorporates:
   *  DataTypeConversion: '<S142>/Data Type Conversion'
   *  Sum: '<S142>/ '
   *  Switch: '<S159>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_j_idx_0 = rty_Out1[0];
    rtb_Switch2_j_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S142>/g_aucFLOW_AF_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S144>/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: '<S142>/Умножили' incorporates:
     *  Gain: '<S142>/Gain'
     *  MATLAB Function: '<S142>/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: '<S142>/if (deg < 0)' */

  /* MATLAB Function: '<S142>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S144>/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: '<S142>/g_aucFLOW_AF_VENT_VALVE_MAX' */

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

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

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

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

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

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

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

/*
 * Output and update for atomic system:
 *    '<S163>/g_aucFLOW_AFSM_FOOT_VALVE_MAX'
 *    '<S164>/g_aucFLOW_AF_FOOT_VALVE_MAX'
 *    '<S272>/g_aucFLOW_AFSM_FOOT_VALVE_MAX'
 *    '<S273>/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:
 *    '<S130>/Afoot_Summer'
 *    '<S131>/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: '<S168>/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: '<S168>/g_assFLOW_AFSM_TEMP_TGT_LEFT' */
  tmp_0 = (int32_t)(rtu_LVL + 1U);
  if (rtu_LVL + 1U > 255U) {
    tmp_0 = 255;
  }

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

  /* Gain: '<S168>/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: '<S163>/Switch1' incorporates:
   *  Gain: '<S163>/Gain6'
   *  Sum: '<S163>/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: '<S163>/g_aucFLOW_AFSM_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S168>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Gain: '<S163>/Gain6' incorporates:
     *  MATLAB Function: '<S163>/g_aucFLOW_AFSM_FOOT_PLUS'
     *  Product: '<S163>/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: '<S163>/Switch1' */

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

  /* Switch: '<S167>/Switch2' incorporates:
   *  RelationalOperator: '<S167>/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: '<S167>/Switch2' */

  /* MATLAB Function: '<S174>/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: '<S174>/g_assFLOW_AFSM_TEMP_TGT' incorporates:
   *  MATLAB Function: '<S168>/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: '<S174>/Gain6' incorporates:
   *  MATLAB Function: '<S174>/g_assFLOW_AFSM_TEMP_TGT'
   *  Sum: '<S174>/ 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: '<S164>/Switch3' incorporates:
   *  Gain: '<S164>/Gain7'
   *  Sum: '<S164>/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: '<S164>/g_aucFLOW_AFSM_FOOT_PLUS' incorporates:
     *  MATLAB Function: '<S168>/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: '<S164>/Gain7' incorporates:
     *  MATLAB Function: '<S164>/g_aucFLOW_AFSM_FOOT_PLUS'
     *  Product: '<S164>/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: '<S164>/Switch3' */

  /* MATLAB Function: '<S164>/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: '<S165>/g_assFLOW_AFSM_AMB_TGT' incorporates:
   *  MATLAB Function: '<S168>/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: '<S165>/deg' incorporates:
   *  MATLAB Function: '<S165>/g_assFLOW_AFSM_AMB_TGT'
   */
  rtb_deg_c = (int16_t)(g_assFLOW_AFSM_AMB_TGT[tmp_0 - 1] - rtu_Amb_Fb);

  /* Gain: '<S165>/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: '<S165>/if (deg < 0)' incorporates:
   *  Sum: '<S165>/ '
   *  Switch: '<S179>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_l_idx_0 = rty_Out1[0];
    rtb_Switch2_l_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S165>/g_aucFLOW_AFSM_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S168>/g_assFLOW_AFSM_TEMP_TGT_LEFT'
     */
    tmp_0 = (int32_t)(rtu_LVL + 1U);
    if (rtu_LVL + 1U > 255U) {
      tmp_0 = 255;
    }

    /* Product: '<S165>/Умножили' incorporates:
     *  Gain: '<S165>/Gain'
     *  MATLAB Function: '<S165>/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: '<S165>/if (deg < 0)' */

  /* MATLAB Function: '<S165>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S168>/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: '<S165>/g_aucFLOW_AF_VENT_VALVE_MAX' */

  /* Switch: '<S179>/Switch2' incorporates:
   *  RelationalOperator: '<S179>/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: '<S179>/Switch2' */

  /* MATLAB Function: '<S166>/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: '<S166>/Gain2' incorporates:
   *  Sum: '<S166>/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: '<S166>/if (deg < 0)' incorporates:
   *  DataTypeConversion: '<S166>/Data Type Conversion'
   *  Sum: '<S166>/ '
   *  Switch: '<S183>/Switch2'
   */
  if (rtb_X >= 0) {
    rtb_Switch2_j1_idx_0 = rty_Out1[0];
    rtb_Switch2_j1_idx_1 = rty_Out1[1];
  } else {
    /* MATLAB Function: '<S166>/g_aucFLOW_AF_VENT_PLUS' incorporates:
     *  MATLAB Function: '<S168>/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: '<S166>/Умножили' incorporates:
     *  Gain: '<S166>/Gain'
     *  MATLAB Function: '<S166>/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: '<S166>/if (deg < 0)' */

  /* MATLAB Function: '<S166>/g_aucFLOW_AF_VENT_VALVE_MAX' incorporates:
   *  MATLAB Function: '<S168>/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: '<S166>/g_aucFLOW_AF_VENT_VALVE_MAX' */

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

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

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

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

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

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

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

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

  return y;
}

/*
 * Output and update for atomic system:
 *    '<S110>/Начальные положения заслонок left'
 *    '<S110>/Начальные положения заслонок 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:
 *    '<S638>/If Action Subsystem'
 *    '<S708>/If Action Subsystem'
 *    '<S779>/If Action Subsystem'
 */
void IfActionSubsystem(int8_t *rty_Out1, double *rtd_ErrorHomming_private,
  double *rtd_Start_timer_n, int8_t *rtd_stepSig_private)
{
  /* DataStoreWrite: '<S641>/Data Store Write' incorporates:
   *  Constant: '<S641>/Constant'
   */
  *rtd_stepSig_private = 1;

  /* DataStoreWrite: '<S641>/Data Store Write1' incorporates:
   *  Constant: '<S641>/Constant2'
   *  DataStoreRead: '<S641>/Data Store Read1'
   *  Sum: '<S641>/step inc'
   */
  (*rtd_ErrorHomming_private)++;

  /* DataStoreWrite: '<S641>/Data Store Write2' incorporates:
   *  Constant: '<S641>/Constant3'
   */
  *rtd_Start_timer_n = 0.0;

  /* SignalConversion generated from: '<S641>/Out1' incorporates:
   *  Constant: '<S641>/Constant1'
   */
  *rty_Out1 = 2;
}

/*
 * System initialize for atomic system:
 *    '<S638>/MATLAB Function'
 *    '<S708>/MATLAB Function'
 *    '<S779>/MATLAB Function'
 */
void MATLABFunction_Init(DW_MATLABFunction *localDW)
{
  localDW->t_start_not_empty = false;
  localDW->cond_prev = 0.0;
}

/*
 * Output and update for atomic system:
 *    '<S638>/MATLAB Function'
 *    '<S708>/MATLAB Function'
 *    '<S779>/MATLAB Function'
 */
void MATLABFunction(double rtu_cond, uint32_t rtu_t_now, uint32_t *rty_dt,
                    DW_MATLABFunction *localDW)
{
  /* :  dt = uint32(0); */
  /* :  if isempty(t_start) */
  if (!localDW->t_start_not_empty) {
    /* :  t_start = t_now; */
    localDW->t_start = rtu_t_now;
    localDW->t_start_not_empty = true;

    /* :  cond_prev = 0; */
  }

  /* :  if cond > 0.5 && cond_prev <= 0.5 */
  if ((rtu_cond > 0.5) && (localDW->cond_prev <= 0.5)) {
    /* :  t_start = t_now; */
    localDW->t_start = rtu_t_now;
  }

  /* :  if cond > 0.5 */
  if (rtu_cond > 0.5) {
    uint32_t qY;

    /* :  dt = uint32(t_now - t_start); */
    /* MW:begin MISRA2012:D4.1 CERT-C:INT30-C 'Justifying MISRA CPP rule violation' */
    qY = rtu_t_now - /*MW:OvSatOk*/ localDW->t_start;

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

    *rty_dt = qY;
  } else {
    /* :  else */
    /* :  dt = uint32(0); */
    *rty_dt = 0U;
  }

  /* :  cond_prev = cond; */
  localDW->cond_prev = rtu_cond;
}

/*
 * Output and update for action system:
 *    '<S623>/If Action Subsystem1'
 *    '<S693>/If Action Subsystem1'
 *    '<S764>/If Action Subsystem1'
 */
void IfActionSubsystem1(int8_t *rty_Output, uint8_t
  *rtd_CCU_ActuatorErrF_Stat_private, uint8_t rtd_COM_private[9], uint8_t
  rtd_ErrorActuator[9], uint8_t rtd_ErrorCalibration_private[9], const double
  *rtd_LOGGER_LIN, uint8_t rtd_MODE_private[9], uint8_t
  rtd_dtc_state_error_model[127])
{
  int32_t i;
  bool tmp;

  /* Logic: '<S647>/Logical Operator' incorporates:
   *  DataStoreRead: '<S639>/Data Store Read'
   */
  tmp = (rtd_ErrorCalibration_private[0] != 0);
  for (i = 0; i < 8; i++) {
    tmp = (tmp || (rtd_ErrorCalibration_private[i + 1] != 0));
  }

  /* DataTypeConversion: '<S647>/Data Type Conversion' incorporates:
   *  DataStoreWrite: '<S647>/Data Store Write1'
   *  Logic: '<S647>/Logical Operator'
   */
  *rtd_CCU_ActuatorErrF_Stat_private = tmp;
  for (i = 0; i < 9; i++) {
    /* DataStoreWrite: '<S647>/Data Store Write2' incorporates:
     *  DataStoreRead: '<S639>/Data Store Read'
     */
    rtd_COM_private[i] = rtd_ErrorCalibration_private[i];

    /* DataStoreWrite: '<S647>/Data Store Write' */
    rtd_MODE_private[i] = 2U;
  }

  /* MATLAB Function: '<S647>/Write ERROR' incorporates:
   *  DataStoreRead: '<S639>/Data Store Read'
   *  DataStoreRead: '<S647>/Data Store Read6'
   */
  /* :  if(LOGGER==1) */
  if (*rtd_LOGGER_LIN == 1.0) {
    /* :  for i = 1:numel(ErrCallibration) */
    for (i = 0; i < 9; i++) {
      /* :  if ErrCallibration(i) == 1 */
      if (rtd_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: '<S647>/Write ERROR' */
  for (i = 0; i < 9; i++) {
    uint8_t rtd_ErrorCalibration_private_0;

    /* Logic: '<S639>/Logical Operator1' incorporates:
     *  DataStoreRead: '<S639>/Data Store Read'
     */
    rtd_ErrorCalibration_private_0 = rtd_ErrorCalibration_private[i];

    /* DataTypeConversion: '<S639>/Data Type Conversion1' incorporates:
     *  DataStoreRead: '<S639>/Data Store Read1'
     *  DataStoreWrite: '<S639>/Data Store Write3'
     *  Logic: '<S639>/Logical Operator1'
     */
    rtd_ErrorActuator[i] = (uint8_t)((rtd_ErrorCalibration_private_0 != 0) ||
      (rtd_ErrorActuator[i] != 0));

    /* DataStoreWrite: '<S648>/Data Store Write' */
    rtd_dtc_state_error_model[i + 54] = rtd_ErrorCalibration_private_0;

    /* DataStoreWrite: '<S639>/Data Store Write' */
    rtd_ErrorCalibration_private[i] = 0U;
  }

  /* SignalConversion generated from: '<S639>/Output' incorporates:
   *  Constant: '<S639>/Constant'
   */
  *rty_Output = 4;
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Bi Level'
 *    '<S817>/AF for Bi Level'
 */
void AFforBiLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_BI2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_BI2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Def'
 *    '<S817>/AF for Def'
 */
void AFforDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_DE2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_DE2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Foor + Def'
 *    '<S817>/AF for Foor + Def'
 */
void AFforFoorDef(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_FD2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_FD2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Foot'
 *    '<S817>/AF for Foot'
 */
void AFforFoot(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_FO2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_FO2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Hi_Level'
 *    '<S817>/AF for Hi_Level'
 */
void AFforHi_Level(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_HI2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_HI2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Tri-Level'
 *    '<S817>/AF for Tri-Level'
 */
void AFforTriLevel(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_TR2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_TR2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S816>/AF for Vent mode'
 *    '<S817>/AF for Vent mode'
 */
void AFforVentmode(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_FR_VE2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_FR_VE2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S834>/AF for Bi Level R'
 *    '<S835>/AF for Bi Level R'
 */
void AFforBiLevelR(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_RE_BI2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_RE_BI2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S834>/AF for Foot R'
 *    '<S835>/AF for Foot R'
 */
void AFforFootR(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_RE_FO2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_RE_FO2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S834>/AF for Vent mode R'
 *    '<S835>/AF for Vent mode R'
 */
void AFforVentmodeR(uint8_t rtu_blower_speed, uint16_t *rty_out)
{
  int32_t tmp;

  /* :  out = uint16(g_ausFLOW_RE_VE2BLR_AF(blower_speed + 1)); */
  tmp = (int32_t)(rtu_blower_speed + 1U);
  if (rtu_blower_speed + 1U > 255U) {
    tmp = 255;
  }

  *rty_out = g_ausFLOW_RE_VE2BLR_AF[tmp - 1];
}

/*
 * Output and update for atomic system:
 *    '<S845>/Valves for Bi Level'
 *    '<S846>/Valves for Bi Level'
 */
void ValvesforBiLevel(uint16_t rty_out[9])
{
  int32_t i;
  for (i = 0; i < 9; i++) {
    rty_out[i] = g_ausFLOW_FR_BIVALVE_MANUAL[i];
  }

  /* :  out = g_ausFLOW_FR_BIVALVE_MANUAL; */
}

/*
 * Output and update for atomic system:
 *    '<S845>/Valves for Def'
 *    '<S846>/Valves for Def'
 */
void ValvesforDef(uint16_t rty_out[9])
{
  int32_t i;
  for (i = 0; i < 9; i++) {
    rty_out[i] = g_ausFLOW_FR_DE2VALVE[i];
  }

  /* :  out = g_ausFLOW_FR_DE2VALVE; */
}

/*
 * Output and update for atomic system:
 *    '<S845>/Valves for Foot + Def'
 *    '<S846>/Valves for Foot + Def'
 */
void ValvesforFootDef(uint16_t rty_out[9])
{
  int32_t i;
  for (i = 0; i < 9; i++) {
    rty_out[i] = g_ausFLOW_FR_FD2VALVE[i];
  }

  /* :  out = g_ausFLOW_FR_FD2VALVE; */
}

/*
 * Output and update for atomic system:
 *    '<S845>/Valves for Hi_Level'
 *    '<S846>/Valves for Hi_Level'
 */
void ValvesforHi_Level(uint16_t rty_out[9])
{
  int32_t i;
  for (i = 0; i < 9; i++) {
    rty_out[i] = g_ausFLOW_FR_HI2VALVE[i];
  }

  /* :  out = g_ausFLOW_FR_HI2VALVE; */
}

/*
 * Output and update for atomic system:
 *    '<S845>/Valves for Tri-Level'
 *    '<S846>/Valves for Tri-Level'
 */
void ValvesforTriLevel(uint16_t rty_out[9])
{
  int32_t i;
  for (i = 0; i < 9; i++) {
    rty_out[i] = g_ausFLOW_FR_TR2VALVE[i];
  }

  /* :  out = g_ausFLOW_FR_TR2VALVE; */
}

/*
 * Output and update for atomic system:
 *    '<S861>/AF for Bi Level'
 *    '<S862>/AF for Bi Level'
 */
void AFforBiLevel_m(uint16_t rty_out[6])
{
  int32_t i;
  for (i = 0; i < 6; i++) {
    rty_out[i] = g_ausFLOW_RE_BI2VALVE_MANUAL[i];
  }

  /* :  out = g_ausFLOW_RE_BI2VALVE_MANUAL; */
}

/*
 * Output and update for atomic system:
 *    '<S861>/valves for Vent mode'
 *    '<S862>/valves for Vent mode'
 */
void valvesforVentmode(uint16_t rty_out[6])
{
  int32_t i;
  for (i = 0; i < 6; i++) {
    rty_out[i] = g_ausFLOW_RE_VENT_MANUAL[i];
  }

  /* :  out = g_ausFLOW_RE_VENT_MANUAL; */
}

/*
 * Output and update for atomic system:
 *    '<S882>/g_assSTART_ENTER_INCAR'
 *    '<S883>/g_assSTART_ENTER_INCAR'
 */
void g_assSTART_ENTER_INCAR_j(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 atomic system:
 *    '<S885>/g_assSTART_ENTER_COOLANT '
 *    '<S886>/g_assSTART_ENTER_COOLANT '
 *    '<S887>/g_assSTART_ENTER_COOLANT '
 */
void g_assSTART_ENTER_COOLANT_p(uint8_t rtu_LVL, int16_t *rty_out)
{
  int32_t q0;
  uint32_t qY;

  /* :  out = int16(g_assSTART_ENTER_COOLANT(LVL + 1 - 3)); */
  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 - 3U;

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

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

/*
 * Output and update for action system:
 *    '<S877>/Level 4'
 *    '<S877>/Level 5'
 */
void Level4(int8_t *rty_step1, const int16_t *rtd_ECT, const uint8_t *rtd_LEVEL,
            const double *rtd_MODE_DRIVER)
{
  int16_t rtb_out_p2;

  /* MATLAB Function: '<S886>/g_assSTART_ENTER_COOLANT ' incorporates:
   *  DataStoreRead: '<S886>/Data Store Read3'
   */
  g_assSTART_ENTER_COOLANT_p(*rtd_LEVEL, &rtb_out_p2);

  /* Switch: '<S886>/Switch' incorporates:
   *  Constant: '<S886>/AUTO'
   *  Constant: '<S886>/Constant'
   *  Constant: '<S886>/Constant1'
   *  DataStoreRead: '<S886>/Data Store Read'
   *  DataStoreRead: '<S886>/Data Store Read1'
   *  Logic: '<S886>/AND'
   *  RelationalOperator: '<S886>/Relational Operator'
   *  RelationalOperator: '<S886>/Relational Operator2'
   */
  if ((*rtd_ECT < rtb_out_p2) && (*rtd_MODE_DRIVER == 1.0)) {
    *rty_step1 = 0;
  } else {
    *rty_step1 = -1;
  }

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

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

/*
 * Output and update for atomic system:
 *    '<S898>/incar filter down'
 *    '<S899>/incar filter down'
 *    '<S900>/incar filter down'
 *    '<S910>/incar filter down'
 *    '<S911>/incar filter down'
 *    '<S913>/incar filter down'
 *    '<S914>/incar filter down'
 *    '<S915>/incar filter down'
 *    '<S978>/incar filter down'
 *    '<S979>/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:
 *    '<S898>/incar filter up'
 *    '<S899>/incar filter up'
 *    '<S900>/incar filter up'
 *    '<S910>/incar filter up'
 *    '<S911>/incar filter up'
 *    '<S913>/incar filter up'
 *    '<S914>/incar filter up'
 *    '<S915>/incar filter up'
 *    '<S978>/incar filter up'
 *    '<S979>/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:
 *    '<S899>/g_assSTART_COOLANT_STEP0_TO_1 '
 *    '<S900>/g_assSTART_COOLANT_STEP0_TO_1 '
 */
void g_assSTART_COOLANT_STEP0_TO_1_h(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:
 *    '<S910>/3 way valve status'
 *    '<S911>/3 way valve status'
 *    '<S913>/3 way valve status'
 *    '<S914>/3 way valve status'
 *    '<S915>/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:
 *    '<S910>/Dtg_FrontLower_X'
 *    '<S911>/Dtg_FrontLower_X'
 *    '<S913>/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:
 *    '<S910>/Dtg_FrontUpper_X'
 *    '<S911>/Dtg_FrontUpper_X'
 *    '<S913>/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:
 *    '<S910>/Incar temp goto from step 1 to step 2 '
 *    '<S911>/Incar temp goto from step 1 to step 2 '
 *    '<S913>/Incar temp goto from step 1 to step 2 '
 *    '<S914>/Incar temp goto from step 1 to step 2 '
 *    '<S915>/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:
 *    '<S910>/blower FR'
 *    '<S911>/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:
 *    '<S910>/mode FR step 1'
 *    '<S911>/mode FR step 1'
 *    '<S913>/mode FR step 1'
 *    '<S914>/mode FR step 1'
 *    '<S915>/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:
 *    '<S910>/window heating'
 *    '<S911>/window heating'
 *    '<S913>/window heating'
 *    '<S914>/window heating'
 *    '<S915>/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:
 *    '<S911>/Time goto from step 1 to step 2 '
 *    '<S913>/Time goto from step 1 to step 2 '
 *    '<S914>/Time goto from step 1 to step 2 '
 *    '<S915>/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:
 *    '<S944>/ECT min max'
 *    '<S958>/ECT min max'
 *    '<S971>/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:
 *    '<S944>/blower min max'
 *    '<S958>/blower min max'
 *    '<S971>/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:
 *    '<S879>/Level 4'
 *    '<S879>/Level 5'
 */
void Level4_c(int8_t *rty_step, uint16_t *rtd_Blower_FL, uint16_t *rtd_Blower_FR,
              uint8_t *rtd_Dtg_FLL, uint8_t *rtd_Dtg_FLR, uint8_t *rtd_Dtg_FUL,
              uint8_t *rtd_Dtg_FUR, const int16_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_n *localDW)
{
  int32_t tmp;
  int16_t rtb_out_jl[2];
  int16_t rtb_out_ap;
  int16_t rtb_out_nv;
  uint16_t rtb_out_nm[2];
  uint8_t rtb_out_fa;
  bool rtb_Equal_b;
  bool rtb_RelationalOperator1_mub;

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

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

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

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

  /* DataStoreWrite: '<S914>/Data Store Write2' */
  *rtd_Mode_FR = rtb_out_fa;

  /* DataStoreWrite: '<S914>/Data Store Write3' */
  *rtd_Mode_FL = rtb_out_fa;

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

  /* DataStoreWrite: '<S914>/Data Store Write4' */
  *rtd_El_window_heating = rtb_out_fa;

  /* MATLAB Function: '<S958>/blower min max' incorporates:
   *  DataStoreRead: '<S914>/Data Store Read7'
   */
  blowerminmax(*rtd_LEVEL, rtb_out_nm);

  /* MATLAB Function: '<S958>/ECT min max' incorporates:
   *  DataStoreRead: '<S914>/Data Store Read7'
   */
  ECTminmax(*rtd_LEVEL, rtb_out_jl);

  /* Lookup_n-D: '<S958>/blower для текущего ECT' incorporates:
   *  DataStoreRead: '<S958>/engine coolant temp'
   */
  rtb_out_nv = look1_is16lu64n32tu16Ds32Is16_binlcs(*rtd_ECT, rtb_out_jl,
    rtb_out_nm, 1U);

  /* DataTypeConversion: '<S958>/Data Type Conversion1' incorporates:
   *  DataStoreWrite: '<S914>/Data Store Write5'
   */
  *rtd_Blower_FR = (uint16_t)rtb_out_nv;

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

  /* MATLAB Function: '<S914>/Dtg_FrontUpper_X' incorporates:
   *  DataStoreRead: '<S914>/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_fa = g_aucSTART_DUCT_TGT_STEP2_FX_U[tmp - 1];

  /* DataStoreWrite: '<S914>/Data Store Write10' */
  *rtd_Dtg_FUR = rtb_out_fa;

  /* DataStoreWrite: '<S914>/Data Store Write11' */
  *rtd_Dtg_FUL = rtb_out_fa;

  /* MATLAB Function: '<S914>/Dtg_FrontLower_X' incorporates:
   *  DataStoreRead: '<S914>/Data Store Read8'
   *  DataStoreRead: '<S914>/Data Store Read9'
   *  MATLAB Function: '<S914>/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_fa = g_aucSTART_DUCT_TGT_STEP2_FX_L[tmp - 1];

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

  /* DataStoreWrite: '<S914>/Data Store Write12' */
  *rtd_Dtg_FLR = rtb_out_fa;

  /* DataStoreWrite: '<S914>/Data Store Write13' */
  *rtd_Dtg_FLL = rtb_out_fa;

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

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

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

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

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

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

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

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

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

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

/*
 * Output and update for atomic system:
 *    '<S978>/3 way valve status'
 *    '<S979>/3 way valve status'
 *    '<S981>/3 way valve status'
 *    '<S982>/3 way valve status'
 *    '<S983>/3 way valve status'
 */
void uwayvalvestatus_a(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:
 *    '<S985>/time for step'
 *    '<S1015>/time for step'
 *    '<S1045>/time for step'
 *    '<S1076>/time for step'
 *    '<S1107>/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:
 *    '<S986>/time for step'
 *    '<S1016>/time for step'
 *    '<S1046>/time for step'
 *    '<S1077>/time for step'
 *    '<S1108>/time for step'
 */
void timeforstep_j(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:
 *    '<S978>/Time goto from step 2 to step 3 '
 *    '<S979>/Time goto from step 2 to step 3 '
 *    '<S981>/Time goto from step 2 to step 3 '
 *    '<S982>/Time goto from step 2 to step 3 '
 *    '<S983>/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:
 *    '<S989>/blower step'
 *    '<S1019>/blower step'
 *    '<S1050>/blower step'
 *    '<S1081>/blower step'
 *    '<S1112>/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:
 *    '<S989>/blower time for step'
 *    '<S1019>/blower time for step'
 *    '<S1050>/blower time for step'
 *    '<S1081>/blower time for step'
 *    '<S1112>/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:
 *    '<S992>/step'
 *    '<S1022>/step'
 *    '<S1053>/step'
 *    '<S1084>/step'
 *    '<S1115>/step'
 */
void step_j(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:
 *    '<S992>/time for step'
 *    '<S1022>/time for step'
 *    '<S1053>/time for step'
 *    '<S1084>/time for step'
 *    '<S1115>/time for step'
 */
void timeforstep_g(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:
 *    '<S979>/window heating'
 *    '<S981>/window heating'
 *    '<S982>/window heating'
 *    '<S983>/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:
 *    '<S981>/autodemist (autodefog)'
 *    '<S982>/autodemist (autodefog)'
 *    '<S983>/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:
 *    '<S880>/Level 3'
 *    '<S880>/Level 4'
 */
void Level3(int8_t *rty_step, uint8_t *rtd_Autodefog, uint16_t *rtd_Blower_FL,
            uint16_t *rtd_Blower_FR, const uint16_t *rtd_Blower_logic_FL,
            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
            *localDW)
{
  int32_t tmp;
  int16_t rtb_out_cw;
  uint16_t rtb_out_as;
  uint16_t rtb_out_gqg;
  uint8_t rtb_out_iew;
  uint8_t rtb_out_ir5;
  uint8_t rtb_out_pr;
  bool rtb_Cond_prev_private_gh;
  bool rtb_RelationalOperator1_bkl;

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

  /* MATLAB Function: '<S1045>/step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read9'
   */
  Dtg_FrontLower_X(*rtd_LEVEL, &rtb_out_iew);

  /* MATLAB Function: '<S1045>/time for step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read9'
   */
  timeforstep(*rtd_LEVEL, &rtb_out_ir5);

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

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

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

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

  /* MATLAB Function: '<S1046>/step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read8'
   */
  Dtg_FrontUpper_X(*rtd_LEVEL, &rtb_out_iew);

  /* MATLAB Function: '<S1046>/time for step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read8'
   */
  timeforstep_j(*rtd_LEVEL, &rtb_out_ir5);

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

    *rtd_Dtg_FUR = (uint8_t)((double)rtb_out_iew / (double)rtb_out_ir5 / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_i) * (double)tmp + (double)*
      rtd_Dtg_FUL);
  }

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

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

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

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

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

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

  /* MATLAB Function: '<S1053>/step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read5'
   */
  step_j(*rtd_LEVEL, &rtb_out_ir5);

  /* MATLAB Function: '<S1053>/time for step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read5'
   */
  timeforstep_g(*rtd_LEVEL, &rtb_out_pr);

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

    *rtd_Mode_FR = (uint8_t)((double)rtb_out_ir5 / (double)rtb_out_pr / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_j) * (double)tmp + (double)*
      rtd_Mode_FL);
  }

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

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

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

  /* DataStoreWrite: '<S981>/Data Store Write4' */
  *rtd_El_window_heating = rtb_out_iew;

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

  /* RelationalOperator: '<S1065>/Relational Operator' incorporates:
   *  Constant: '<S1065>/epsilon'
   */
  rtb_Cond_prev_private_gh = (rtb_out_as <= 0.01);

  /* MATLAB Function: '<S1050>/blower step' incorporates:
   *  DataStoreRead: '<S981>/Data Store Read7'
   */
  blowerstep(*rtd_LEVEL, &rtb_out_gqg);

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

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

    *rtd_Blower_FR = (uint16_t)((double)rtb_out_gqg / (double)rtb_out_as /
      1000.0 * (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_a) * (double)tmp
      + (double)*rtd_Blower_FL);
  }

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

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

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

  /* RelationalOperator: '<S981>/Equal' incorporates:
   *  DataStoreRead: '<S981>/current step'
   */
  rtb_Cond_prev_private_gh = (*rtd_step_start_controle_front == 2);

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

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

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

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

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

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

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

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

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

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

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

/*
 * Output and update for action system:
 *    '<S875>/Step 3 F'
 *    '<S876>/Step 3 R'
 */
void Step3F(int8_t *rty_step, int8_t *rtd_start_control_finished_front)
{
  /* DataStoreWrite: '<S881>/Data Store Write10' incorporates:
   *  Constant: '<S881>/True'
   */
  *rtd_start_control_finished_front = 1;

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

/*
 * Output and update for atomic system:
 *    '<S1142>/g_ausSTART_ENTER_SETTEMP'
 *    '<S1143>/g_ausSTART_ENTER_SETTEMP'
 *    '<S1144>/g_ausSTART_ENTER_SETTEMP'
 */
void g_ausSTART_ENTER_SETTEMP_b(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:
 *    '<S1143>/g_assSTART_ENTER_INCAR'
 *    '<S1144>/g_assSTART_ENTER_INCAR'
 *    '<S1145>/g_assSTART_ENTER_INCAR'
 *    '<S1146>/g_assSTART_ENTER_INCAR'
 *    '<S1147>/g_assSTART_ENTER_INCAR'
 */
void g_assSTART_ENTER_INCAR_p(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:
 *    '<S1145>/g_assSTART_ENTER_COOLANT '
 *    '<S1146>/g_assSTART_ENTER_COOLANT '
 *    '<S1147>/g_assSTART_ENTER_COOLANT '
 */
void g_assSTART_ENTER_COOLANT_e(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:
 *    '<S1137>/Level 4'
 *    '<S1137>/Level 5'
 */
void Level4_e(int8_t *rty_step1, const int16_t *rtd_ECT, const int16_t
              *rtd_Incar_RR, const uint8_t *rtd_LEVEL, const double
              *rtd_MODE_RR_passenger)
{
  int16_t rtb_out_ef;
  int16_t rtb_out_ntg;

  /* MATLAB Function: '<S1146>/g_assSTART_ENTER_INCAR' incorporates:
   *  DataStoreRead: '<S1146>/Data Store Read4'
   */
  g_assSTART_ENTER_INCAR_p(*rtd_LEVEL, &rtb_out_ntg);

  /* MATLAB Function: '<S1146>/g_assSTART_ENTER_COOLANT ' incorporates:
   *  DataStoreRead: '<S1146>/Data Store Read3'
   */
  g_assSTART_ENTER_COOLANT_e(*rtd_LEVEL, &rtb_out_ef);

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

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

/*
 * Output and update for atomic system:
 *    '<S1163>/incar filter down'
 *    '<S1164>/incar filter down'
 *    '<S1165>/incar filter down'
 *    '<S1166>/incar filter down'
 */
void incarfilterdown_c(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:
 *    '<S1163>/incar filter up'
 *    '<S1164>/incar filter up'
 *    '<S1165>/incar filter up'
 *    '<S1166>/incar filter up'
 */
void incarfilterup_i(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:
 *    '<S1164>/g_assSTART_COOLANT_STEP0_TO_1 '
 *    '<S1165>/g_assSTART_COOLANT_STEP0_TO_1 '
 *    '<S1166>/g_assSTART_COOLANT_STEP0_TO_1 '
 */
void g_assSTART_COOLANT_STEP0_TO_1_e(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:
 *    '<S1138>/Level 4'
 *    '<S1138>/Level 5'
 */
void Level4_m(int8_t *rty_step1, uint16_t *rtd_Blower_RL, uint16_t
              *rtd_Blower_RR, uint8_t *rtd_Dtg_RL, uint8_t *rtd_Dtg_RR, const
              int16_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_ls;

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

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

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

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

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

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

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

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

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

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

  /* MATLAB Function: '<S1165>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
   *  DataStoreRead: '<S1165>/Data Store Read3'
   */
  g_assSTART_COOLANT_STEP0_TO_1_e(*rtd_LEVEL, &rtb_out_ls);

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

/*
 * Output and update for atomic system:
 *    '<S1179>/2 way valve'
 *    '<S1180>/2 way valve'
 *    '<S1181>/2 way valve'
 *    '<S1182>/2 way valve'
 *    '<S1183>/2 way valve'
 *    '<S1184>/2 way valve'
 *    '<S1249>/2 way valve'
 *    '<S1250>/2 way valve'
 *    '<S1251>/2 way valve'
 *    '<S1252>/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:
 *    '<S1179>/Dtg_rear'
 *    '<S1180>/Dtg_rear'
 *    '<S1181>/Dtg_rear'
 *    '<S1182>/Dtg_rear'
 *    '<S1183>/Dtg_rear'
 *    '<S1184>/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:
 *    '<S1179>/Incar temp goto from step 1 to step 2 '
 *    '<S1180>/Incar temp goto from step 1 to step 2 '
 *    '<S1181>/Incar temp goto from step 1 to step 2 '
 *    '<S1182>/Incar temp goto from step 1 to step 2 '
 *    '<S1183>/Incar temp goto from step 1 to step 2 '
 *    '<S1184>/Incar temp goto from step 1 to step 2 '
 */
void Incartempgotofromstep1tostep2_j(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:
 *    '<S1179>/Time goto from step 1 to step 2 '
 *    '<S1180>/Time goto from step 1 to step 2 '
 *    '<S1181>/Time goto from step 1 to step 2 '
 *    '<S1182>/Time goto from step 1 to step 2 '
 *    '<S1183>/Time goto from step 1 to step 2 '
 *    '<S1184>/Time goto from step 1 to step 2 '
 *    '<S1249>/Time goto from step 1 to step 2 '
 *    '<S1250>/Time goto from step 1 to step 2 '
 *    '<S1251>/Time goto from step 1 to step 2 '
 *    '<S1252>/Time goto from step 1 to step 2 '
 *    ...
 */
void Timegotofromstep1tostep2_l(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:
 *    '<S1179>/mode rear step 1'
 *    '<S1180>/mode rear step 1'
 *    '<S1181>/mode rear step 1'
 *    '<S1182>/mode rear step 1'
 *    '<S1183>/mode rear step 1'
 *    '<S1184>/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:
 *    '<S1139>/Level 0'
 *    '<S1139>/Level 1'
 */
void Level0_b(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR,
              uint8_t *rtd_Dtg_RL, uint8_t *rtd_Dtg_RR, const int16_t
              *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_c *localDW)
{
  int32_t tmp;
  uint32_t rtb_dt_j0;
  int16_t rtb_out_gb;
  int16_t rtb_out_kdi;
  uint16_t rtb_out_ne;
  uint8_t rtb_out_hl;
  bool rtb_Equal_eo;

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

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

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

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

  /* DataStoreWrite: '<S1179>/Data Store Write2' */
  *rtd_Mode_RR = rtb_out_hl;

  /* DataStoreWrite: '<S1179>/Data Store Write3' */
  *rtd_Mode_RL = rtb_out_hl;

  /* MATLAB Function: '<S1179>/blower rear' incorporates:
   *  DataStoreRead: '<S1179>/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_ne = g_ausSTART_BLR_AF_STEP12_R[tmp - 1];

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

  /* DataStoreWrite: '<S1179>/Data Store Write5' */
  *rtd_Blower_RR = rtb_out_ne;

  /* DataStoreWrite: '<S1179>/Data Store Write6' */
  *rtd_Blower_RL = rtb_out_ne;

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

  /* DataStoreWrite: '<S1179>/Data Store Write10' */
  *rtd_Dtg_RR = rtb_out_hl;

  /* DataStoreWrite: '<S1179>/Data Store Write11' */
  *rtd_Dtg_RL = rtb_out_hl;

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

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

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

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

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

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

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

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

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

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

/*
 * Output and update for atomic system:
 *    '<S1208>/blower start finish'
 *    '<S1220>/blower start finish'
 *    '<S1232>/blower start finish'
 *    '<S1243>/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:
 *    '<S1220>/ECT min max'
 *    '<S1232>/ECT min max'
 *    '<S1243>/ECT min max'
 */
void ECTminmax_l(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:
 *    '<S1139>/Level 4'
 *    '<S1139>/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 int16_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_a *localDW)
{
  uint32_t rtb_dt_md;
  int16_t rtb_out_ij[2];
  int16_t rtb_out_mac;
  int16_t rtb_out_md;
  uint16_t rtb_out_dq[2];
  uint8_t rtb_out_gz;
  bool rtb_Equal_m3;

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

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

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

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

  /* DataStoreWrite: '<S1183>/Data Store Write2' */
  *rtd_Mode_RR = rtb_out_gz;

  /* DataStoreWrite: '<S1183>/Data Store Write3' */
  *rtd_Mode_RL = rtb_out_gz;

  /* MATLAB Function: '<S1232>/blower start finish' incorporates:
   *  DataStoreRead: '<S1183>/Data Store Read7'
   */
  blowerstartfinish(*rtd_LEVEL, rtb_out_dq);

  /* MATLAB Function: '<S1232>/ECT min max' incorporates:
   *  DataStoreRead: '<S1183>/Data Store Read7'
   */
  ECTminmax_l(*rtd_LEVEL, rtb_out_ij);

  /* Lookup_n-D: '<S1232>/blower для текущего ECT' incorporates:
   *  DataStoreRead: '<S1232>/engine coolant temp'
   */
  rtb_out_md = look1_is16lu64n32tu16Ds32Is16_binlcs(*rtd_ECT, rtb_out_ij,
    rtb_out_dq, 1U);

  /* DataTypeConversion: '<S1232>/Data Type Conversion1' incorporates:
   *  DataStoreWrite: '<S1183>/Data Store Write5'
   */
  *rtd_Blower_RR = (uint16_t)rtb_out_md;

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

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

  /* DataStoreWrite: '<S1183>/Data Store Write10' */
  *rtd_Dtg_RR = rtb_out_gz;

  /* DataStoreWrite: '<S1183>/Data Store Write11' */
  *rtd_Dtg_RL = rtb_out_gz;

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

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

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

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

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

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

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

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

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

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

/*
 * Output and update for atomic system:
 *    '<S1256>/time for step'
 *    '<S1279>/time for step'
 *    '<S1302>/time for step'
 *    '<S1325>/time for step'
 *    '<S1348>/time for step'
 *    '<S1371>/time for step'
 */
void timeforstep_jn(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:
 *    '<S1259>/blower step'
 *    '<S1282>/blower step'
 *    '<S1305>/blower step'
 *    '<S1328>/blower step'
 *    '<S1351>/blower step'
 *    '<S1374>/blower step'
 */
void blowerstep_d(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:
 *    '<S1259>/blower time for step'
 *    '<S1282>/blower time for step'
 *    '<S1305>/blower time for step'
 *    '<S1328>/blower time for step'
 *    '<S1351>/blower time for step'
 *    '<S1374>/blower time for step'
 */
void blowertimeforstep_l(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:
 *    '<S1262>/step'
 *    '<S1285>/step'
 *    '<S1308>/step'
 *    '<S1331>/step'
 *    '<S1354>/step'
 *    '<S1377>/step'
 */
void step_a(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:
 *    '<S1262>/time for step'
 *    '<S1285>/time for step'
 *    '<S1308>/time for step'
 *    '<S1331>/time for step'
 *    '<S1354>/time for step'
 *    '<S1377>/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:
 *    '<S1140>/Level 3'
 *    '<S1140>/Level 4'
 *    '<S1140>/Level 5'
 */
void Level3_i(int8_t *rty_step, uint16_t *rtd_Blower_RL, uint16_t *rtd_Blower_RR,
              const uint16_t *rtd_Blower_logic_RR, uint8_t *rtd_Dtg_RL, uint8_t *
              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_Level3_n *localDW)
{
  int32_t tmp;
  uint32_t rtb_dt_jh;
  int16_t rtb_out_cg;
  uint16_t rtb_out_nn;
  uint16_t rtb_out_pv;
  uint8_t rtb_out_di;
  uint8_t rtb_out_jl;
  bool rtb_Cond_prev_private_a4;

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

  /* MATLAB Function: '<S1325>/step' incorporates:
   *  DataStoreRead: '<S1252>/Data Store Read8'
   */
  Dtg_rear(*rtd_LEVEL, &rtb_out_jl);

  /* MATLAB Function: '<S1325>/time for step' incorporates:
   *  DataStoreRead: '<S1252>/Data Store Read8'
   */
  timeforstep_jn(*rtd_LEVEL, &rtb_out_di);

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

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

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

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

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

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

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

  /* RelationalOperator: '<S1342>/Relational Operator' incorporates:
   *  Constant: '<S1342>/epsilon'
   */
  rtb_Cond_prev_private_a4 = (rtb_out_jl <= 0.01);

  /* MATLAB Function: '<S1331>/step' incorporates:
   *  DataStoreRead: '<S1252>/Data Store Read5'
   */
  step_a(*rtd_LEVEL, &rtb_out_di);

  /* MATLAB Function: '<S1331>/time for step' incorporates:
   *  DataStoreRead: '<S1252>/Data Store Read5'
   */
  timeforstep_h(*rtd_LEVEL, &rtb_out_jl);

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

    *rtd_Mode_RR = (uint8_t)((double)rtb_out_di / (double)rtb_out_jl / 1000.0 *
      (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_i) * (double)tmp + (double)*
      rtd_Mode_RR);
  }

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

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

  /* MATLAB Function: '<S1328>/blower step' incorporates:
   *  DataStoreRead: '<S1252>/Data Store Read7'
   */
  blowerstep_d(*rtd_LEVEL, &rtb_out_nn);

  /* MATLAB Function: '<S1328>/blower time for step' incorporates:
   *  DataStoreRead: '<S1252>/Data Store Read7'
   */
  blowertimeforstep_l(*rtd_LEVEL, &rtb_out_pv);

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

    *rtd_Blower_RR = (uint16_t)((double)rtb_out_nn / (double)rtb_out_pv / 1000.0
      * (double)(*rtd_t_now - localDW->UnitDelay_DSTATE_e) * (double)tmp +
      (double)*rtd_Blower_RR);
  }

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

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

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

  /* RelationalOperator: '<S1252>/Equal' incorporates:
   *  DataStoreRead: '<S1252>/current step'
   */
  rtb_Cond_prev_private_a4 = (*rtd_step_start_controle_rear == 2);

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

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

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

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

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

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

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

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

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

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

/* Model step function */
void HVAC_model_step(void)
{
  double rtb_Divide1_a4[9];
  double rtb_f_lower_upper_bounds[2];
  double rtb_Divide10;
  double rtb_Divide11;
  double rtb_Divide3;
  double rtb_Divide6;
  double rtb_Divide8;
  double rtb_rate;
  int32_t i;
  int32_t tmp;
  uint32_t rtb_Subtract;
  uint32_t rtb_dt_an;
  int16_t rtb_uDLookupTable7[6];
  int16_t rtb_out_md[2];
  int16_t Duct1_F;
  int16_t Duct1_R;
  int16_t Duct2_F;
  int16_t Duct2_R;
  int16_t Duct3_F;
  int16_t Duct3_R;
  int16_t Duct4_F;
  int16_t Duct4_R;
  int16_t Duct5_F;
  int16_t Duct6_F;
  int16_t rtb_LVL;
  int16_t rtb_Saturation_n;
  uint16_t Merge[9];
  uint16_t rtb_out_ic[9];
  uint16_t rtb_out_k4[9];
  uint16_t rtb_out_mj[9];
  uint16_t rtb_vals_m[9];
  uint16_t rtb_out_kw[6];
  uint16_t rtb_urear[6];
  uint16_t rtb_out_f0[2];
  uint16_t rtb_out_b;
  uint16_t rtb_out_em;
  uint16_t rtb_out_jv;
  uint16_t rtb_out_khw;
  uint16_t rtb_out_le;
  uint16_t rtb_out_m4;
  uint16_t rtb_out_pb;
  uint16_t rtb_out_pf;
  int8_t rtb_Switch_nyq;
  uint8_t rtb_get_modes_for_levels[78];
  uint8_t Actuator_pos_percent_Ch1[9];
  uint8_t rtb_DataTypeConversion_bh[9];
  uint8_t rtb_DataTypeConversion_bq[9];
  uint8_t rtb_DataTypeConversion_fb[9];
  uint8_t rtb_DataTypeConversion2_l3[6];
  uint8_t Autodefog;
  uint8_t Dtg_FUR;
  uint8_t El_window_heating;
  uint8_t Mode_FR;
  uint8_t rtb_Merge_a;
  uint8_t rtb_Merge_e;
  uint8_t rtb_Merge_j;
  uint8_t rtb_Merge_m;
  bool rtb_LogicalOperator3_i5[9];
  bool rtb_Compare_n[8];
  bool rtb_LogicalOperator3_n1[6];
  bool rtb_Compare;
  bool rtb_Compare_a;
  bool rtb_Compare_bp;
  bool rtb_Compare_bt;
  bool rtb_Compare_e;
  bool rtb_Compare_e1;
  bool rtb_Compare_eo;
  bool rtb_Compare_esy;
  bool rtb_Compare_fr;
  bool rtb_Compare_gg;
  bool rtb_Compare_gh;
  bool rtb_Compare_ho;
  bool rtb_Compare_it;
  bool rtb_Compare_j4;
  bool rtb_Compare_jf;
  bool rtb_Compare_lus;
  bool rtb_Compare_m4;
  bool rtb_Compare_mk;
  bool rtb_Compare_mt;
  bool rtb_Compare_ne;
  bool rtb_Compare_of;
  bool rtb_Compare_p;
  bool rtb_FailCond_b;
  bool rtb_FailCond_fj;
  bool rtb_FailCond_kk;
  bool rtb_FailCond_n;
  bool rtb_LogicalOperator1;
  bool rtb_LogicalOperator10;
  bool rtb_LogicalOperator11;
  bool rtb_LogicalOperator1_dv;
  bool rtb_LogicalOperator1_l;
  bool rtb_LogicalOperator1_n;
  bool rtb_LogicalOperator3_cz;
  bool rtb_LogicalOperator3_p0;
  bool rtb_LogicalOperator4_fo;
  bool rtb_LogicalOperator6;
  bool rtb_LogicalOperator8;
  bool rtb_RelationalOperator2_nm;

  /* RelationalOperator: '<S1>/Relational Operator1' incorporates:
   *  UnitDelay: '<S1>/Unit Delay'
   */
  rtb_RelationalOperator2_nm = (rtDW.UnitDelay_DSTATE_d5 == -9999);

  /* DataStoreRead: '<Root>/Data Store Read14' incorporates:
   *  UnitDelay: '<S1>/Unit Delay'
   */
  rtDW.UnitDelay_DSTATE_d5 = rtDW.AMB_RAW;

  /* If: '<S1>/If' */
  if (rtb_RelationalOperator2_nm) {
    /* Outputs for IfAction SubSystem: '<S1>/Инициализация температуры' incorporates:
     *  ActionPort: '<S11>/Action Port'
     */
    /* Switch: '<S16>/Switch1' incorporates:
     *  DataStoreWrite: '<S11>/Data Store Write'
     *  DataTypeConversion: '<S11>/Data Type Conversion'
     *  UnitDelay: '<S1>/Unit Delay'
     */
    rtDW.AMB_store = rtDW.UnitDelay_DSTATE_d5;

    /* End of Outputs for SubSystem: '<S1>/Инициализация температуры' */
  } else {
    /* Outputs for IfAction SubSystem: '<S1>/Фильтрация температуры' incorporates:
     *  ActionPort: '<S12>/Action Port'
     */
    /* Lookup_n-D: '<S12>/Get LVL for temp' incorporates:
     *  DataStoreRead: '<Root>/Data Store Read14'
     *  UnitDelay: '<S1>/Unit Delay'
     */
    rtb_LVL = rtConstP.pooled40[plook_u32s16_bincka(rtDW.UnitDelay_DSTATE_d5,
      rtConstP.GetLVLfortemp_bp01Data, 5U)];

    /* If: '<S84>/If1' incorporates:
     *  DataStoreRead: '<S84>/Data Store Read'
     *  UnitDelay: '<S1>/Unit Delay'
     */
    if (rtDW.KEEP_RISING_UNTIL_LIMIT > 0.0) {
      /* Outputs for IfAction SubSystem: '<S84>/включен ускоренный режим' incorporates:
       *  ActionPort: '<S97>/Action Port'
       */
      u_h(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_j, &rtDW.AMB_store,
          &rtDW.KEEP_RISING_UNTIL_LIMIT);

      /* End of Outputs for SubSystem: '<S84>/включен ускоренный режим' */
    } else {
      /* Outputs for IfAction SubSystem: '<S84>/обычный режим' incorporates:
       *  ActionPort: '<S98>/Action Port'
       */
      u_a(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_j, &rtDW.AMB_store,
          &rtDW.KEEP_RISING_UNTIL_LIMIT);

      /* End of Outputs for SubSystem: '<S84>/обычный режим' */
    }

    /* End of If: '<S84>/If1' */

    /* If: '<S83>/If1' incorporates:
     *  DataStoreRead: '<S83>/Data Store Read'
     *  UnitDelay: '<S1>/Unit Delay'
     */
    if (rtDW.KEEP_FALLING_UNTIL_LIMIT > 0.0) {
      /* Outputs for IfAction SubSystem: '<S83>/включен ускоренный режим' incorporates:
       *  ActionPort: '<S85>/Action Port'
       */
      u_d(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_e, &rtDW.AMB_store,
          &rtDW.KEEP_FALLING_UNTIL_LIMIT);

      /* End of Outputs for SubSystem: '<S83>/включен ускоренный режим' */
    } else {
      /* Outputs for IfAction SubSystem: '<S83>/обычный режим' incorporates:
       *  ActionPort: '<S86>/Action Port'
       */
      u_c(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_e, &rtDW.AMB_store,
          &rtDW.KEEP_FALLING_UNTIL_LIMIT);

      /* End of Outputs for SubSystem: '<S83>/обычный режим' */
    }

    /* End of If: '<S83>/If1' */

    /* Sum: '<S13>/Subtract' incorporates:
     *  DataStoreRead: '<Root>/Data Store Read15'
     *  UnitDelay: '<S13>/Unit Delay'
     */
    rtb_Subtract = rtDW.t_now - rtDW.UnitDelay_DSTATE_c;

    /* If: '<S17>/If' incorporates:
     *  DataStoreRead: '<Root>/Data Store Read12'
     *  DataStoreRead: '<S17>/Data Store Read'
     */
    /* :  f_g_ssAMBFILT_WATER = g_ssAMBFILT_WATER; */
    if ((rtDW.VehicleSpeed > 45) && (rtDW.KEEP_UNTIL_SPEED_DROPS > 0)) {
      /* Outputs for IfAction SubSystem: '<S17>/Быстро из-за флага' incorporates:
       *  ActionPort: '<S19>/Action Port'
       */
      /* If: '<S52>/If1' incorporates:
       *  DataStoreRead: '<S52>/Data Store Read'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (rtDW.KEEP_RISING_UNTIL_LIMIT > 0.0) {
        /* Outputs for IfAction SubSystem: '<S52>/включен ускоренный режим' incorporates:
         *  ActionPort: '<S65>/Action Port'
         */
        u_h(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_m, &rtDW.AMB_store,
            &rtDW.KEEP_RISING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S52>/включен ускоренный режим' */
      } else {
        /* Outputs for IfAction SubSystem: '<S52>/обычный режим' incorporates:
         *  ActionPort: '<S66>/Action Port'
         */
        u_a(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_m, &rtDW.AMB_store,
            &rtDW.KEEP_RISING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S52>/обычный режим' */
      }

      /* End of If: '<S52>/If1' */

      /* If: '<S51>/If1' incorporates:
       *  DataStoreRead: '<S51>/Data Store Read'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (rtDW.KEEP_FALLING_UNTIL_LIMIT > 0.0) {
        /* Outputs for IfAction SubSystem: '<S51>/включен ускоренный режим' incorporates:
         *  ActionPort: '<S53>/Action Port'
         */
        u_d(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_a, &rtDW.AMB_store,
            &rtDW.KEEP_FALLING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S51>/включен ускоренный режим' */
      } else {
        /* Outputs for IfAction SubSystem: '<S51>/обычный режим' incorporates:
         *  ActionPort: '<S54>/Action Port'
         */
        u_c(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_a, &rtDW.AMB_store,
            &rtDW.KEEP_FALLING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S51>/обычный режим' */
      }

      /* End of If: '<S51>/If1' */

      /* Switch: '<S49>/Switch1' incorporates:
       *  Abs: '<S50>/Abs'
       *  Constant: '<S50>/epsilon'
       *  DataStoreRead: '<S49>/Read Amb'
       *  RelationalOperator: '<S49>/AMBraw > AMB'
       *  RelationalOperator: '<S50>/Relational Operator'
       *  Sum: '<S50>/Add'
       *  Switch: '<S49>/Switch'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (fabs((double)rtDW.UnitDelay_DSTATE_d5 - rtDW.AMB_store) <= 0.01) {
        /* SignalConversion generated from: '<S19>/AMB_new' */
        rtb_rate = rtDW.AMB_store;
      } else {
        if (rtDW.UnitDelay_DSTATE_d5 > rtDW.AMB_store) {
          /* Switch: '<S49>/Switch' incorporates:
           *  DataTypeConversion: '<S52>/Data Type Conversion'
           */
          rtb_Saturation_n = rtb_Merge_m;
        } else {
          /* Switch: '<S49>/Switch' incorporates:
           *  DataTypeConversion: '<S51>/Data Type Conversion'
           *  UnaryMinus: '<S51>/Unary Minus'
           */
          rtb_Saturation_n = (int16_t)-rtb_Merge_a;
        }

        /* SignalConversion generated from: '<S19>/AMB_new' incorporates:
         *  Constant: '<S49>/Constant'
         *  Product: '<S49>/Divide'
         *  Product: '<S49>/Product'
         *  Sum: '<S49>/Add'
         *  Switch: '<S49>/Switch'
         */
        rtb_rate = (double)rtb_Subtract / 60000.0 * (double)rtb_Saturation_n +
          rtDW.AMB_store;
      }

      /* End of Switch: '<S49>/Switch1' */
      /* End of Outputs for SubSystem: '<S17>/Быстро из-за флага' */
    } else if (rtDW.VehicleSpeed > 50) {
      /* Outputs for IfAction SubSystem: '<S17>/Быстро из-за скорости' incorporates:
       *  ActionPort: '<S18>/Action Port'
       */
      /* DataStoreWrite: '<S18>/Data Store Write' incorporates:
       *  Constant: '<S18>/Constant'
       */
      rtDW.KEEP_UNTIL_SPEED_DROPS = 1;

      /* If: '<S24>/If1' incorporates:
       *  DataStoreRead: '<S24>/Data Store Read'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (rtDW.KEEP_RISING_UNTIL_LIMIT > 0.0) {
        /* Outputs for IfAction SubSystem: '<S24>/включен ускоренный режим' incorporates:
         *  ActionPort: '<S37>/Action Port'
         */
        u_h(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_m, &rtDW.AMB_store,
            &rtDW.KEEP_RISING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S24>/включен ускоренный режим' */
      } else {
        /* Outputs for IfAction SubSystem: '<S24>/обычный режим' incorporates:
         *  ActionPort: '<S38>/Action Port'
         */
        u_a(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_m, &rtDW.AMB_store,
            &rtDW.KEEP_RISING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S24>/обычный режим' */
      }

      /* End of If: '<S24>/If1' */

      /* If: '<S23>/If1' incorporates:
       *  DataStoreRead: '<S23>/Data Store Read'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (rtDW.KEEP_FALLING_UNTIL_LIMIT > 0.0) {
        /* Outputs for IfAction SubSystem: '<S23>/включен ускоренный режим' incorporates:
         *  ActionPort: '<S25>/Action Port'
         */
        u_d(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_a, &rtDW.AMB_store,
            &rtDW.KEEP_FALLING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S23>/включен ускоренный режим' */
      } else {
        /* Outputs for IfAction SubSystem: '<S23>/обычный режим' incorporates:
         *  ActionPort: '<S26>/Action Port'
         */
        u_c(rtDW.UnitDelay_DSTATE_d5, rtb_LVL, &rtb_Merge_a, &rtDW.AMB_store,
            &rtDW.KEEP_FALLING_UNTIL_LIMIT);

        /* End of Outputs for SubSystem: '<S23>/обычный режим' */
      }

      /* End of If: '<S23>/If1' */

      /* Switch: '<S21>/Switch1' incorporates:
       *  Abs: '<S22>/Abs'
       *  Constant: '<S22>/epsilon'
       *  DataStoreRead: '<S21>/Read Amb'
       *  RelationalOperator: '<S21>/AMBraw > AMB'
       *  RelationalOperator: '<S22>/Relational Operator'
       *  Sum: '<S22>/Add'
       *  Switch: '<S21>/Switch'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (fabs((double)rtDW.UnitDelay_DSTATE_d5 - rtDW.AMB_store) <= 0.01) {
        /* SignalConversion generated from: '<S18>/AMB_new' */
        rtb_rate = rtDW.AMB_store;
      } else {
        if (rtDW.UnitDelay_DSTATE_d5 > rtDW.AMB_store) {
          /* Switch: '<S21>/Switch' incorporates:
           *  DataTypeConversion: '<S24>/Data Type Conversion'
           */
          rtb_Saturation_n = rtb_Merge_m;
        } else {
          /* Switch: '<S21>/Switch' incorporates:
           *  DataTypeConversion: '<S23>/Data Type Conversion'
           *  UnaryMinus: '<S23>/Unary Minus'
           */
          rtb_Saturation_n = (int16_t)-rtb_Merge_a;
        }

        /* SignalConversion generated from: '<S18>/AMB_new' incorporates:
         *  Constant: '<S21>/Constant'
         *  Product: '<S21>/Divide'
         *  Product: '<S21>/Product'
         *  Sum: '<S21>/Add'
         *  Switch: '<S21>/Switch'
         */
        rtb_rate = (double)rtb_Subtract / 60000.0 * (double)rtb_Saturation_n +
          rtDW.AMB_store;
      }

      /* End of Switch: '<S21>/Switch1' */
      /* End of Outputs for SubSystem: '<S17>/Быстро из-за скорости' */
    } else {
      /* Outputs for IfAction SubSystem: '<S17>/Медленно' incorporates:
       *  ActionPort: '<S20>/Action Port'
       */
      /* DataStoreWrite: '<S20>/Data Store Write' incorporates:
       *  Constant: '<S20>/Constant1'
       */
      rtDW.KEEP_UNTIL_SPEED_DROPS = 0;

      /* MATLAB Function: '<S79>/границы' */
      /* :  rate_at_10 = 0.5; */
      /* :  rate_at_50 = double(g_aucAMBRATE_RISING(lvl + 1)) ; */
      /* :  f_lower_upper_bounds = [rate_at_10, rate_at_50]; */
      rtb_f_lower_upper_bounds[0] = 0.5;
      i = rtb_LVL + 1;
      if (rtb_LVL + 1 > 32767) {
        i = 32767;
      }

      rtb_f_lower_upper_bounds[1] = g_aucAMBRATE_RISING[i - 1];

      /* MATLAB Function: '<S78>/обычное понижение темп.' */
      /* :  fprintf("lvl = %d\n", lvl); */
      printf("lvl = %d\n", rtb_LVL);
      fflush(stdout);

      /* Switch: '<S20>/Switch1' incorporates:
       *  Abs: '<S77>/Abs'
       *  Constant: '<S20>/Constant'
       *  Constant: '<S77>/epsilon'
       *  DataStoreRead: '<S20>/Read Amb'
       *  Product: '<S20>/Divide'
       *  Product: '<S20>/Product'
       *  RelationalOperator: '<S20>/AMBraw > AMB'
       *  RelationalOperator: '<S77>/Relational Operator'
       *  Sum: '<S20>/Add'
       *  Sum: '<S77>/Add'
       *  Switch: '<S20>/Switch'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      /* :  f_g_aucAMBRATE_FALLING = g_aucAMBRATE_FALLING(lvl + 1); */
      if (fabs((double)rtDW.UnitDelay_DSTATE_d5 - rtDW.AMB_store) <= 0.01) {
        rtb_rate = rtDW.UnitDelay_DSTATE_d5;
      } else {
        if (rtDW.UnitDelay_DSTATE_d5 > rtDW.AMB_store) {
          /* Switch: '<S79>/Скорость >10' incorporates:
           *  Constant: '<S79>/Constant'
           *  Switch: '<S20>/Switch'
           */
          if (rtDW.VehicleSpeed > 10) {
            /* Lookup_n-D: '<S79>/1-D Lookup Table1' incorporates:
             *  DataStoreRead: '<Root>/Data Store Read12'
             */
            rtb_rate = look1_is16td_binlc(rtDW.VehicleSpeed,
              rtConstP.uDLookupTable1_bp01Data, rtb_f_lower_upper_bounds, 1U);
          } else {
            rtb_rate = 0.5;
          }

          /* End of Switch: '<S79>/Скорость >10' */
        } else {
          /* MATLAB Function: '<S78>/обычное понижение темп.' incorporates:
           *  MATLAB Function: '<S79>/границы'
           */
          i = rtb_LVL + 1;
          if (rtb_LVL + 1 > 32767) {
            i = 32767;
          }

          /* Switch: '<S20>/Switch' incorporates:
           *  DataTypeConversion: '<S78>/Data Type Conversion'
           *  MATLAB Function: '<S78>/обычное понижение темп.'
           *  UnaryMinus: '<S78>/Unary Minus'
           */
          rtb_rate = -(double)g_aucAMBRATE_FALLING[i - 1];
        }

        rtb_rate = (double)rtb_Subtract / 60000.0 * rtb_rate + rtDW.AMB_store;
      }

      /* End of Switch: '<S20>/Switch1' */
      /* End of Outputs for SubSystem: '<S17>/Медленно' */
    }

    /* End of If: '<S17>/If' */

    /* Switch: '<S12>/Switch' incorporates:
     *  DataStoreRead: '<Root>/Data Store Read11'
     *  DataStoreRead: '<Root>/Data Store Read12'
     *  MATLAB Function: '<S12>/Coolant temp threshold'
     *  RelationalOperator: '<S12>/Relational Operator'
     *  RelationalOperator: '<S15>/Relational Operator'
     *  Switch: '<S15>/Switch'
     */
    if (rtDW.ECT <= g_ssAMBFILT_WATER) {
      /* Switch: '<S16>/Switch1' incorporates:
       *  Abs: '<S82>/Abs'
       *  Constant: '<S82>/epsilon'
       *  DataStoreRead: '<S16>/Read Amb'
       *  RelationalOperator: '<S82>/Relational Operator'
       *  Sum: '<S82>/Add'
       *  UnitDelay: '<S1>/Unit Delay'
       */
      if (fabs((double)rtDW.UnitDelay_DSTATE_d5 - rtDW.AMB_store) > 0.01) {
        /* Switch: '<S16>/Switch' incorporates:
         *  DataTypeConversion: '<S83>/Data Type Conversion'
         *  DataTypeConversion: '<S84>/Data Type Conversion'
         *  RelationalOperator: '<S16>/AMBraw > AMB'
         *  UnaryMinus: '<S83>/Unary Minus'
         */
        if (rtDW.UnitDelay_DSTATE_d5 > rtDW.AMB_store) {
          rtb_Saturation_n = rtb_Merge_j;
        } else {
          rtb_Saturation_n = (int16_t)-rtb_Merge_e;
        }

        /* Switch: '<S16>/Switch1' incorporates:
         *  Constant: '<S16>/Constant'
         *  Product: '<S16>/Divide'
         *  Product: '<S16>/Product'
         *  Sum: '<S16>/Add'
         *  Switch: '<S16>/Switch'
         */
        rtDW.AMB_store += (double)rtb_Subtract / 60000.0 * (double)
          rtb_Saturation_n;
      }

      /* End of Switch: '<S16>/Switch1' */
    } else if (rtDW.VehicleSpeed != 0) {
      /* Switch: '<S16>/Switch1' incorporates:
       *  DataStoreWrite: '<S12>/Write new AMB'
       *  Switch: '<S15>/Switch'
       */
      rtDW.AMB_store = rtb_rate;
    }

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

    /* Update for UnitDelay: '<S13>/Unit Delay' incorporates:
     *  DataStoreRead: '<Root>/Data Store Read15'
     */
    rtDW.UnitDelay_DSTATE_c = rtDW.t_now;

    /* End of Outputs for SubSystem: '<S1>/Фильтрация температуры' */
  }

  /* End of If: '<S1>/If' */

  /* DataTypeConversion: '<S1>/Data Type Conversion' incorporates:
   *  DataStoreWrite: '<Root>/Data Store Write1'
   */
  rtb_LVL = (int16_t)floor(rtDW.AMB_store);

  /* BusCreator: '<S3>/Bus Creator' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read10'
   *  DataStoreRead: '<S3>/Data Store Read11'
   *  DataStoreRead: '<S3>/Data Store Read4'
   *  DataStoreRead: '<S3>/Data Store Read5'
   *  DataStoreRead: '<S3>/Data Store Read6'
   *  DataStoreRead: '<S3>/Data Store Read7'
   *  DataStoreRead: '<S3>/Data Store Read8'
   *  DataStoreRead: '<S3>/Data Store Read9'
   *  DataStoreWrite: '<S3>/Data Store Write2'
   */
  Status_Sensor_Model.Battery = 0;
  Status_Sensor_Model.AMB = rtb_LVL;
  Status_Sensor_Model.Incar_FL = rtDW.Incar_FL;
  Status_Sensor_Model.Incar_FR = rtDW.Incar_FR;
  Status_Sensor_Model.Incar_RL = rtDW.Incar_RL;
  Status_Sensor_Model.Incar_RR = rtDW.Incar_RR;
  Status_Sensor_Model.Eva_F = rtDW.Eva_F;
  Status_Sensor_Model.Eva_R = rtDW.Eva_R;
  Status_Sensor_Model.Pressure = rtDW.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;

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

  /* RelationalOperator: '<S385>/Compare' incorporates:
   *  Constant: '<S385>/Constant'
   */
  rtb_Compare = (rtb_rate < 0.1);

  /* RelationalOperator: '<S386>/Compare' incorporates:
   *  Constant: '<S386>/Constant'
   */
  rtb_Compare_mk = (rtb_rate > 4.9);

  /* Logic: '<S352>/Logical Operator' */
  rtb_RelationalOperator2_nm = (rtb_Compare || rtb_Compare_mk);

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

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

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

  /* DataStoreWrite: '<S389>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S389>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[12] = rtb_LogicalOperator1;

  /* Switch: '<S389>/Switch' incorporates:
   *  DataTypeConversion: '<S389>/Data Type Conversion'
   *  Switch: '<S389>/Switch1'
   */
  if (rtb_LogicalOperator1) {
    /* DataStoreWrite: '<S389>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S389>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[13] = rtb_Compare;

    /* DataStoreWrite: '<S389>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S389>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[12] = rtb_Compare_mk;
  } else {
    /* DataStoreWrite: '<S389>/Data Store Write' incorporates:
     *  Constant: '<S389>/Constant'
     */
    rtDW.dtc_state_error_model[13] = 0U;
  }

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

  /* MATLAB Function: '<S352>/Write ERROR' incorporates:
   *  DataStoreRead: '<S352>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1) {
    /* :  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_rate);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S352>/Write Eva_F' incorporates:
   *  DataStoreRead: '<S352>/Data Store Read'
   *  DataStoreWrite: '<S352>/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", rtDW.Eva_F);
    fflush(stdout);
  }

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

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

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

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

  /* RelationalOperator: '<S392>/Compare' incorporates:
   *  Constant: '<S392>/Constant'
   */
  rtb_Compare_mk = (rtb_rate < 0.1);

  /* RelationalOperator: '<S393>/Compare' incorporates:
   *  Constant: '<S393>/Constant'
   */
  rtb_Compare_ho = (rtb_rate > 4.9);

  /* Logic: '<S353>/Logical Operator' */
  rtb_Compare = (rtb_Compare_mk || rtb_Compare_ho);

  /* Logic: '<S353>/Logical Operator1' incorporates:
   *  Constant: '<S394>/Constant'
   *  DataStoreRead: '<S395>/Data Store Read4'
   *  RelationalOperator: '<S394>/Compare'
   *  Sum: '<S395>/Subtract'
   *  UnitDelay: '<S395>/t_start_delay_private '
   */
  rtb_LogicalOperator1_dv = (rtb_Compare && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_c >= 3000U));

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

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

  /* DataStoreWrite: '<S396>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S396>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[14] = rtb_LogicalOperator1_dv;

  /* Switch: '<S396>/Switch' incorporates:
   *  DataTypeConversion: '<S396>/Data Type Conversion'
   *  Switch: '<S396>/Switch1'
   */
  if (rtb_LogicalOperator1_dv) {
    /* DataStoreWrite: '<S396>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S396>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[15] = rtb_Compare_mk;

    /* DataStoreWrite: '<S396>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S396>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[14] = rtb_Compare_ho;
  } else {
    /* DataStoreWrite: '<S396>/Data Store Write' incorporates:
     *  Constant: '<S396>/Constant'
     */
    rtDW.dtc_state_error_model[15] = 0U;
  }

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

  /* MATLAB Function: '<S353>/Write ERROR' incorporates:
   *  DataStoreRead: '<S353>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_dv) {
    /* :  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_rate);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S353>/Write Eva_F' incorporates:
   *  DataStoreRead: '<S353>/Data Store Read'
   *  DataStoreWrite: '<S353>/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", rtDW.Eva_R);
    fflush(stdout);
  }

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

  /* Switch: '<S395>/Switch' incorporates:
   *  DataStoreRead: '<S395>/Data Store Read4'
   *  Logic: '<S395>/Logical Operator3'
   *  Logic: '<S395>/Logical Operator4'
   *  UnitDelay: '<S395>/Cond_prev_private '
   *  UnitDelay: '<S395>/t_start_delay_private '
   */
  if (rtb_Compare && (!rtDW.Cond_prev_private_DSTATE_p)) {
    rtDW.t_start_delay_private_DSTATE_c = rtDW.t_now;
  }

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

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

  /* RelationalOperator: '<S414>/Compare' incorporates:
   *  Constant: '<S414>/Constant'
   */
  rtb_Compare_ho = (rtb_rate < 0.1);

  /* RelationalOperator: '<S415>/Compare' incorporates:
   *  Constant: '<S415>/Constant'
   */
  rtb_Compare_it = (rtb_rate > 4.9);

  /* Logic: '<S369>/Logical Operator' */
  rtb_Compare_mk = (rtb_Compare_ho || rtb_Compare_it);

  /* Logic: '<S369>/Logical Operator1' incorporates:
   *  Constant: '<S416>/Constant'
   *  DataStoreRead: '<S417>/Data Store Read4'
   *  RelationalOperator: '<S416>/Compare'
   *  Sum: '<S417>/Subtract'
   *  UnitDelay: '<S417>/t_start_delay_private '
   */
  rtb_LogicalOperator1_n = (rtb_Compare_mk && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_h >= 3000U));

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

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

  /* DataStoreWrite: '<S418>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S418>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[51] = rtb_LogicalOperator1_n;

  /* Switch: '<S418>/Switch' incorporates:
   *  DataTypeConversion: '<S418>/Data Type Conversion'
   *  Switch: '<S418>/Switch1'
   */
  if (rtb_LogicalOperator1_n) {
    /* DataStoreWrite: '<S418>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S418>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[50] = rtb_Compare_ho;

    /* DataStoreWrite: '<S418>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S418>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[51] = rtb_Compare_it;
  } else {
    /* DataStoreWrite: '<S418>/Data Store Write' incorporates:
     *  Constant: '<S418>/Constant'
     */
    rtDW.dtc_state_error_model[50] = 0U;
  }

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

  /* MATLAB Function: '<S369>/Write' incorporates:
   *  DataStoreRead: '<S369>/Data Store Read'
   *  DataStoreWrite: '<S369>/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", rtDW.Pressure);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S369>/Write ERROR' incorporates:
   *  DataStoreRead: '<S369>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_n) {
    /* :  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_rate);
    fflush(stdout);
  }

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

  /* Switch: '<S417>/Switch' incorporates:
   *  DataStoreRead: '<S417>/Data Store Read4'
   *  Logic: '<S417>/Logical Operator3'
   *  Logic: '<S417>/Logical Operator4'
   *  UnitDelay: '<S417>/Cond_prev_private '
   *  UnitDelay: '<S417>/t_start_delay_private '
   */
  if (rtb_Compare_mk && (!rtDW.Cond_prev_private_DSTATE_a)) {
    rtDW.t_start_delay_private_DSTATE_h = rtDW.t_now;
  }

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

  /* Product: '<S370>/Divide4' incorporates:
   *  Constant: '<S370>/Constant1'
   *  Constant: '<S370>/Constant2'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S370>/Divide1'
   */
  rtb_rate = (double)rtDW.ADC_Data_Model.Sensor_Front_Duct2 / 4095.0 * 5.0;

  /* RelationalOperator: '<S421>/Compare' incorporates:
   *  Constant: '<S421>/Constant'
   */
  rtb_Compare_gh = (rtb_rate < 0.15);

  /* RelationalOperator: '<S431>/Compare' incorporates:
   *  Constant: '<S431>/Constant'
   */
  rtb_Compare_j4 = (rtb_rate > 4.9);

  /* Logic: '<S370>/Logical Operator1' */
  rtb_Compare_ho = (rtb_Compare_gh || rtb_Compare_j4);

  /* Logic: '<S370>/Logical Operator4' incorporates:
   *  Constant: '<S435>/Constant'
   *  DataStoreRead: '<S440>/Data Store Read4'
   *  RelationalOperator: '<S435>/Compare'
   *  Sum: '<S440>/Subtract'
   *  UnitDelay: '<S440>/t_start_delay_private '
   */
  rtb_LogicalOperator4_fo = (rtb_Compare_ho && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_m >= 3000U));

  /* SignalConversion generated from: '<S370>/1-D Lookup Table7' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read1'
   */
  rtb_urear[0] = rtDW.ADC_Data_Model.Sensor_Front_Duct1;
  rtb_urear[1] = rtDW.ADC_Data_Model.Sensor_Front_Duct2;
  rtb_urear[2] = rtDW.ADC_Data_Model.Sensor_Front_Duct3;
  rtb_urear[3] = rtDW.ADC_Data_Model.Sensor_Front_Duct4;
  rtb_urear[4] = rtDW.ADC_Data_Model.Sensor_Front_Duct5;
  rtb_urear[5] = rtDW.ADC_Data_Model.Sensor_Front_Duct6;

  /* Lookup_n-D: '<S370>/1-D Lookup Table7' */
  for (i = 0; i < 6; i++) {
    rtb_uDLookupTable7[i] = look1_iu16bs16lu64n32ts16Ds32_binlcs(rtb_urear[i],
      rtConstP.pooled46, rtConstP.pooled45, 1023U);
  }

  /* End of Lookup_n-D: '<S370>/1-D Lookup Table7' */

  /* Switch: '<S370>/Switch2' incorporates:
   *  Constant: '<S370>/Constant6'
   *  DataStoreWrite: '<S370>/Data Store Write1'
   */
  if (rtb_LogicalOperator4_fo) {
    Duct2_F = 230;
  } else {
    Duct2_F = rtb_uDLookupTable7[1];
  }

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

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

  /* RelationalOperator: '<S432>/Compare' incorporates:
   *  Constant: '<S432>/Constant'
   */
  rtb_Compare_ne = (rtb_Divide3 < 0.15);

  /* RelationalOperator: '<S433>/Compare' incorporates:
   *  Constant: '<S433>/Constant'
   */
  rtb_Compare_e = (rtb_Divide3 > 4.9);

  /* Logic: '<S370>/Logical Operator2' */
  rtb_Compare_it = (rtb_Compare_ne || rtb_Compare_e);

  /* Logic: '<S370>/Logical Operator3' incorporates:
   *  Constant: '<S434>/Constant'
   *  DataStoreRead: '<S439>/Data Store Read4'
   *  RelationalOperator: '<S434>/Compare'
   *  Sum: '<S439>/Subtract'
   *  UnitDelay: '<S439>/t_start_delay_private '
   */
  rtb_LogicalOperator3_cz = (rtb_Compare_it && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_k >= 3000U));

  /* Switch: '<S370>/Switch1' incorporates:
   *  Constant: '<S370>/Constant5'
   *  DataStoreWrite: '<S370>/Data Store Write2'
   */
  if (rtb_LogicalOperator3_cz) {
    Duct1_F = 230;
  } else {
    Duct1_F = rtb_uDLookupTable7[0];
  }

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

  /* Product: '<S370>/Divide6' incorporates:
   *  Constant: '<S370>/Constant7'
   *  Constant: '<S370>/Constant8'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S370>/Divide5'
   */
  rtb_Divide6 = (double)rtDW.ADC_Data_Model.Sensor_Front_Duct3 / 4095.0 * 5.0;

  /* RelationalOperator: '<S436>/Compare' incorporates:
   *  Constant: '<S436>/Constant'
   */
  rtb_Compare_gg = (rtb_Divide6 < 0.15);

  /* RelationalOperator: '<S437>/Compare' incorporates:
   *  Constant: '<S437>/Constant'
   */
  rtb_Compare_m4 = (rtb_Divide6 > 4.9);

  /* Logic: '<S370>/Logical Operator5' */
  rtb_FailCond_n = (rtb_Compare_gg || rtb_Compare_m4);

  /* Logic: '<S370>/Logical Operator6' incorporates:
   *  Constant: '<S438>/Constant'
   *  DataStoreRead: '<S441>/Data Store Read4'
   *  RelationalOperator: '<S438>/Compare'
   *  Sum: '<S441>/Subtract'
   *  UnitDelay: '<S441>/t_start_delay_private '
   */
  rtb_LogicalOperator6 = (rtb_FailCond_n && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_p >= 3000U));

  /* Switch: '<S370>/Switch3' incorporates:
   *  Constant: '<S370>/Constant9'
   *  DataStoreWrite: '<S370>/Data Store Write3'
   */
  if (rtb_LogicalOperator6) {
    Duct3_F = 230;
  } else {
    Duct3_F = rtb_uDLookupTable7[2];
  }

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

  /* Product: '<S370>/Divide8' incorporates:
   *  Constant: '<S370>/Constant10'
   *  Constant: '<S370>/Constant11'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S370>/Divide7'
   */
  rtb_Divide8 = (double)rtDW.ADC_Data_Model.Sensor_Front_Duct4 / 4095.0 * 5.0;

  /* RelationalOperator: '<S422>/Compare' incorporates:
   *  Constant: '<S422>/Constant'
   */
  rtb_Compare_lus = (rtb_Divide8 < 0.15);

  /* RelationalOperator: '<S423>/Compare' incorporates:
   *  Constant: '<S423>/Constant'
   */
  rtb_Compare_e1 = (rtb_Divide8 > 4.9);

  /* Logic: '<S370>/Logical Operator7' */
  rtb_FailCond_b = (rtb_Compare_lus || rtb_Compare_e1);

  /* Logic: '<S370>/Logical Operator8' incorporates:
   *  Constant: '<S424>/Constant'
   *  DataStoreRead: '<S442>/Data Store Read4'
   *  RelationalOperator: '<S424>/Compare'
   *  Sum: '<S442>/Subtract'
   *  UnitDelay: '<S442>/t_start_delay_private '
   */
  rtb_LogicalOperator8 = (rtb_FailCond_b && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_hb >= 3000U));

  /* Switch: '<S370>/Switch4' incorporates:
   *  Constant: '<S370>/Constant12'
   *  DataStoreWrite: '<S370>/Data Store Write4'
   */
  if (rtb_LogicalOperator8) {
    Duct4_F = 230;
  } else {
    Duct4_F = rtb_uDLookupTable7[3];
  }

  /* End of Switch: '<S370>/Switch4' */

  /* Product: '<S370>/Divide10' incorporates:
   *  Constant: '<S370>/Constant13'
   *  Constant: '<S370>/Constant14'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S370>/Divide9'
   */
  rtb_Divide10 = (double)rtDW.ADC_Data_Model.Sensor_Front_Duct5 / 4095.0 * 5.0;

  /* RelationalOperator: '<S425>/Compare' incorporates:
   *  Constant: '<S425>/Constant'
   */
  rtb_Compare_bp = (rtb_Divide10 < 0.15);

  /* RelationalOperator: '<S426>/Compare' incorporates:
   *  Constant: '<S426>/Constant'
   */
  rtb_Compare_bt = (rtb_Divide10 > 4.9);

  /* Logic: '<S370>/Logical Operator9' */
  rtb_FailCond_kk = (rtb_Compare_bp || rtb_Compare_bt);

  /* Logic: '<S370>/Logical Operator10' incorporates:
   *  Constant: '<S427>/Constant'
   *  DataStoreRead: '<S443>/Data Store Read4'
   *  RelationalOperator: '<S427>/Compare'
   *  Sum: '<S443>/Subtract'
   *  UnitDelay: '<S443>/t_start_delay_private '
   */
  rtb_LogicalOperator10 = (rtb_FailCond_kk && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_i >= 3000U));

  /* Switch: '<S370>/Switch5' incorporates:
   *  Constant: '<S370>/Constant15'
   *  DataStoreWrite: '<S370>/Data Store Write5'
   */
  if (rtb_LogicalOperator10) {
    Duct5_F = 230;
  } else {
    Duct5_F = rtb_uDLookupTable7[4];
  }

  /* End of Switch: '<S370>/Switch5' */

  /* Product: '<S370>/Divide11' incorporates:
   *  Constant: '<S370>/Constant16'
   *  Constant: '<S370>/Constant17'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S370>/Divide12'
   */
  rtb_Divide11 = (double)rtDW.ADC_Data_Model.Sensor_Front_Duct6 / 4095.0 * 5.0;

  /* RelationalOperator: '<S428>/Compare' incorporates:
   *  Constant: '<S428>/Constant'
   */
  rtb_Compare_p = (rtb_Divide11 < 0.15);

  /* RelationalOperator: '<S429>/Compare' incorporates:
   *  Constant: '<S429>/Constant'
   */
  rtb_Compare_eo = (rtb_Divide11 > 4.9);

  /* Logic: '<S370>/Logical Operator12' */
  rtb_FailCond_fj = (rtb_Compare_p || rtb_Compare_eo);

  /* Logic: '<S370>/Logical Operator11' incorporates:
   *  Constant: '<S430>/Constant'
   *  DataStoreRead: '<S444>/Data Store Read4'
   *  RelationalOperator: '<S430>/Compare'
   *  Sum: '<S444>/Subtract'
   *  UnitDelay: '<S444>/t_start_delay_private '
   */
  rtb_LogicalOperator11 = (rtb_FailCond_fj && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_cc >= 3000U));

  /* Switch: '<S370>/Switch6' incorporates:
   *  Constant: '<S370>/Constant18'
   *  DataStoreWrite: '<S370>/Data Store Write6'
   */
  if (rtb_LogicalOperator11) {
    Duct6_F = 230;
  } else {
    Duct6_F = rtb_uDLookupTable7[5];
  }

  /* End of Switch: '<S370>/Switch6' */

  /* DataStoreWrite: '<S445>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S445>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[17] = rtb_LogicalOperator3_cz;

  /* Switch: '<S445>/Switch' incorporates:
   *  DataTypeConversion: '<S445>/Data Type Conversion'
   *  Switch: '<S445>/Switch1'
   */
  if (rtb_LogicalOperator3_cz) {
    /* DataStoreWrite: '<S445>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S445>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[18] = rtb_Compare_ne;

    /* DataStoreWrite: '<S445>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S445>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[17] = rtb_Compare_e;
  } else {
    /* DataStoreWrite: '<S445>/Data Store Write' incorporates:
     *  Constant: '<S445>/Constant'
     */
    rtDW.dtc_state_error_model[18] = 0U;
  }

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

  /* DataStoreWrite: '<S446>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S446>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[19] = rtb_LogicalOperator4_fo;

  /* Switch: '<S446>/Switch' incorporates:
   *  DataTypeConversion: '<S446>/Data Type Conversion'
   *  Switch: '<S446>/Switch1'
   */
  if (rtb_LogicalOperator4_fo) {
    /* DataStoreWrite: '<S446>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S446>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[20] = rtb_Compare_gh;

    /* DataStoreWrite: '<S446>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S446>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[19] = rtb_Compare_j4;
  } else {
    /* DataStoreWrite: '<S446>/Data Store Write' incorporates:
     *  Constant: '<S446>/Constant'
     */
    rtDW.dtc_state_error_model[20] = 0U;
  }

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

  /* DataStoreWrite: '<S447>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S447>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[21] = rtb_LogicalOperator6;

  /* Switch: '<S447>/Switch' incorporates:
   *  DataTypeConversion: '<S447>/Data Type Conversion'
   *  Switch: '<S447>/Switch1'
   */
  if (rtb_LogicalOperator6) {
    /* DataStoreWrite: '<S447>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S447>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[22] = rtb_Compare_gg;

    /* DataStoreWrite: '<S447>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S447>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[21] = rtb_Compare_m4;
  } else {
    /* DataStoreWrite: '<S447>/Data Store Write' incorporates:
     *  Constant: '<S447>/Constant'
     */
    rtDW.dtc_state_error_model[22] = 0U;
  }

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

  /* DataStoreWrite: '<S448>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S448>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[23] = rtb_LogicalOperator8;

  /* Switch: '<S448>/Switch' incorporates:
   *  DataTypeConversion: '<S448>/Data Type Conversion'
   *  Switch: '<S448>/Switch1'
   */
  if (rtb_LogicalOperator8) {
    /* DataStoreWrite: '<S448>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S448>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[24] = rtb_Compare_lus;

    /* DataStoreWrite: '<S448>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S448>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[23] = rtb_Compare_e1;
  } else {
    /* DataStoreWrite: '<S448>/Data Store Write' incorporates:
     *  Constant: '<S448>/Constant'
     */
    rtDW.dtc_state_error_model[24] = 0U;
  }

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

  /* DataStoreWrite: '<S449>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S449>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[25] = rtb_LogicalOperator10;

  /* Switch: '<S449>/Switch' incorporates:
   *  DataTypeConversion: '<S449>/Data Type Conversion'
   *  Switch: '<S449>/Switch1'
   */
  if (rtb_LogicalOperator10) {
    /* DataStoreWrite: '<S449>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S449>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[26] = rtb_Compare_bp;

    /* DataStoreWrite: '<S449>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S449>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[25] = rtb_Compare_bt;
  } else {
    /* DataStoreWrite: '<S449>/Data Store Write' incorporates:
     *  Constant: '<S449>/Constant'
     */
    rtDW.dtc_state_error_model[26] = 0U;
  }

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

  /* DataStoreWrite: '<S450>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S450>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[27] = rtb_LogicalOperator11;

  /* Switch: '<S450>/Switch' incorporates:
   *  DataTypeConversion: '<S450>/Data Type Conversion'
   *  Switch: '<S450>/Switch1'
   */
  if (rtb_LogicalOperator11) {
    /* DataStoreWrite: '<S450>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S450>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[28] = rtb_Compare_p;

    /* DataStoreWrite: '<S450>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S450>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[27] = rtb_Compare_eo;
  } else {
    /* DataStoreWrite: '<S450>/Data Store Write' incorporates:
     *  Constant: '<S450>/Constant'
     */
    rtDW.dtc_state_error_model[28] = 0U;
  }

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

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

  /* End of MATLAB Function: '<S370>/Write 1' */

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

  /* End of MATLAB Function: '<S370>/Write 2' */

  /* MATLAB Function: '<S370>/Write 3' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read3'
   *  DataStoreWrite: '<S370>/Data Store Write3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct3_F = %d * 0.1 C\n',Sensor); */
    printf("Duct3_F = %d * 0.1 C\n", Duct3_F);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write 3' */

  /* MATLAB Function: '<S370>/Write 4' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read4'
   *  DataStoreWrite: '<S370>/Data Store Write4'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct4_F = %d * 0.1 C\n',Sensor); */
    printf("Duct4_F = %d * 0.1 C\n", Duct4_F);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write 4' */

  /* MATLAB Function: '<S370>/Write 5' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read5'
   *  DataStoreWrite: '<S370>/Data Store Write5'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct5_F = %d * 0.1 C\n',Sensor); */
    printf("Duct5_F = %d * 0.1 C\n", Duct5_F);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write 5' */

  /* MATLAB Function: '<S370>/Write 6' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read6'
   *  DataStoreWrite: '<S370>/Data Store Write6'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct6_F = %d * 0.1 C\n',Sensor); */
    printf("Duct6_F = %d * 0.1 C\n", Duct6_F);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write 6' */

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

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

  /* MATLAB Function: '<S370>/Write ERROR2' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read2'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator4_fo) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct2_F = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct2_F = %f V\n",
           rtb_rate);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write ERROR2' */

  /* MATLAB Function: '<S370>/Write ERROR3' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator6) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct3_F = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct3_F = %f V\n",
           rtb_Divide6);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write ERROR3' */

  /* MATLAB Function: '<S370>/Write ERROR4' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read4'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator8) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct4_F = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct4_F = %f V\n",
           rtb_Divide8);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write ERROR4' */

  /* MATLAB Function: '<S370>/Write ERROR5' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read5'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator10) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct5_F = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct5_F = %f V\n",
           rtb_Divide10);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write ERROR5' */

  /* MATLAB Function: '<S370>/Write ERROR6' incorporates:
   *  DataStoreRead: '<S370>/Data Store Read6'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator11) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct6_F = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrF_Stat = 0x1 (Failure), Sensor_Duct6_F = %f V\n",
           rtb_Divide11);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S370>/Write ERROR6' */

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

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

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

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

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

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

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

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

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

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

  /* Switch: '<S444>/Switch' incorporates:
   *  DataStoreRead: '<S444>/Data Store Read4'
   *  Logic: '<S444>/Logical Operator3'
   *  Logic: '<S444>/Logical Operator4'
   *  UnitDelay: '<S444>/Cond_prev_private '
   *  UnitDelay: '<S444>/t_start_delay_private '
   */
  if (rtb_FailCond_fj && (!rtDW.Cond_prev_private_DSTATE_cn)) {
    rtDW.t_start_delay_private_DSTATE_cc = rtDW.t_now;
  }

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

  /* Product: '<S377>/Divide5' incorporates:
   *  Constant: '<S377>/Constant6'
   *  Constant: '<S377>/Constant7'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S377>/Divide4'
   */
  rtb_rate = (double)rtDW.ADC_Data_Model.Sensor_Rear_Duct3 / 4095.0 * 5.0;

  /* RelationalOperator: '<S477>/Compare' incorporates:
   *  Constant: '<S477>/Constant'
   */
  rtb_Compare_gg = (rtb_rate < 0.15);

  /* RelationalOperator: '<S478>/Compare' incorporates:
   *  Constant: '<S478>/Constant'
   */
  rtb_Compare_m4 = (rtb_rate > 4.9);

  /* Logic: '<S377>/Logical Operator5' */
  rtb_Compare_gh = (rtb_Compare_gg || rtb_Compare_m4);

  /* Logic: '<S377>/Logical Operator6' incorporates:
   *  Constant: '<S479>/Constant'
   *  DataStoreRead: '<S483>/Data Store Read4'
   *  RelationalOperator: '<S479>/Compare'
   *  Sum: '<S483>/Subtract'
   *  UnitDelay: '<S483>/t_start_delay_private '
   */
  rtb_Compare_bp = (rtb_Compare_gh && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_cd >= 3000U));

  /* Switch: '<S377>/Switch2' incorporates:
   *  Constant: '<S377>/Constant8'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write1'
   *  Lookup_n-D: '<S377>/1-D Lookup Table4'
   *  SignalConversion generated from: '<S377>/1-D Lookup Table4'
   */
  if (rtb_Compare_bp) {
    Duct1_R = 230;
  } else {
    Duct1_R = look1_iu16bs16lu64n32ts16Ds32_binlcs
      (rtDW.ADC_Data_Model.Sensor_Rear_Duct3, rtConstP.pooled46,
       rtConstP.pooled45, 1023U);
  }

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

  /* Product: '<S377>/Divide7' incorporates:
   *  Constant: '<S377>/Constant10'
   *  Constant: '<S377>/Constant9'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S377>/Divide6'
   */
  rtb_Divide3 = (double)rtDW.ADC_Data_Model.Sensor_Rear_Duct4 / 4095.0 * 5.0;

  /* RelationalOperator: '<S480>/Compare' incorporates:
   *  Constant: '<S480>/Constant'
   */
  rtb_Compare_lus = (rtb_Divide3 < 0.15);

  /* RelationalOperator: '<S471>/Compare' incorporates:
   *  Constant: '<S471>/Constant'
   */
  rtb_Compare_e1 = (rtb_Divide3 > 4.9);

  /* Logic: '<S377>/Logical Operator7' */
  rtb_Compare_j4 = (rtb_Compare_lus || rtb_Compare_e1);

  /* Logic: '<S377>/Logical Operator8' incorporates:
   *  Constant: '<S472>/Constant'
   *  DataStoreRead: '<S484>/Data Store Read4'
   *  RelationalOperator: '<S472>/Compare'
   *  Sum: '<S484>/Subtract'
   *  UnitDelay: '<S484>/t_start_delay_private '
   */
  rtb_Compare_bt = (rtb_Compare_j4 && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_o >= 3000U));

  /* Switch: '<S377>/Switch3' incorporates:
   *  Constant: '<S377>/Constant11'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write2'
   *  Lookup_n-D: '<S377>/1-D Lookup Table4'
   *  SignalConversion generated from: '<S377>/1-D Lookup Table4'
   */
  if (rtb_Compare_bt) {
    Duct2_R = 230;
  } else {
    Duct2_R = look1_iu16bs16lu64n32ts16Ds32_binlcs
      (rtDW.ADC_Data_Model.Sensor_Rear_Duct4, rtConstP.pooled46,
       rtConstP.pooled45, 1023U);
  }

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

  /* Product: '<S377>/Divide1' incorporates:
   *  Constant: '<S377>/Constant'
   *  Constant: '<S377>/Constant1'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S377>/Divide'
   */
  rtb_Divide6 = (double)rtDW.ADC_Data_Model.Sensor_Rear_Duct1 / 4095.0 * 5.0;

  /* RelationalOperator: '<S469>/Compare' incorporates:
   *  Constant: '<S469>/Constant'
   */
  rtb_Compare_mt = (rtb_Divide6 < 0.15);

  /* RelationalOperator: '<S470>/Compare' incorporates:
   *  Constant: '<S470>/Constant'
   */
  rtb_Compare_fr = (rtb_Divide6 > 4.9);

  /* Logic: '<S377>/Logical Operator' */
  rtb_Compare_ne = (rtb_Compare_mt || rtb_Compare_fr);

  /* Logic: '<S377>/Logical Operator1' incorporates:
   *  Constant: '<S473>/Constant'
   *  DataStoreRead: '<S481>/Data Store Read4'
   *  RelationalOperator: '<S473>/Compare'
   *  Sum: '<S481>/Subtract'
   *  UnitDelay: '<S481>/t_start_delay_private '
   */
  rtb_Compare_p = (rtb_Compare_ne && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_oj >= 3000U));

  /* Switch: '<S377>/Switch' incorporates:
   *  Constant: '<S377>/Constant2'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write3'
   *  Lookup_n-D: '<S377>/1-D Lookup Table4'
   *  SignalConversion generated from: '<S377>/1-D Lookup Table4'
   */
  if (rtb_Compare_p) {
    Duct3_R = 230;
  } else {
    Duct3_R = look1_iu16bs16lu64n32ts16Ds32_binlcs
      (rtDW.ADC_Data_Model.Sensor_Rear_Duct1, rtConstP.pooled46,
       rtConstP.pooled45, 1023U);
  }

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

  /* Product: '<S377>/Divide3' incorporates:
   *  Constant: '<S377>/Constant3'
   *  Constant: '<S377>/Constant4'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S377>/Divide2'
   */
  rtb_Divide8 = (double)rtDW.ADC_Data_Model.Sensor_Rear_Duct2 / 4095.0 * 5.0;

  /* RelationalOperator: '<S474>/Compare' incorporates:
   *  Constant: '<S474>/Constant'
   */
  rtb_Compare_jf = (rtb_Divide8 < 0.15);

  /* RelationalOperator: '<S475>/Compare' incorporates:
   *  Constant: '<S475>/Constant'
   */
  rtb_Compare_of = (rtb_Divide8 > 4.9);

  /* Logic: '<S377>/Logical Operator2' */
  rtb_Compare_e = (rtb_Compare_jf || rtb_Compare_of);

  /* Logic: '<S377>/Logical Operator3' incorporates:
   *  Constant: '<S476>/Constant'
   *  DataStoreRead: '<S482>/Data Store Read4'
   *  RelationalOperator: '<S476>/Compare'
   *  Sum: '<S482>/Subtract'
   *  UnitDelay: '<S482>/t_start_delay_private '
   */
  rtb_Compare_eo = (rtb_Compare_e && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_oy >= 3000U));

  /* Switch: '<S377>/Switch1' incorporates:
   *  Constant: '<S377>/Constant5'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write4'
   *  Lookup_n-D: '<S377>/1-D Lookup Table4'
   *  SignalConversion generated from: '<S377>/1-D Lookup Table4'
   */
  if (rtb_Compare_eo) {
    Duct4_R = 230;
  } else {
    Duct4_R = look1_iu16bs16lu64n32ts16Ds32_binlcs
      (rtDW.ADC_Data_Model.Sensor_Rear_Duct2, rtConstP.pooled46,
       rtConstP.pooled45, 1023U);
  }

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

  /* DataStoreWrite: '<S485>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S485>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[29] = rtb_Compare_p;

  /* Switch: '<S485>/Switch' incorporates:
   *  DataTypeConversion: '<S485>/Data Type Conversion'
   *  Switch: '<S485>/Switch1'
   */
  if (rtb_Compare_p) {
    /* DataStoreWrite: '<S485>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S485>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[30] = rtb_Compare_mt;

    /* DataStoreWrite: '<S485>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S485>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[29] = rtb_Compare_fr;
  } else {
    /* DataStoreWrite: '<S485>/Data Store Write' incorporates:
     *  Constant: '<S485>/Constant'
     */
    rtDW.dtc_state_error_model[30] = 0U;
  }

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

  /* DataStoreWrite: '<S486>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S486>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[31] = rtb_Compare_eo;

  /* Switch: '<S486>/Switch' incorporates:
   *  DataTypeConversion: '<S486>/Data Type Conversion'
   *  Switch: '<S486>/Switch1'
   */
  if (rtb_Compare_eo) {
    /* DataStoreWrite: '<S486>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S486>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[32] = rtb_Compare_jf;

    /* DataStoreWrite: '<S486>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S486>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[31] = rtb_Compare_of;
  } else {
    /* DataStoreWrite: '<S486>/Data Store Write' incorporates:
     *  Constant: '<S486>/Constant'
     */
    rtDW.dtc_state_error_model[32] = 0U;
  }

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

  /* DataStoreWrite: '<S487>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S487>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[33] = rtb_Compare_bp;

  /* Switch: '<S487>/Switch' incorporates:
   *  DataTypeConversion: '<S487>/Data Type Conversion'
   *  Switch: '<S487>/Switch1'
   */
  if (rtb_Compare_bp) {
    /* DataStoreWrite: '<S487>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S487>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[34] = rtb_Compare_gg;

    /* DataStoreWrite: '<S487>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S487>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[33] = rtb_Compare_m4;
  } else {
    /* DataStoreWrite: '<S487>/Data Store Write' incorporates:
     *  Constant: '<S487>/Constant'
     */
    rtDW.dtc_state_error_model[34] = 0U;
  }

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

  /* DataStoreWrite: '<S488>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S488>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[35] = rtb_Compare_bt;

  /* Switch: '<S488>/Switch' incorporates:
   *  DataTypeConversion: '<S488>/Data Type Conversion'
   *  Switch: '<S488>/Switch1'
   */
  if (rtb_Compare_bt) {
    /* DataStoreWrite: '<S488>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S488>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[36] = rtb_Compare_lus;

    /* DataStoreWrite: '<S488>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S488>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[35] = rtb_Compare_e1;
  } else {
    /* DataStoreWrite: '<S488>/Data Store Write' incorporates:
     *  Constant: '<S488>/Constant'
     */
    rtDW.dtc_state_error_model[36] = 0U;
  }

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

  /* MATLAB Function: '<S377>/Write ' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct1_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
    rtb_out_b = rtDW.ADC_Data_Model.Sensor_Rear_Duct1;
    if (rtDW.ADC_Data_Model.Sensor_Rear_Duct1 > 32767) {
      rtb_out_b = 32767U;
    }

    printf("Duct1_R = %d * 0.1 C %d V\n", Duct3_R, (int16_t)rtb_out_b);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S377>/Write 1' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read1'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write4'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct2_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
    rtb_out_b = rtDW.ADC_Data_Model.Sensor_Rear_Duct2;
    if (rtDW.ADC_Data_Model.Sensor_Rear_Duct2 > 32767) {
      rtb_out_b = 32767U;
    }

    printf("Duct2_R = %d * 0.1 C %d V\n", Duct4_R, (int16_t)rtb_out_b);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S377>/Write 1' */

  /* MATLAB Function: '<S377>/Write 2' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read2'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write1'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct3_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
    rtb_out_b = rtDW.ADC_Data_Model.Sensor_Rear_Duct3;
    if (rtDW.ADC_Data_Model.Sensor_Rear_Duct3 > 32767) {
      rtb_out_b = 32767U;
    }

    printf("Duct3_R = %d * 0.1 C %d V\n", Duct1_R, (int16_t)rtb_out_b);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S377>/Write 2' */

  /* MATLAB Function: '<S377>/Write 3' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read3'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  DataStoreWrite: '<S377>/Data Store Write2'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_ACP != 0.0) {
    /* :  fprintf('Duct4_R = %d * 0.1 C %d V\n',Sensor, int16(V)); */
    rtb_out_b = rtDW.ADC_Data_Model.Sensor_Rear_Duct4;
    if (rtDW.ADC_Data_Model.Sensor_Rear_Duct4 > 32767) {
      rtb_out_b = 32767U;
    }

    printf("Duct4_R = %d * 0.1 C %d V\n", Duct2_R, (int16_t)rtb_out_b);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S377>/Write 3' */

  /* MATLAB Function: '<S377>/Write ERROR' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_Compare_p) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct1_R = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct1_R = %f V\n",
           rtb_Divide6);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S377>/Write ERROR1' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read1'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_Compare_eo) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct2_R = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct2_R = %f V\n",
           rtb_Divide8);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S377>/Write ERROR2' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read2'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_Compare_bp) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct3_R = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct3_R = %f V\n",
           rtb_rate);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S377>/Write ERROR2' */

  /* MATLAB Function: '<S377>/Write ERROR3' incorporates:
   *  DataStoreRead: '<S377>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_Compare_bt) {
    /* :  if(Err) */
    /* :  fprintf('CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct4_R = %f V\n',Sensor); */
    printf("CCU_Body_Err.CCU_DuctTempSenErrR_Stat = 0x1 (Failure), Sensor_Duct4_R = %f V\n",
           rtb_Divide3);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S377>/Write ERROR3' */

  /* Switch: '<S481>/Switch' incorporates:
   *  DataStoreRead: '<S481>/Data Store Read4'
   *  Logic: '<S481>/Logical Operator3'
   *  Logic: '<S481>/Logical Operator4'
   *  UnitDelay: '<S481>/Cond_prev_private '
   *  UnitDelay: '<S481>/t_start_delay_private '
   */
  if (rtb_Compare_ne && (!rtDW.Cond_prev_private_DSTATE_l)) {
    rtDW.t_start_delay_private_DSTATE_oj = rtDW.t_now;
  }

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

  /* Switch: '<S482>/Switch' incorporates:
   *  DataStoreRead: '<S482>/Data Store Read4'
   *  Logic: '<S482>/Logical Operator3'
   *  Logic: '<S482>/Logical Operator4'
   *  UnitDelay: '<S482>/Cond_prev_private '
   *  UnitDelay: '<S482>/t_start_delay_private '
   */
  if (rtb_Compare_e && (!rtDW.Cond_prev_private_DSTATE_ja)) {
    rtDW.t_start_delay_private_DSTATE_oy = rtDW.t_now;
  }

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

  /* Switch: '<S483>/Switch' incorporates:
   *  DataStoreRead: '<S483>/Data Store Read4'
   *  Logic: '<S483>/Logical Operator3'
   *  Logic: '<S483>/Logical Operator4'
   *  UnitDelay: '<S483>/Cond_prev_private '
   *  UnitDelay: '<S483>/t_start_delay_private '
   */
  if (rtb_Compare_gh && (!rtDW.Cond_prev_private_DSTATE_g)) {
    rtDW.t_start_delay_private_DSTATE_cd = rtDW.t_now;
  }

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

  /* Switch: '<S484>/Switch' incorporates:
   *  DataStoreRead: '<S484>/Data Store Read4'
   *  Logic: '<S484>/Logical Operator3'
   *  Logic: '<S484>/Logical Operator4'
   *  UnitDelay: '<S484>/Cond_prev_private '
   *  UnitDelay: '<S484>/t_start_delay_private '
   */
  if (rtb_Compare_j4 && (!rtDW.Cond_prev_private_DSTATE_cd)) {
    rtDW.t_start_delay_private_DSTATE_o = rtDW.t_now;
  }

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

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

  /* RelationalOperator: '<S497>/Compare' incorporates:
   *  Constant: '<S497>/Constant'
   */
  rtb_Compare_lus = (rtb_rate < 0.15);

  /* RelationalOperator: '<S498>/Compare' incorporates:
   *  Constant: '<S498>/Constant'
   */
  rtb_Compare_e1 = (rtb_rate > 4.9);

  /* Logic: '<S378>/Logical Operator' */
  rtb_Compare_gg = (rtb_Compare_lus || rtb_Compare_e1);

  /* Logic: '<S378>/Logical Operator1' incorporates:
   *  Constant: '<S499>/Constant'
   *  DataStoreRead: '<S503>/Data Store Read4'
   *  RelationalOperator: '<S499>/Compare'
   *  Sum: '<S503>/Subtract'
   *  UnitDelay: '<S503>/t_start_delay_private '
   */
  rtb_Compare_mt = (rtb_Compare_gg && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_g >= 3000U));

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

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

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

  /* RelationalOperator: '<S500>/Compare' incorporates:
   *  Constant: '<S500>/Constant'
   */
  rtb_Compare_jf = (rtb_Divide3 < 0.15);

  /* RelationalOperator: '<S501>/Compare' incorporates:
   *  Constant: '<S501>/Constant'
   */
  rtb_Compare_of = (rtb_Divide3 > 4.9);

  /* Logic: '<S378>/Logical Operator2' */
  rtb_Compare_m4 = (rtb_Compare_jf || rtb_Compare_of);

  /* Logic: '<S378>/Logical Operator3' incorporates:
   *  Constant: '<S502>/Constant'
   *  DataStoreRead: '<S504>/Data Store Read4'
   *  RelationalOperator: '<S502>/Compare'
   *  Sum: '<S504>/Subtract'
   *  UnitDelay: '<S504>/t_start_delay_private '
   */
  rtb_Compare_fr = (rtb_Compare_m4 && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_j >= 3000U));

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

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

  /* DataStoreWrite: '<S505>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S505>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[2] = rtb_Compare_mt;

  /* Switch: '<S505>/Switch' incorporates:
   *  DataTypeConversion: '<S505>/Data Type Conversion'
   *  Switch: '<S505>/Switch1'
   */
  if (rtb_Compare_mt) {
    /* DataStoreWrite: '<S505>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S505>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[3] = rtb_Compare_lus;

    /* DataStoreWrite: '<S505>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S505>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[2] = rtb_Compare_e1;
  } else {
    /* DataStoreWrite: '<S505>/Data Store Write' incorporates:
     *  Constant: '<S505>/Constant'
     */
    rtDW.dtc_state_error_model[3] = 0U;
  }

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

  /* DataStoreWrite: '<S506>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S506>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[6] = rtb_Compare_fr;

  /* Switch: '<S506>/Switch' incorporates:
   *  DataTypeConversion: '<S506>/Data Type Conversion'
   *  Switch: '<S506>/Switch1'
   */
  if (rtb_Compare_fr) {
    /* DataStoreWrite: '<S506>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S506>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[7] = rtb_Compare_jf;

    /* DataStoreWrite: '<S506>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S506>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[6] = rtb_Compare_of;
  } else {
    /* DataStoreWrite: '<S506>/Data Store Write' incorporates:
     *  Constant: '<S506>/Constant'
     */
    rtDW.dtc_state_error_model[7] = 0U;
  }

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

  /* MATLAB Function: '<S378>/Write ERROR' incorporates:
   *  DataStoreRead: '<S378>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_Compare_mt) {
    /* :  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_rate);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S378>/Write ERROR1' incorporates:
   *  DataStoreRead: '<S378>/Data Store Read1'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_Compare_fr) {
    /* :  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: '<S378>/Write ERROR1' */

  /* MATLAB Function: '<S378>/Write IncarFL' incorporates:
   *  DataStoreRead: '<S378>/Data Store Read'
   *  DataStoreWrite: '<S378>/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", rtDW.Incar_FL);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S378>/Write IncarRL' incorporates:
   *  DataStoreRead: '<S378>/Data Store Read1'
   *  DataStoreWrite: '<S378>/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", rtDW.Incar_RL);
    fflush(stdout);
  }

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

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

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

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

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

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

  /* RelationalOperator: '<S511>/Compare' incorporates:
   *  Constant: '<S511>/Constant'
   */
  rtb_Compare_jf = (rtb_rate < 0.15);

  /* RelationalOperator: '<S512>/Compare' incorporates:
   *  Constant: '<S512>/Constant'
   */
  rtb_Compare_of = (rtb_rate > 4.9);

  /* Logic: '<S379>/Logical Operator' */
  rtb_Compare_lus = (rtb_Compare_jf || rtb_Compare_of);

  /* Logic: '<S379>/Logical Operator1' incorporates:
   *  Constant: '<S513>/Constant'
   *  DataStoreRead: '<S517>/Data Store Read4'
   *  RelationalOperator: '<S513>/Compare'
   *  Sum: '<S517>/Subtract'
   *  UnitDelay: '<S517>/t_start_delay_private '
   */
  rtb_LogicalOperator1_l = (rtb_Compare_lus && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_kw >= 3000U));

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

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

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

  /* RelationalOperator: '<S514>/Compare' incorporates:
   *  Constant: '<S514>/Constant'
   */
  rtb_Compare_esy = (rtb_Divide3 < 0.15);

  /* RelationalOperator: '<S515>/Compare' incorporates:
   *  Constant: '<S515>/Constant'
   */
  rtb_Compare_a = (rtb_Divide3 > 4.9);

  /* Logic: '<S379>/Logical Operator2' */
  rtb_Compare_e1 = (rtb_Compare_esy || rtb_Compare_a);

  /* Logic: '<S379>/Logical Operator3' incorporates:
   *  Constant: '<S516>/Constant'
   *  DataStoreRead: '<S518>/Data Store Read4'
   *  RelationalOperator: '<S516>/Compare'
   *  Sum: '<S518>/Subtract'
   *  UnitDelay: '<S518>/t_start_delay_private '
   */
  rtb_LogicalOperator3_p0 = (rtb_Compare_e1 && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_gd >= 3000U));

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

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

  /* DataStoreWrite: '<S519>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S519>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[4] = rtb_LogicalOperator1_l;

  /* Switch: '<S519>/Switch' incorporates:
   *  DataTypeConversion: '<S519>/Data Type Conversion'
   *  Switch: '<S519>/Switch1'
   */
  if (rtb_LogicalOperator1_l) {
    /* DataStoreWrite: '<S519>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S519>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[5] = rtb_Compare_jf;

    /* DataStoreWrite: '<S519>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S519>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[4] = rtb_Compare_of;
  } else {
    /* DataStoreWrite: '<S519>/Data Store Write' incorporates:
     *  Constant: '<S519>/Constant'
     */
    rtDW.dtc_state_error_model[5] = 0U;
  }

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

  /* DataStoreWrite: '<S520>/Data Store Write1' incorporates:
   *  DataTypeConversion: '<S520>/Data Type Conversion'
   */
  rtDW.dtc_state_error_model[8] = rtb_LogicalOperator3_p0;

  /* Switch: '<S520>/Switch' incorporates:
   *  DataTypeConversion: '<S520>/Data Type Conversion'
   *  Switch: '<S520>/Switch1'
   */
  if (rtb_LogicalOperator3_p0) {
    /* DataStoreWrite: '<S520>/Data Store Write' incorporates:
     *  DataTypeConversion: '<S520>/Data Type Conversion1'
     */
    rtDW.dtc_state_error_model[9] = rtb_Compare_esy;

    /* DataStoreWrite: '<S520>/Data Store Write1' incorporates:
     *  DataTypeConversion: '<S520>/Data Type Conversion2'
     */
    rtDW.dtc_state_error_model[8] = rtb_Compare_a;
  } else {
    /* DataStoreWrite: '<S520>/Data Store Write' incorporates:
     *  Constant: '<S520>/Constant'
     */
    rtDW.dtc_state_error_model[9] = 0U;
  }

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

  /* MATLAB Function: '<S379>/Write ERROR' incorporates:
   *  DataStoreRead: '<S379>/Data Store Read'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator1_l) {
    /* :  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_rate);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S379>/Write ERROR1' incorporates:
   *  DataStoreRead: '<S379>/Data Store Read1'
   */
  /* :  if(LOGGER) */
  if ((rtDW.LOGGER_ACP != 0.0) && rtb_LogicalOperator3_p0) {
    /* :  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: '<S379>/Write ERROR1' */

  /* MATLAB Function: '<S379>/Write IncarFR' incorporates:
   *  DataStoreRead: '<S379>/Data Store Read'
   *  DataStoreWrite: '<S379>/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", rtDW.Incar_FR);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S379>/Write IncarRR' incorporates:
   *  DataStoreRead: '<S379>/Data Store Read1'
   *  DataStoreWrite: '<S379>/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", rtDW.Incar_RR);
    fflush(stdout);
  }

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

  /* Switch: '<S517>/Switch' incorporates:
   *  DataStoreRead: '<S517>/Data Store Read4'
   *  Logic: '<S517>/Logical Operator3'
   *  Logic: '<S517>/Logical Operator4'
   *  UnitDelay: '<S517>/Cond_prev_private '
   *  UnitDelay: '<S517>/t_start_delay_private '
   */
  if (rtb_Compare_lus && (!rtDW.Cond_prev_private_DSTATE_jl)) {
    rtDW.t_start_delay_private_DSTATE_kw = rtDW.t_now;
  }

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

  /* Switch: '<S518>/Switch' incorporates:
   *  DataStoreRead: '<S518>/Data Store Read4'
   *  Logic: '<S518>/Logical Operator3'
   *  Logic: '<S518>/Logical Operator4'
   *  UnitDelay: '<S518>/Cond_prev_private '
   *  UnitDelay: '<S518>/t_start_delay_private '
   */
  if (rtb_Compare_e1 && (!rtDW.Cond_prev_private_DSTATE_ei)) {
    rtDW.t_start_delay_private_DSTATE_gd = rtDW.t_now;
  }

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

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

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

  /* MATLAB Function: '<S354>/Write' incorporates:
   *  Constant: '<S354>/Constant2'
   *  Constant: '<S354>/Constant3'
   *  DataStoreRead: '<S354>/Data Store Read'
   *  Product: '<S354>/Divide2'
   *  Product: '<S354>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S355>/Write' incorporates:
   *  Constant: '<S355>/Constant2'
   *  Constant: '<S355>/Constant3'
   *  DataStoreRead: '<S355>/Data Store Read'
   *  Product: '<S355>/Divide2'
   *  Product: '<S355>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S356>/Write' incorporates:
   *  Constant: '<S356>/Constant2'
   *  Constant: '<S356>/Constant3'
   *  DataStoreRead: '<S356>/Data Store Read'
   *  Product: '<S356>/Divide2'
   *  Product: '<S356>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S357>/Write' incorporates:
   *  Constant: '<S357>/Constant2'
   *  Constant: '<S357>/Constant3'
   *  DataStoreRead: '<S357>/Data Store Read'
   *  Product: '<S357>/Divide2'
   *  Product: '<S357>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S358>/Write' incorporates:
   *  Constant: '<S358>/Constant2'
   *  Constant: '<S358>/Constant3'
   *  DataStoreRead: '<S358>/Data Store Read'
   *  Product: '<S358>/Divide2'
   *  Product: '<S358>/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_rate, rtb_rate
           / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S359>/Write' incorporates:
   *  Constant: '<S359>/Constant2'
   *  Constant: '<S359>/Constant3'
   *  DataStoreRead: '<S359>/Data Store Read'
   *  Product: '<S359>/Divide2'
   *  Product: '<S359>/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_rate, rtb_rate /
           1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S360>/Write' incorporates:
   *  Constant: '<S360>/Constant2'
   *  Constant: '<S360>/Constant3'
   *  DataStoreRead: '<S360>/Data Store Read'
   *  Product: '<S360>/Divide2'
   *  Product: '<S360>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S361>/Write' incorporates:
   *  Constant: '<S361>/Constant2'
   *  Constant: '<S361>/Constant3'
   *  DataStoreRead: '<S361>/Data Store Read'
   *  Product: '<S361>/Divide2'
   *  Product: '<S361>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S362>/Write' incorporates:
   *  Constant: '<S362>/Constant2'
   *  Constant: '<S362>/Constant3'
   *  DataStoreRead: '<S362>/Data Store Read'
   *  Product: '<S362>/Divide2'
   *  Product: '<S362>/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_rate,
           rtb_rate / 1200.0 * 550.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S363>/Write' incorporates:
   *  Constant: '<S363>/Constant2'
   *  Constant: '<S363>/Constant3'
   *  DataStoreRead: '<S363>/Data Store Read'
   *  Product: '<S363>/Divide2'
   *  Product: '<S363>/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_rate, rtb_rate /
           1200.0 * 550.0);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S364>/Write' incorporates:
   *  Constant: '<S364>/Constant'
   *  Constant: '<S364>/Constant1'
   *  DataStoreRead: '<S364>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S364>/Divide'
   *  Product: '<S364>/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: '<S364>/Write' */

  /* MATLAB Function: '<S365>/Write' incorporates:
   *  Constant: '<S365>/Constant'
   *  Constant: '<S365>/Constant1'
   *  DataStoreRead: '<S365>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S365>/Divide'
   *  Product: '<S365>/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: '<S365>/Write' */

  /* MATLAB Function: '<S366>/Write' incorporates:
   *  Constant: '<S366>/Constant'
   *  Constant: '<S366>/Constant1'
   *  DataStoreRead: '<S366>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S366>/Divide'
   *  Product: '<S366>/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: '<S366>/Write' */

  /* MATLAB Function: '<S367>/Write' incorporates:
   *  Constant: '<S367>/Constant'
   *  Constant: '<S367>/Constant1'
   *  DataStoreRead: '<S367>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S367>/Divide'
   *  Product: '<S367>/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: '<S367>/Write' */

  /* MATLAB Function: '<S368>/Write' incorporates:
   *  Constant: '<S368>/Constant'
   *  Constant: '<S368>/Constant1'
   *  DataStoreRead: '<S368>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S368>/Divide'
   *  Product: '<S368>/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: '<S368>/Write' */

  /* MATLAB Function: '<S371>/Write' incorporates:
   *  Constant: '<S371>/Constant'
   *  Constant: '<S371>/Constant1'
   *  DataStoreRead: '<S371>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S371>/Divide'
   *  Product: '<S371>/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_Rear_Duct5 / 4095.0 * 5.0);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S372>/Write' incorporates:
   *  Constant: '<S372>/Constant'
   *  Constant: '<S372>/Constant1'
   *  DataStoreRead: '<S372>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S372>/Divide'
   *  Product: '<S372>/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_Rear_Duct6 / 4095.0 * 5.0);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S373>/Write' incorporates:
   *  Constant: '<S373>/Constant'
   *  Constant: '<S373>/Constant1'
   *  DataStoreRead: '<S373>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S373>/Divide'
   *  Product: '<S373>/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: '<S373>/Write' */

  /* MATLAB Function: '<S374>/Write' incorporates:
   *  Constant: '<S374>/Constant'
   *  Constant: '<S374>/Constant1'
   *  DataStoreRead: '<S374>/Data Store Read'
   *  DataStoreRead: '<S3>/Data Store Read1'
   *  Product: '<S374>/Divide'
   *  Product: '<S374>/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: '<S374>/Write' */

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

  /* MATLAB Function: '<S375>/Write' incorporates:
   *  Constant: '<S375>/Constant2'
   *  Constant: '<S375>/Constant3'
   *  DataStoreRead: '<S375>/Data Store Read'
   *  Product: '<S375>/Divide2'
   *  Product: '<S375>/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_rate,
           rtb_rate / 2490.0 * 5890.0);
    fflush(stdout);
  }

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

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

  /* MATLAB Function: '<S376>/Write' incorporates:
   *  Constant: '<S376>/Constant2'
   *  Constant: '<S376>/Constant3'
   *  DataStoreRead: '<S376>/Data Store Read'
   *  Product: '<S376>/Divide2'
   *  Product: '<S376>/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_rate,
           rtb_rate / 2490.0 * 5890.0);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S3>/Write' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read2'
   *  DataStoreRead: '<S3>/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: '<S3>/Write' */

  /* MATLAB Function: '<S3>/Write1' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read2'
   *  DataStoreRead: '<S3>/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: '<S3>/Write1' */

  /* MATLAB Function: '<S3>/Write2' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read2'
   *  DataStoreRead: '<S3>/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: '<S3>/Write2' */

  /* MATLAB Function: '<S3>/Write3' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read2'
   *  DataStoreRead: '<S3>/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: '<S3>/Write3' */

  /* MATLAB Function: '<S3>/Write4' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read2'
   *  DataStoreRead: '<S3>/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: '<S3>/Write4' */

  /* BusCreator: '<Root>/Bus Creator' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read'
   *  DataStoreRead: '<Root>/Data Store Read2'
   *  DataStoreWrite: '<Root>/Data Store Write'
   *  DataTypeConversion: '<S370>/Data Type Conversion'
   *  DataTypeConversion: '<S377>/Data Type Conversion'
   *  DataTypeConversion: '<S378>/Data Type Conversion'
   *  DataTypeConversion: '<S379>/Data Type Conversion'
   *  DataTypeConversion: '<S389>/Data Type Conversion'
   *  DataTypeConversion: '<S396>/Data Type Conversion'
   *  DataTypeConversion: '<S418>/Data Type Conversion'
   *  Logic: '<S370>/Logical Operator13'
   *  Logic: '<S377>/Logical Operator4'
   *  Logic: '<S378>/Logical Operator4'
   *  Logic: '<S379>/Logical Operator4'
   */
  CCU_Errors_Model.CCU_IncarTempErrF_Stat = (uint8_t)(rtb_Compare_mt ||
    rtb_Compare_fr);
  CCU_Errors_Model.CCU_IncarTempErrR_Stat = (uint8_t)(rtb_LogicalOperator1_l ||
    rtb_LogicalOperator3_p0);
  CCU_Errors_Model.CCU_DuctTempSenErrF_Stat = (uint8_t)(rtb_LogicalOperator3_cz ||
    rtb_LogicalOperator4_fo || rtb_LogicalOperator6 || rtb_LogicalOperator8 ||
    rtb_LogicalOperator10 || rtb_LogicalOperator11);
  CCU_Errors_Model.CCU_DuctTempSenErrR_Stat = (uint8_t)(rtb_Compare_p ||
    rtb_Compare_eo || rtb_Compare_bp || rtb_Compare_bt);
  CCU_Errors_Model.CCU_EvaTempSenErrF_Stat = rtb_LogicalOperator1;
  CCU_Errors_Model.CCU_EvaTempSenErrR_Stat = rtb_LogicalOperator1_dv;
  CCU_Errors_Model.CCU_DeflectorSwErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DeflectorSwErrR_Stat = 0U;
  CCU_Errors_Model.CCU_PressSenErr_Stat = rtb_LogicalOperator1_n;
  CCU_Errors_Model.CCU_AmbienTemptSenErr_Stat = 0U;
  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 = rtDW.CCU_ActuatorErrR_Stat_private;
  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;

  /* Saturate: '<S109>/Saturation' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read'
   */
  if (rtb_LVL > 1000) {
    rtb_Saturation_n = 1000;
  } else if (rtb_LVL < -1000) {
    rtb_Saturation_n = -1000;
  } else {
    rtb_Saturation_n = rtb_LVL;
  }

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

  /* MATLAB Function: '<S109>/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)]; */
  rtb_uDLookupTable7[0] = -1000;
  rtb_uDLookupTable7[1] = g_assAMB_LV_UP[4];
  rtb_uDLookupTable7[2] = g_assAMB_LV_UP[3];
  rtb_uDLookupTable7[3] = g_assAMB_LV_UP[2];
  rtb_uDLookupTable7[4] = g_assAMB_LV_UP[1];
  rtb_uDLookupTable7[5] = g_assAMB_LV_UP[0];

  /* SwitchCase: '<S109>/Switch Case' incorporates:
   *  Lookup_n-D: '<S109>/1-D Lookup Table'
   *  Saturate: '<S109>/Saturation'
   */
  switch ((int8_t)rtConstP.pooled40[plook_u32s16_bincka(rtb_Saturation_n,
           rtb_uDLookupTable7, 5U)]) {
   case 0:
    /* Outputs for IfAction SubSystem: '<S109>/Switch Case Action Subsystem' incorporates:
     *  ActionPort: '<S113>/Action Port'
     */
    /* Merge: '<S109>/Merge' incorporates:
     *  MATLAB Function: '<S113>/Convert_g_assAMB_LV_UP_1'
     *  RelationalOperator: '<S113>/Relational Operator'
     *  Switch: '<S113>/Switch'
     */
    /* :  c_g_assAMB_LV_UP_1 = g_assAMB_LV_UP(1); */
    rtB.Merge_b = (uint8_t)(rtb_Saturation_n <= g_assAMB_LV_UP[0]);

    /* End of Outputs for SubSystem: '<S109>/Switch Case Action Subsystem' */
    break;

   case 1:
    /* Outputs for IfAction SubSystem: '<S109>/Switch Case Action Subsystem1' incorporates:
     *  ActionPort: '<S114>/Action Port'
     */
    /* Switch: '<S114>/Switch' incorporates:
     *  MATLAB Function: '<S114>/Convert_g_assAMB_LV_UP_2'
     *  RelationalOperator: '<S114>/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 (rtb_Saturation_n > g_assAMB_LV_UP[1]) {
      /* Merge: '<S109>/Merge' incorporates:
       *  MATLAB Function: '<S114>/Convert_g_assAMB_LV_DN_1'
       *  RelationalOperator: '<S114>/Relational Operator1'
       */
      rtB.Merge_b = (uint8_t)(rtb_Saturation_n <= g_assAMB_LV_DN[0]);
    } else {
      /* Merge: '<S109>/Merge' incorporates:
       *  Constant: '<S114>/Constant_Lv2'
       */
      rtB.Merge_b = 2U;
    }

    /* End of Switch: '<S114>/Switch' */
    /* End of Outputs for SubSystem: '<S109>/Switch Case Action Subsystem1' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S109>/Switch Case Action Subsystem2' incorporates:
     *  ActionPort: '<S115>/Action Port'
     */
    /* Switch: '<S115>/Switch2' incorporates:
     *  MATLAB Function: '<S115>/Convert_g_assAMB_LV_UP_3'
     *  RelationalOperator: '<S115>/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 (rtb_Saturation_n > g_assAMB_LV_UP[2]) {
      /* Switch: '<S115>/Switch3' incorporates:
       *  MATLAB Function: '<S115>/Convert_g_assAMB_LV_DN_2'
       *  RelationalOperator: '<S115>/Relational Operator1'
       */
      if (rtb_Saturation_n > g_assAMB_LV_DN[1]) {
        /* Merge: '<S109>/Merge' incorporates:
         *  Constant: '<S115>/Constant_Lv1'
         */
        rtB.Merge_b = 1U;
      } else {
        /* Merge: '<S109>/Merge' incorporates:
         *  Constant: '<S115>/Constant_Lv2'
         */
        rtB.Merge_b = 2U;
      }

      /* End of Switch: '<S115>/Switch3' */
    } else {
      /* Merge: '<S109>/Merge' incorporates:
       *  Constant: '<S115>/Constant_Lv3'
       */
      rtB.Merge_b = 3U;
    }

    /* End of Switch: '<S115>/Switch2' */
    /* End of Outputs for SubSystem: '<S109>/Switch Case Action Subsystem2' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S109>/Switch Case Action Subsystem3' incorporates:
     *  ActionPort: '<S116>/Action Port'
     */
    /* Switch: '<S116>/Switch2' incorporates:
     *  MATLAB Function: '<S116>/Convert_g_assAMB_LV_UP_4'
     *  RelationalOperator: '<S116>/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 (rtb_Saturation_n > g_assAMB_LV_UP[3]) {
      /* Switch: '<S116>/Switch3' incorporates:
       *  MATLAB Function: '<S116>/Convert_g_assAMB_LV_DN_3'
       *  RelationalOperator: '<S116>/Relational Operator1'
       */
      if (rtb_Saturation_n > g_assAMB_LV_DN[2]) {
        /* Merge: '<S109>/Merge' incorporates:
         *  Constant: '<S116>/Constant_Lv2'
         */
        rtB.Merge_b = 2U;
      } else {
        /* Merge: '<S109>/Merge' incorporates:
         *  Constant: '<S116>/Constant_Lv3'
         */
        rtB.Merge_b = 3U;
      }

      /* End of Switch: '<S116>/Switch3' */
    } else {
      /* Merge: '<S109>/Merge' incorporates:
       *  Constant: '<S116>/Constant_Lv4'
       */
      rtB.Merge_b = 4U;
    }

    /* End of Switch: '<S116>/Switch2' */
    /* End of Outputs for SubSystem: '<S109>/Switch Case Action Subsystem3' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S109>/Switch Case Action Subsystem4' incorporates:
     *  ActionPort: '<S117>/Action Port'
     */
    /* Switch: '<S117>/Switch2' incorporates:
     *  MATLAB Function: '<S117>/Convert_g_assAMB_LV_UP_5'
     *  RelationalOperator: '<S117>/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 (rtb_Saturation_n > g_assAMB_LV_UP[4]) {
      /* Switch: '<S117>/Switch3' incorporates:
       *  MATLAB Function: '<S117>/Convert_g_assAMB_LV_DN_4'
       *  RelationalOperator: '<S117>/Relational Operator1'
       */
      if (rtb_Saturation_n > g_assAMB_LV_DN[3]) {
        /* Merge: '<S109>/Merge' incorporates:
         *  Constant: '<S117>/Constant_Lv3'
         */
        rtB.Merge_b = 3U;
      } else {
        /* Merge: '<S109>/Merge' incorporates:
         *  Constant: '<S117>/Constant_Lv4'
         */
        rtB.Merge_b = 4U;
      }

      /* End of Switch: '<S117>/Switch3' */
    } else {
      /* Merge: '<S109>/Merge' incorporates:
       *  Constant: '<S117>/Constant_Lv5'
       */
      rtB.Merge_b = 5U;
    }

    /* End of Switch: '<S117>/Switch2' */
    /* End of Outputs for SubSystem: '<S109>/Switch Case Action Subsystem4' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S109>/Switch Case Action Subsystem5' incorporates:
     *  ActionPort: '<S118>/Action Port'
     */
    /* Switch: '<S118>/Switch1' incorporates:
     *  MATLAB Function: '<S118>/Convert_g_assAMB_LV_DN_5'
     *  RelationalOperator: '<S118>/Relational Operator'
     */
    /* :  c_g_assAMB_LV_DN_5 = g_assAMB_LV_DN(5); */
    if (rtb_Saturation_n > g_assAMB_LV_DN[4]) {
      /* Merge: '<S109>/Merge' incorporates:
       *  Constant: '<S118>/Constant_Lv4'
       */
      rtB.Merge_b = 4U;
    } else {
      /* Merge: '<S109>/Merge' incorporates:
       *  Constant: '<S118>/Constant_Lv5'
       */
      rtB.Merge_b = 5U;
    }

    /* End of Switch: '<S118>/Switch1' */
    /* End of Outputs for SubSystem: '<S109>/Switch Case Action Subsystem5' */
    break;
  }

  /* End of SwitchCase: '<S109>/Switch Case' */

  /* Saturate: '<S2>/Saturation' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read1'
   */
  if (rtDW.FIU_SET_FL > 290) {
    i = 290;
  } else if (rtDW.FIU_SET_FL < 170) {
    i = 170;
  } else {
    i = rtDW.FIU_SET_FL;
  }

  /* Gain: '<S110>/Gain' incorporates:
   *  Saturate: '<S2>/Saturation'
   */
  i *= 13107;
  rtb_Merge_j = (uint8_t)((((uint32_t)i & 65536U) != 0U) + (i >> 17));

  /* MATLAB Function: '<S110>/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: '<S110>/Modes for levels' */

  /* Lookup_n-D: '<S110>/Выбор режима Left' incorporates:
   *  Gain: '<S110>/Gain'
   *  Merge: '<S109>/Merge'
   */
  rtb_Merge_m = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Merge_j,
    rtConstP.pooled86, rtConstP.pooled49, rtb_get_modes_for_levels,
    rtConstP.pooled38, 6U);

  /* MATLAB Function: '<S110>/Начальные положения заслонок left' */
  left(rtb_Merge_m, rtb_vals_m);

  /* Saturate: '<S2>/Saturation1' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read2'
   */
  if (rtDW.FIU_SET_FR > 290) {
    i = 290;
  } else if (rtDW.FIU_SET_FR < 170) {
    i = 170;
  } else {
    i = rtDW.FIU_SET_FR;
  }

  /* Gain: '<S110>/Gain2' incorporates:
   *  Saturate: '<S2>/Saturation1'
   */
  i *= 13107;
  rtb_Merge_e = (uint8_t)((((uint32_t)i & 65536U) != 0U) + (i >> 17));

  /* SwitchCase: '<S130>/Switch for Left ' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read'
   */
  switch (rtb_Merge_m) {
   case 10:
    break;

   case 20:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S130>/Bilevel' incorporates:
       *  ActionPort: '<S136>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S130>/Bilevel' */
    }

    /* Outputs for IfAction SubSystem: '<S130>/Bilevel' incorporates:
     *  ActionPort: '<S136>/Action Port'
     */
    Bilevel(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S130>/Bilevel' */
    break;

   case 30:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S130>/Bilevel2' incorporates:
       *  ActionPort: '<S137>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S130>/Bilevel2' */
    }

    /* Outputs for IfAction SubSystem: '<S130>/Bilevel2' incorporates:
     *  ActionPort: '<S137>/Action Port'
     */
    Bilevel2(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S130>/Bilevel2' */
    break;

   case 40:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S130>/Afoot' incorporates:
       *  ActionPort: '<S134>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S130>/Afoot' */
    }

    /* Outputs for IfAction SubSystem: '<S130>/Afoot' incorporates:
     *  ActionPort: '<S134>/Action Port'
     */
    Afoot(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S130>/Afoot' */
    break;

   case 50:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S130>/Afoot_Summer' incorporates:
       *  ActionPort: '<S135>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S130>/Afoot_Summer' */
    }

    /* Outputs for IfAction SubSystem: '<S130>/Afoot_Summer' incorporates:
     *  ActionPort: '<S135>/Action Port'
     */
    Afoot_Summer(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S130>/Afoot_Summer' */
    break;
  }

  /* End of SwitchCase: '<S130>/Switch for Left ' */

  /* Lookup_n-D: '<S110>/Выбор режима Right' incorporates:
   *  Gain: '<S110>/Gain2'
   *  Merge: '<S109>/Merge'
   */
  rtb_Merge_m = look2_iu8bu8s16lu64n32_binlcse(rtB.Merge_b, rtb_Merge_e,
    rtConstP.pooled86, rtConstP.pooled49, rtb_get_modes_for_levels,
    rtConstP.pooled38, 6U);

  /* MATLAB Function: '<S110>/Начальные положения заслонок right' */
  left(rtb_Merge_m, rtb_vals_m);

  /* SwitchCase: '<S131>/Switch for Left ' incorporates:
   *  DataStoreRead: '<S2>/Data Store Read'
   */
  switch (rtb_Merge_m) {
   case 10:
    break;

   case 20:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S131>/Bilevel' incorporates:
       *  ActionPort: '<S245>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S131>/Bilevel' */
    }

    /* Outputs for IfAction SubSystem: '<S131>/Bilevel' incorporates:
     *  ActionPort: '<S245>/Action Port'
     */
    Bilevel(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S131>/Bilevel' */
    break;

   case 30:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S131>/Bilevel2' incorporates:
       *  ActionPort: '<S246>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S131>/Bilevel2' */
    }

    /* Outputs for IfAction SubSystem: '<S131>/Bilevel2' incorporates:
     *  ActionPort: '<S246>/Action Port'
     */
    Bilevel2(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S131>/Bilevel2' */
    break;

   case 40:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S131>/Afoot' incorporates:
       *  ActionPort: '<S243>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S131>/Afoot' */
    }

    /* Outputs for IfAction SubSystem: '<S131>/Afoot' incorporates:
     *  ActionPort: '<S243>/Action Port'
     */
    Afoot(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S131>/Afoot' */
    break;

   case 50:
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S131>/Afoot_Summer' incorporates:
       *  ActionPort: '<S244>/Action Port'
       */
      Merge[i] = rtb_vals_m[i];

      /* End of Outputs for SubSystem: '<S131>/Afoot_Summer' */
    }

    /* Outputs for IfAction SubSystem: '<S131>/Afoot_Summer' incorporates:
     *  ActionPort: '<S244>/Action Port'
     */
    Afoot_Summer(rtb_LVL, rtB.Merge_b, Merge, rtb_Merge_j, rtb_Merge_e);

    /* End of Outputs for SubSystem: '<S131>/Afoot_Summer' */
    break;
  }

  /* End of SwitchCase: '<S131>/Switch for Left ' */

  /* MATLAB Function: '<S109>/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",
           rtb_Saturation_n, 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",
           rtb_Saturation_n, rtB.Merge_b);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S109>/Log Ambient Lv' */

  /* DataTypeConversion: '<S565>/Data Type  Conversion1' incorporates:
   *  Bias: '<S565>/Bias'
   *  DataStoreRead: '<S4>/Data Store Read'
   *  DataStoreWrite: '<S565>/Data Store Write'
   *  DataTypeConversion: '<S565>/Data Type  Conversion'
   *  Gain: '<S565>/Gain1'
   *  Gain: '<S565>/Gain2'
   */
  rtDW.AMB_RAW = (int16_t)floor((0.01 * (double)
    rtDW.CCUCAN_BCM_Powertrain_model.BCM_AmbTempRaw_ro - 40.0) * 10.0);

  /* Bias: '<S566>/Bias' incorporates:
   *  DataStoreRead: '<S4>/Data Store Read5'
   *  DataStoreWrite: '<S566>/Data Store Write1'
   *  DataTypeConversion: '<S566>/Data Type Conversion1'
   */
  rtDW.ECT = (int16_t)(rtDW.CCUCAN_EMS_Veh_model.EMS_EngCoolTemp_Val_ro - 40);

  /* DataTypeConversion: '<S567>/Data Type Conversion1' incorporates:
   *  DataStoreRead: '<S4>/Data Store Read6'
   *  DataStoreWrite: '<S567>/Data Store Write2'
   *  DataTypeConversion: '<S567>/Data Type Conversion'
   *  Gain: '<S567>/Gain'
   */
  rtDW.VehicleSpeed = (int16_t)floor(0.01 * (double)
    rtDW.CCUCAN_ESC_04_model.ESC_VehicleSpeed_ro);

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem1' incorporates:
   *  EnablePort: '<S526>/Enable'
   */
  /* DataStoreRead: '<S4>/Data Store Read1' */
  if (rtDW.FIU_CCU1_MODEL.FIU_CCmodeFL_Req > 0) {
    /* DataStoreWrite: '<S526>/Data Store Write6' */
    rtDW.FIU_MODE_FL = rtDW.FIU_CCU1_MODEL.FIU_CCmodeFL_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem1' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem10' incorporates:
   *  EnablePort: '<S527>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_CCmodeFR_Req > 0) {
    /* DataStoreWrite: '<S527>/Data Store Write10' */
    rtDW.FIU_MODE_FR = rtDW.FIU_CCU1_MODEL.FIU_CCmodeFR_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem10' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem11' incorporates:
   *  EnablePort: '<S528>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFR_Def_Req > 0) {
    /* DataStoreWrite: '<S528>/Data Store Write11' */
    rtDW.FIU_DEF_FR = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFR_Def_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem11' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem12' incorporates:
   *  EnablePort: '<S529>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFR_Face_Req > 0) {
    /* DataStoreWrite: '<S529>/Data Store Write12' */
    rtDW.FIU_FACE_FR = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFR_Face_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem12' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem13' incorporates:
   *  EnablePort: '<S530>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFR_Foot_Req > 0) {
    /* DataStoreWrite: '<S530>/Data Store Write13' */
    rtDW.FIU_FOOT_FR = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFR_Foot_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem13' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem14' incorporates:
   *  EnablePort: '<S531>/Enable'
   */
  /* SignalConversion generated from: '<S4>/Bus Selector' incorporates:
   *  DataStoreRead: '<S4>/Data Store Read1'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFL_Req > 0) {
    /* DataStoreWrite: '<S531>/Data Store Write14' */
    rtDW.FIU_BLOWERS_FL = rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFL_Req;
  }

  /* End of SignalConversion generated from: '<S4>/Bus Selector' */
  /* End of Outputs for SubSystem: '<S4>/Subsystem14' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem15' incorporates:
   *  EnablePort: '<S532>/Enable'
   */
  /* DataStoreRead: '<S4>/Data Store Read1' */
  if (rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFR_Req > 0) {
    /* DataStoreWrite: '<S532>/Data Store Write15' */
    rtDW.FIU_BLOWERS_FR = rtDW.FIU_CCU1_MODEL.FIU_BlowerSpeedFR_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem15' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem16' incorporates:
   *  EnablePort: '<S533>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_CCautoModeFL_Req > 0) {
    /* DataStoreWrite: '<S533>/Data Store Write16' */
    rtDW.FIU_AUTOMODE_FL = rtDW.FIU_CCU1_MODEL.FIU_CCautoModeFL_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem16' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem17' incorporates:
   *  EnablePort: '<S534>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_CCautoModeFR_Req > 0) {
    /* DataStoreWrite: '<S534>/Data Store Write17' */
    rtDW.FIU_AUTOMODE_FR = rtDW.FIU_CCU1_MODEL.FIU_CCautoModeFR_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem17' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem18' incorporates:
   *  EnablePort: '<S535>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_Recirculation_Req > 0) {
    /* DataStoreWrite: '<S535>/Data Store Write19' */
    rtDW.FIU_RECIRC = rtDW.FIU_CCU1_MODEL.FIU_Recirculation_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem18' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem5' incorporates:
   *  EnablePort: '<S570>/Enable'
   */
  /* SignalConversion generated from: '<S4>/Bus Selector' incorporates:
   *  DataStoreRead: '<S4>/Data Store Read1'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro > 0) {
    /* DataTypeConversion: '<S577>/Data Type  Conversion1' incorporates:
     *  Bias: '<S577>/Bias'
     *  DataTypeConversion: '<S577>/Data Type  Conversion'
     *  Gain: '<S577>/Gain'
     *  Gain: '<S577>/Gain1'
     */
    rtDW.FIU_SET_FL = (uint16_t)((0.5 * (double)
      rtDW.FIU_CCU1_MODEL.FIU_TargetTempFL_Val_ro + 15.0) * 10.0);

    /* Saturate: '<S577>/Saturation' */
    if (rtDW.FIU_SET_FL > 305) {
      /* DataTypeConversion: '<S577>/Data Type  Conversion1' */
      rtDW.FIU_SET_FL = 305U;
    } else if (rtDW.FIU_SET_FL < 155) {
      /* DataTypeConversion: '<S577>/Data Type  Conversion1' */
      rtDW.FIU_SET_FL = 155U;
    }

    /* End of Saturate: '<S577>/Saturation' */
  }

  /* End of SignalConversion generated from: '<S4>/Bus Selector' */
  /* End of Outputs for SubSystem: '<S4>/Subsystem5' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem6' incorporates:
   *  EnablePort: '<S571>/Enable'
   */
  /* DataStoreRead: '<S4>/Data Store Read1' */
  if (rtDW.FIU_CCU1_MODEL.FIU_TargetTempFR_Val_ro > 0) {
    /* DataTypeConversion: '<S578>/Data Type  Conversion1' incorporates:
     *  Bias: '<S578>/Bias'
     *  DataTypeConversion: '<S578>/Data Type  Conversion'
     *  Gain: '<S578>/Gain'
     *  Gain: '<S578>/Gain1'
     */
    rtDW.FIU_SET_FR = (uint16_t)((0.5 * (double)
      rtDW.FIU_CCU1_MODEL.FIU_TargetTempFR_Val_ro + 15.0) * 10.0);

    /* Saturate: '<S578>/Saturation' */
    if (rtDW.FIU_SET_FR > 305) {
      /* DataTypeConversion: '<S578>/Data Type  Conversion1' */
      rtDW.FIU_SET_FR = 305U;
    } else if (rtDW.FIU_SET_FR < 155) {
      /* DataTypeConversion: '<S578>/Data Type  Conversion1' */
      rtDW.FIU_SET_FR = 155U;
    }

    /* End of Saturate: '<S578>/Saturation' */
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem6' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem7' incorporates:
   *  EnablePort: '<S572>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Def_Req > 0) {
    /* DataStoreWrite: '<S572>/Data Store Write7' */
    rtDW.FIU_DEF_FL = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Def_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem7' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem8' incorporates:
   *  EnablePort: '<S573>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Face_Req > 0) {
    /* DataStoreWrite: '<S573>/Data Store Write8' */
    rtDW.FIU_FACE_FL = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Face_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem8' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem9' incorporates:
   *  EnablePort: '<S574>/Enable'
   */
  if (rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Foot_Req > 0) {
    /* DataStoreWrite: '<S574>/Data Store Write9' */
    rtDW.FIU_FOOT_FL = rtDW.FIU_CCU1_MODEL.FIU_AirDirectionFL_Foot_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem9' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem2' incorporates:
   *  EnablePort: '<S537>/Enable'
   */
  /* DataStoreRead: '<S4>/Data Store Read2' */
  if (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRL_Val_ro > 0) {
    /* DataTypeConversion: '<S575>/Data Type  Conversion1' incorporates:
     *  Bias: '<S575>/Bias'
     *  DataTypeConversion: '<S575>/Data Type  Conversion'
     *  Gain: '<S575>/Gain'
     *  Gain: '<S575>/Gain1'
     */
    rtDW.FIU_SET_RL = (uint16_t)((0.5 * (double)
      rtDW.FIU_CCU2_MODEL.FIU_TargetTempRL_Val_ro + 15.0) * 10.0);

    /* Saturate: '<S575>/Saturation' */
    if (rtDW.FIU_SET_RL > 305) {
      /* DataTypeConversion: '<S575>/Data Type  Conversion1' */
      rtDW.FIU_SET_RL = 305U;
    } else if (rtDW.FIU_SET_RL < 155) {
      /* DataTypeConversion: '<S575>/Data Type  Conversion1' */
      rtDW.FIU_SET_RL = 155U;
    }

    /* End of Saturate: '<S575>/Saturation' */
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem2' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem27' incorporates:
   *  EnablePort: '<S545>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_CCmodeRL_Req > 0) {
    /* DataStoreWrite: '<S545>/Data Store Write1' */
    rtDW.FIU_MODE_RL = rtDW.FIU_CCU2_MODEL.FIU_CCmodeRL_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem27' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem29' incorporates:
   *  EnablePort: '<S547>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRL_Face_Req > 0) {
    /* DataStoreWrite: '<S547>/Data Store Write1' */
    rtDW.FIU_FACE_RL = rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRL_Face_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem29' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem3' incorporates:
   *  EnablePort: '<S548>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro > 0) {
    /* DataTypeConversion: '<S576>/Data Type  Conversion1' incorporates:
     *  Bias: '<S576>/Bias'
     *  DataTypeConversion: '<S576>/Data Type  Conversion'
     *  Gain: '<S576>/Gain'
     *  Gain: '<S576>/Gain1'
     */
    rtDW.FIU_SET_RR = (uint16_t)((0.5 * (double)
      rtDW.FIU_CCU2_MODEL.FIU_TargetTempRR_Val_ro + 15.0) * 10.0);

    /* Saturate: '<S576>/Saturation' */
    if (rtDW.FIU_SET_RR > 305) {
      /* DataTypeConversion: '<S576>/Data Type  Conversion1' */
      rtDW.FIU_SET_RR = 305U;
    } else if (rtDW.FIU_SET_RR < 155) {
      /* DataTypeConversion: '<S576>/Data Type  Conversion1' */
      rtDW.FIU_SET_RR = 155U;
    }

    /* End of Saturate: '<S576>/Saturation' */
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem3' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem30' incorporates:
   *  EnablePort: '<S549>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRL_Foot_Req > 0) {
    /* DataStoreWrite: '<S549>/Data Store Write1' */
    rtDW.FIU_FOOT_RL = rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRL_Foot_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem30' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem31' incorporates:
   *  EnablePort: '<S550>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_CCmodeRR_Req > 0) {
    /* DataStoreWrite: '<S550>/Data Store Write1' */
    rtDW.FIU_MODE_RR = rtDW.FIU_CCU2_MODEL.FIU_CCmodeRR_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem31' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem33' incorporates:
   *  EnablePort: '<S552>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRR_Face_Req > 0) {
    /* DataStoreWrite: '<S552>/Data Store Write1' */
    rtDW.FIU_FACE_RR = rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRR_Face_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem33' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem34' incorporates:
   *  EnablePort: '<S553>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRR_Foot_Req > 0) {
    /* DataStoreWrite: '<S553>/Data Store Write1' */
    rtDW.FIU_FOOT_RR = rtDW.FIU_CCU2_MODEL.FIU_AirDirectionRR_Foot_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem34' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem35' incorporates:
   *  EnablePort: '<S554>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_BlowerSpeedRL_Req > 0) {
    /* DataStoreWrite: '<S554>/Data Store Write1' */
    rtDW.FIU_BLOWERS_RL = rtDW.FIU_CCU2_MODEL.FIU_BlowerSpeedRL_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem35' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem36' incorporates:
   *  EnablePort: '<S555>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_BlowerSpeedRR_Req > 0) {
    /* DataStoreWrite: '<S555>/Data Store Write1' */
    rtDW.FIU_BLOWERS_RR = rtDW.FIU_CCU2_MODEL.FIU_BlowerSpeedRR_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem36' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem37' incorporates:
   *  EnablePort: '<S556>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_CCautoModeRL_Req > 0) {
    /* DataStoreWrite: '<S556>/Data Store Write1' */
    rtDW.FIU_AUTOMODE_RL = rtDW.FIU_CCU2_MODEL.FIU_CCautoModeRL_Req;
  }

  /* End of Outputs for SubSystem: '<S4>/Subsystem37' */

  /* Outputs for Enabled SubSystem: '<S4>/Subsystem38' incorporates:
   *  EnablePort: '<S557>/Enable'
   */
  if (rtDW.FIU_CCU2_MODEL.FIU_CCautoModeRR_Req > 0) {
    /* DataStoreWrite: '<S557>/Data Store Write1' */
    rtDW.FIU_AUTOMODE_RR = rtDW.FIU_CCU2_MODEL.FIU_CCautoModeRR_Req;
  }

  /* End of DataStoreRead: '<S4>/Data Store Read2' */
  /* End of Outputs for SubSystem: '<S4>/Subsystem38' */

  /* BusCreator: '<S5>/Bus Creator' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read'
   *  DataStoreRead: '<S5>/Data Store Read1'
   *  DataStoreRead: '<S5>/Data Store Read10'
   *  DataStoreRead: '<S5>/Data Store Read17'
   *  DataStoreRead: '<S5>/Data Store Read18'
   *  DataStoreRead: '<S5>/Data Store Read19'
   *  DataStoreRead: '<S5>/Data Store Read2'
   *  DataStoreRead: '<S5>/Data Store Read20'
   *  DataStoreRead: '<S5>/Data Store Read21'
   *  DataStoreRead: '<S5>/Data Store Read22'
   *  DataStoreRead: '<S5>/Data Store Read23'
   *  DataStoreRead: '<S5>/Data Store Read24'
   *  DataStoreRead: '<S5>/Data Store Read3'
   *  DataStoreRead: '<S5>/Data Store Read4'
   *  DataStoreRead: '<S5>/Data Store Read5'
   *  DataStoreRead: '<S5>/Data Store Read6'
   *  DataStoreRead: '<S5>/Data Store Read7'
   *  DataStoreRead: '<S5>/Data Store Read8'
   *  DataStoreRead: '<S5>/Data Store Read9'
   *  DataStoreWrite: '<S5>/Data Store Write'
   *  Switch: '<S581>/Switch'
   *  Switch: '<S582>/Switch'
   *  Switch: '<S583>/Switch'
   *  Switch: '<S584>/Switch'
   *  Switch: '<S585>/Switch'
   *  Switch: '<S586>/Switch'
   *  Switch: '<S587>/Switch'
   *  Switch: '<S588>/Switch'
   *  Switch: '<S591>/Switch'
   *  Switch: '<S592>/Switch'
   *  Switch: '<S593>/Switch'
   *  Switch: '<S594>/Switch'
   *  Switch: '<S595>/Switch'
   *  Switch: '<S596>/Switch'
   */
  rtDW.CCU_STAT1_MODEL.CCU_ModeFL_Stat = (uint8_t)(rtDW.FIU_MODE_FL > 1);
  rtDW.CCU_STAT1_MODEL.CCU_ModeFR_Stat = (uint8_t)(rtDW.FIU_MODE_FR > 1);
  rtDW.CCU_STAT1_MODEL.CCU_ModeRL_Stat = (uint8_t)(rtDW.FIU_MODE_RL > 1);
  rtDW.CCU_STAT1_MODEL.CCU_ModeRR_Stat = (uint8_t)(rtDW.FIU_MODE_RR > 1);
  rtDW.CCU_STAT1_MODEL.CCU_AutoModeFL_Stat = rtDW.FIU_AUTOMODE_FL;
  rtDW.CCU_STAT1_MODEL.CCU_AutoModeFR_Stat = rtDW.FIU_AUTOMODE_FR;
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRL_Face_Stat = (uint8_t)(rtDW.FIU_FACE_RL
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRL_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_RL
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AutoModeRL_Stat = rtDW.FIU_AUTOMODE_RL;
  rtDW.CCU_STAT1_MODEL.CCU_AutoModeRR_Stat = rtDW.FIU_AUTOMODE_RR;
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRR_Face_Stat = (uint8_t)(rtDW.FIU_FACE_RR
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionRR_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_RR
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Def_Stat = (uint8_t)(rtDW.FIU_DEF_FL <=
    1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Face_Stat = (uint8_t)(rtDW.FIU_FACE_FL
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFL_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_FL
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Def_Stat = (uint8_t)(rtDW.FIU_DEF_FR <=
    1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Face_Stat = (uint8_t)(rtDW.FIU_FACE_FR
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_AirDirectionFR_Foot_Stat = (uint8_t)(rtDW.FIU_FOOT_FR
    <= 1);
  rtDW.CCU_STAT1_MODEL.CCU_Recirculation_Stat = rtDW.FIU_RECIRC;

  /* Switch: '<S5>/Switch4' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read11'
   */
  if (rtDW.FIU_BLOWERS_FL > 7) {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  Constant: '<S5>/manual1'
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFL_Stat = 0U;
  } else {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFL_Stat = rtDW.FIU_BLOWERS_FL;
  }

  /* End of Switch: '<S5>/Switch4' */

  /* Saturate: '<S579>/Saturation' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read13'
   */
  if (rtDW.FIU_SET_FL > 310) {
    rtb_out_b = 310U;
  } else if (rtDW.FIU_SET_FL < 155) {
    rtb_out_b = 155U;
  } else {
    rtb_out_b = rtDW.FIU_SET_FL;
  }

  /* BusCreator: '<S5>/Bus Creator' incorporates:
   *  Bias: '<S579>/Bias'
   *  DataStoreWrite: '<S5>/Data Store Write'
   *  DataTypeConversion: '<S579>/Data Type Conversion'
   *  Gain: '<S579>/Gain'
   *  Gain: '<S579>/Gain1'
   *  Saturate: '<S579>/Saturation'
   */
  rtDW.CCU_STAT1_MODEL.CCU_TargetTempFL_Stat_ro = (uint8_t)((0.10000038146972656
    * (double)rtb_out_b - 15.5) * 2.0);

  /* Switch: '<S5>/Switch5' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read12'
   */
  if (rtDW.FIU_BLOWERS_FR > 7) {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  Constant: '<S5>/manual1'
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFR_Stat = 0U;
  } else {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedFR_Stat = rtDW.FIU_BLOWERS_FR;
  }

  /* End of Switch: '<S5>/Switch5' */

  /* Saturate: '<S590>/Saturation' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read14'
   */
  if (rtDW.FIU_SET_FR > 310) {
    rtb_out_b = 310U;
  } else if (rtDW.FIU_SET_FR < 155) {
    rtb_out_b = 155U;
  } else {
    rtb_out_b = rtDW.FIU_SET_FR;
  }

  /* BusCreator: '<S5>/Bus Creator' incorporates:
   *  Bias: '<S590>/Bias'
   *  DataStoreWrite: '<S5>/Data Store Write'
   *  DataTypeConversion: '<S590>/Data Type Conversion'
   *  Gain: '<S590>/Gain'
   *  Gain: '<S590>/Gain1'
   *  Saturate: '<S590>/Saturation'
   */
  rtDW.CCU_STAT1_MODEL.CCU_TargetTempFR_Stat_ro = (uint8_t)((0.10000038146972656
    * (double)rtb_out_b - 15.5) * 2.0);

  /* Switch: '<S5>/Switch6' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read26'
   */
  if (rtDW.FIU_BLOWERS_RL > 7) {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  Constant: '<S5>/manual1'
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRL_Stat = 0U;
  } else {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRL_Stat = rtDW.FIU_BLOWERS_RL;
  }

  /* End of Switch: '<S5>/Switch6' */

  /* Saturate: '<S580>/Saturation' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read15'
   */
  if (rtDW.FIU_SET_RR > 310) {
    rtb_out_b = 310U;
  } else if (rtDW.FIU_SET_RR < 155) {
    rtb_out_b = 155U;
  } else {
    rtb_out_b = rtDW.FIU_SET_RR;
  }

  /* BusCreator: '<S5>/Bus Creator' incorporates:
   *  Bias: '<S580>/Bias'
   *  DataStoreWrite: '<S5>/Data Store Write'
   *  DataTypeConversion: '<S580>/Data Type Conversion'
   *  Gain: '<S580>/Gain'
   *  Gain: '<S580>/Gain1'
   *  Saturate: '<S580>/Saturation'
   */
  rtDW.CCU_STAT1_MODEL.CCU_TargetTempRR_Stat_ro = (uint8_t)((0.10000038146972656
    * (double)rtb_out_b - 15.5) * 2.0);

  /* Switch: '<S5>/Switch7' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read25'
   */
  if (rtDW.FIU_BLOWERS_RR > 7) {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  Constant: '<S5>/manual1'
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRR_Stat = 0U;
  } else {
    /* BusCreator: '<S5>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S5>/Data Store Write'
     */
    rtDW.CCU_STAT1_MODEL.CCU_BlowerSpeedRR_Stat = rtDW.FIU_BLOWERS_RR;
  }

  /* End of Switch: '<S5>/Switch7' */

  /* Saturate: '<S589>/Saturation' incorporates:
   *  DataStoreRead: '<S5>/Data Store Read16'
   */
  if (rtDW.FIU_SET_RL > 310) {
    rtb_out_b = 310U;
  } else if (rtDW.FIU_SET_RL < 155) {
    rtb_out_b = 155U;
  } else {
    rtb_out_b = rtDW.FIU_SET_RL;
  }

  /* BusCreator: '<S5>/Bus Creator' incorporates:
   *  Bias: '<S589>/Bias'
   *  DataStoreWrite: '<S5>/Data Store Write'
   *  DataTypeConversion: '<S589>/Data Type Conversion'
   *  Gain: '<S589>/Gain'
   *  Gain: '<S589>/Gain1'
   *  Saturate: '<S589>/Saturation'
   */
  rtDW.CCU_STAT1_MODEL.CCU_TargetTempRL_Stat_ro = (uint8_t)((0.10000038146972656
    * (double)rtb_out_b - 15.5) * 2.0);

  /* DataTypeConversion: '<S611>/Data Type Conversion' */
  for (i = 0; i < 9; i++) {
    /* Switch: '<S611>/Switch' incorporates:
     *  Constant: '<S611>/Constant'
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreRead: '<S611>/Data Store Read'
     *  Gain: '<S611>/Gain'
     *  Product: '<S611>/Divide'
     */
    rtb_Saturation_n = rtDW.MaxPositionCh0_private[i];
    if (rtb_Saturation_n != 0) {
      rtb_rate = (double)Actuator_Ch0_Status_Model.in_CPOS_ALL[i] / (double)
        rtb_Saturation_n * 100.0;
    } else {
      rtb_rate = 0.0;
    }

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

    /* Saturate: '<S611>/Saturation' incorporates:
     *  DataTypeConversion: '<S611>/Data Type Conversion'
     */
    if (rtb_rate > 100.0) {
      rtb_DataTypeConversion_bh[i] = 100U;
    } else if (rtb_rate < 0.0) {
      rtb_DataTypeConversion_bh[i] = 0U;
    } else {
      rtb_DataTypeConversion_bh[i] = (uint8_t)rtb_rate;
    }

    /* End of Saturate: '<S611>/Saturation' */
  }

  /* End of DataTypeConversion: '<S611>/Data Type Conversion' */

  /* Switch: '<S597>/Switch' incorporates:
   *  Constant: '<S597>/Constant1'
   *  DataStoreRead: '<S597>/Data Store Read'
   *  DataStoreRead: '<S597>/Data Store Read2'
   */
  if (rtDW.stepSig_private > 0) {
    rtb_Switch_nyq = rtDW.stepSig_private;
  } else {
    rtb_Switch_nyq = 1;
  }

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

  /* SwitchCase: '<S597>/Switch Case' */
  switch (rtb_Switch_nyq) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S597>/Stop Mode' incorporates:
     *  ActionPort: '<S610>/Action Port'
     */
    /* If: '<S610>/If1' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S610>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S667>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S667>/Data Store Write1' */
        rtDW.COM_private[i] = 1U;

        /* DataStoreWrite: '<S667>/Data Store Write' */
        rtDW.MODE_private[i] = 2U;
      }

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S667>/Constant'
       *  Sum: '<S667>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S667>/Write' incorporates:
       *  DataStoreRead: '<S667>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Stop Mode\n'); */
        printf("[LIN 1] Stop Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S667>/Write' */
      /* End of Outputs for SubSystem: '<S610>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S610>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S668>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S668>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S610>/If1' */
    /* End of Outputs for SubSystem: '<S597>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S597>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S606>/Action Port'
     */
    /* If: '<S606>/If' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S606>/If Action Subsystem' incorporates:
       *  ActionPort: '<S655>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S655>/Data Store Write' */
        rtDW.POS_private[i] = 6000U;

        /* DataStoreWrite: '<S655>/Data Store Write1' */
        rtDW.COM_private[i] = 2U;
      }

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S655>/Constant'
       *  Merge: '<S606>/Merge'
       *  Sum: '<S655>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S655>/Write' incorporates:
       *  DataStoreRead: '<S655>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Initial CPOS Min\n'); */
        printf("[LIN 1] Initial CPOS Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S655>/Write' */
      /* End of Outputs for SubSystem: '<S606>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S606>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S656>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  Merge: '<S606>/Merge'
       *  SignalConversion generated from: '<S656>/stepIn1'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S606>/If' */
    /* End of Outputs for SubSystem: '<S597>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S597>/Normal Mode' incorporates:
     *  ActionPort: '<S609>/Action Port'
     */
    /* If: '<S609>/If1' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S609>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S664>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S664>/Data Store Write' */
        rtDW.MODE_private[i] = 0U;

        /* DataStoreWrite: '<S664>/Data Store Write1' */
        rtDW.COM_private[i] = 1U;
      }

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S664>/Constant'
       *  Sum: '<S664>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S664>/Write' incorporates:
       *  DataStoreRead: '<S664>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Normal Mode\n'); */
        printf("[LIN 1] Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S664>/Write' */
      /* End of Outputs for SubSystem: '<S609>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S609>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S665>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S665>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S609>/If1' */
    /* End of Outputs for SubSystem: '<S597>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S597>/Move to position Min' incorporates:
     *  ActionPort: '<S608>/Action Port'
     */
    /* If: '<S608>/If1' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S608>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S661>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S661>/Data Store Write4' incorporates:
         *  Constant: '<S661>/Constant1'
         */
        rtDW.Autos_private[i] = 1U;

        /* DataStoreWrite: '<S661>/Data Store Write2' incorporates:
         *  Constant: '<S661>/Constant10'
         */
        rtDW.Stall_private[i] = 1U;

        /* DataStoreWrite: '<S661>/Data Store Write3' */
        rtDW.Lnoise_private[i] = 0U;

        /* DataStoreWrite: '<S661>/Data Store Write5' incorporates:
         *  Constant: '<S661>/Constant2'
         */
        rtDW.Speed_private[i] = 3U;

        /* DataStoreWrite: '<S661>/Data Store Write6' incorporates:
         *  Constant: '<S661>/Constant3'
         */
        rtDW.Coils_private[i] = 3U;

        /* DataStoreWrite: '<S661>/Data Store Write' */
        rtDW.POS_private[i] = 0U;

        /* DataStoreWrite: '<S661>/Data Store Write1' incorporates:
         *  Constant: '<S661>/Constant9'
         */
        rtDW.COM_private[i] = 3U;
      }

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S661>/Constant'
       *  Sum: '<S661>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S661>/Write' incorporates:
       *  DataStoreRead: '<S661>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Move to position Min\n'); */
        printf("[LIN 1] Move to position Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S661>/Write' */
      /* End of Outputs for SubSystem: '<S608>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S608>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S662>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S662>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S608>/If1' */
    /* End of Outputs for SubSystem: '<S597>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S597>/Check Stall Min' incorporates:
     *  ActionPort: '<S603>/Action Port'
     */
    /* Logic: '<S603>/Logical Operator3' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreRead: '<S603>/Data Store Read'
     *  Logic: '<S603>/Logical Operator1'
     *  Logic: '<S603>/Logical Operator2'
     *  RelationalOperator: '<S603>/Relational Operator'
     *  RelationalOperator: '<S603>/Relational Operator1'
     */
    for (i = 0; i < 9; i++) {
      rtb_LogicalOperator3_i5[i] =
        ((Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1) ||
         (Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 0) ||
         (rtDW.ErrorCalibration_private[i] == 0));
    }

    /* End of Logic: '<S603>/Logical Operator3' */

    /* Logic: '<S603>/Logical Operator' incorporates:
     *  Logic: '<S603>/Logical Operator3'
     */
    rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_i5[i
        + 1]);
    }

    /* If: '<S603>/If2' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  DataTypeConversion: '<S603>/Data Type Conversion'
     *  DataTypeConversion: '<S603>/Data Type Conversion1'
     *  Logic: '<S603>/Logical Operator'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
    {
      /* Outputs for IfAction SubSystem: '<S603>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S616>/Action Port'
       */
      /* DataStoreWrite: '<S616>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        /* Switch: '<S616>/Switch' incorporates:
         *  DataStoreRead: '<S616>/Data Store Read1'
         */
        if (rtDW.ErrorCalibration_private[i] != 0) {
          rtDW.MinPositionCh0_private[i] =
            Actuator_Ch0_Status_Model.in_CPOS_ALL[i];
        }

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

      /* End of DataStoreWrite: '<S616>/Data Store Write1' */

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S616>/Constant'
       *  Sum: '<S616>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S616>/Write' incorporates:
       *  DataStoreRead: '<S616>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Check Stall Min\n'); */
        printf("[LIN 1] Check Stall Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S616>/Write' */
      /* End of Outputs for SubSystem: '<S603>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S603>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S617>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S617>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S603>/If2' */
    /* End of Outputs for SubSystem: '<S597>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S597>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S605>/Action Port'
     */
    /* If: '<S605>/If1' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S605>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S652>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S652>/Data Store Write1' */
        rtDW.COM_private[i] = 2U;

        /* DataStoreWrite: '<S652>/Data Store Write' */
        rtDW.POS_private[i] = 0U;
      }

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S652>/Constant'
       *  Sum: '<S652>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S652>/Write' incorporates:
       *  DataStoreRead: '<S652>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Initial CPOS Max\n'); */
        printf("[LIN 1] Initial CPOS Max\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S652>/Write' */
      /* End of Outputs for SubSystem: '<S605>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S605>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S653>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S653>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S605>/If1' */
    /* End of Outputs for SubSystem: '<S597>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S597>/Move to position Max' incorporates:
     *  ActionPort: '<S607>/Action Port'
     */
    /* If: '<S607>/If1' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S607>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S658>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S658>/Data Store Write4' incorporates:
         *  Constant: '<S658>/Constant1'
         */
        rtDW.Autos_private[i] = 1U;

        /* DataStoreWrite: '<S658>/Data Store Write2' incorporates:
         *  Constant: '<S658>/Constant10'
         */
        rtDW.Stall_private[i] = 1U;

        /* DataStoreWrite: '<S658>/Data Store Write3' */
        rtDW.Lnoise_private[i] = 0U;

        /* DataStoreWrite: '<S658>/Data Store Write5' incorporates:
         *  Constant: '<S658>/Constant2'
         */
        rtDW.Speed_private[i] = 3U;

        /* DataStoreWrite: '<S658>/Data Store Write' */
        rtDW.POS_private[i] = 6000U;

        /* DataStoreWrite: '<S658>/Data Store Write1' incorporates:
         *  Constant: '<S658>/Constant9'
         */
        rtDW.COM_private[i] = 3U;

        /* DataStoreWrite: '<S658>/Data Store Write6' */
        rtDW.Coils_private[i] = 0U;
      }

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S658>/Constant'
       *  Sum: '<S658>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S658>/Write' incorporates:
       *  DataStoreRead: '<S658>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Move to position Max\n'); */
        printf("[LIN 1] Move to position Max\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S658>/Write' */
      /* End of Outputs for SubSystem: '<S607>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S607>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S659>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S659>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S607>/If1' */
    /* End of Outputs for SubSystem: '<S597>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S597>/Check Stall Max' incorporates:
     *  ActionPort: '<S602>/Action Port'
     */
    /* Logic: '<S602>/Logical Operator3' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreRead: '<S602>/Data Store Read'
     *  Logic: '<S602>/Logical Operator'
     *  Logic: '<S602>/Logical Operator2'
     *  RelationalOperator: '<S602>/Relational Operator'
     *  RelationalOperator: '<S602>/Relational Operator1'
     */
    for (i = 0; i < 9; i++) {
      rtb_LogicalOperator3_i5[i] =
        ((Actuator_Ch0_Status_Model.in_Act_Stall_Slave[i] == 1) ||
         (Actuator_Ch0_Status_Model.in_CPOS_ALL[i] == 6000) ||
         (rtDW.ErrorCalibration_private[i] == 0));
    }

    /* End of Logic: '<S602>/Logical Operator3' */

    /* Logic: '<S602>/Logical Operator1' incorporates:
     *  Logic: '<S602>/Logical Operator3'
     */
    rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_i5[i
        + 1]);
    }

    /* If: '<S602>/If2' incorporates:
     *  DataStoreRead: '<S597>/Data Store Read1'
     *  DataStoreWrite: '<S597>/Data Store Write1'
     *  DataTypeConversion: '<S602>/Data Type Conversion'
     *  DataTypeConversion: '<S602>/Data Type Conversion1'
     *  Logic: '<S602>/Logical Operator1'
     *  SignalConversion generated from: '<S597>/Bus Selector'
     */
    if ((Actuator_Ch0_Status_Model.Busy == 0) &&
        (Actuator_Ch0_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
    {
      /* Outputs for IfAction SubSystem: '<S602>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S613>/Action Port'
       */
      /* DataStoreWrite: '<S613>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        /* Switch: '<S613>/Switch' incorporates:
         *  DataStoreRead: '<S613>/Data Store Read1'
         */
        if (rtDW.ErrorCalibration_private[i] != 0) {
          rtDW.MaxPositionCh0_private[i] =
            Actuator_Ch0_Status_Model.in_CPOS_ALL[i];
        }

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

      /* End of DataStoreWrite: '<S613>/Data Store Write1' */

      /* Merge: '<S597>/Merge' incorporates:
       *  Constant: '<S613>/Constant'
       *  Sum: '<S613>/step inc'
       */
      rtB.Merge_f1 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S613>/Write' incorporates:
       *  DataStoreRead: '<S613>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 1] Check Stall MAX\n'); */
        printf("[LIN 1] Check Stall MAX\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S613>/Write' */
      /* End of Outputs for SubSystem: '<S602>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S602>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S614>/Action Port'
       */
      /* Merge: '<S597>/Merge' incorporates:
       *  SignalConversion generated from: '<S614>/stepIn'
       */
      rtB.Merge_f1 = rtb_Switch_nyq;

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

    /* End of If: '<S602>/If2' */
    /* End of Outputs for SubSystem: '<S597>/Check Stall Max' */
    break;

   case 9:
    /* Outputs for IfAction SubSystem: '<S597>/Homing' incorporates:
     *  ActionPort: '<S604>/Action Port'
     */
    /* Product: '<S619>/Divide1' incorporates:
     *  Constant: '<S619>/ACT1'
     *  DataStoreRead: '<S619>/MAX ACT1T '
     */
    for (i = 0; i < 9; i++) {
      rtb_Divide1_a4[i] = (double)rtDW.MaxPositionCh0_private[i] / (double)
        rtConstP.ACT1_Value[i];
    }

    /* End of Product: '<S619>/Divide1' */

    /* SwitchCase: '<S604>/Switch Case' incorporates:
     *  DataStoreRead: '<S604>/Data Store Read4'
     */
    switch (rtDW.stepHoming_private) {
     case 0:
      /* Outputs for IfAction SubSystem: '<S604>/Switch Case Action Subsystem' incorporates:
       *  ActionPort: '<S620>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S625>/Compare' */
        rtb_rate = rtb_Divide1_a4[i];

        /* Logic: '<S620>/Logical Operator' incorporates:
         *  Constant: '<S625>/Constant'
         *  Constant: '<S626>/Constant'
         *  RelationalOperator: '<S625>/Compare'
         *  RelationalOperator: '<S626>/Compare'
         */
        rtb_LogicalOperator1 = ((rtb_rate >= 0.9) && (rtb_rate <= 1.1));
        rtb_LogicalOperator3_i5[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S628>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S628>/Data Store Read'
         *  DataStoreWrite: '<S628>/Data Store Write'
         *  Logic: '<S628>/Logical Operator'
         *  Logic: '<S628>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private[i] != 0));
      }

      /* MATLAB Function: '<S620>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S620>/Data Store Read5'
       *  DataStoreRead: '<S620>/MIN ACT1T 1'
       *  Logic: '<S620>/Logical Operator2'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 1] Homing 0\n"); */
        printf("[LIN 1] Homing 0\n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
          printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                 (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
                 rtb_Divide1_a4[i], (int16_t)!rtb_LogicalOperator3_i5[i]);
          fflush(stdout);
        }
      }

      /* End of MATLAB Function: '<S620>/MAX POSITION' */

      /* Logic: '<S620>/Logical Operator1' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* Switch: '<S620>/Switch' incorporates:
       *  Logic: '<S620>/Logical Operator1'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S604>/Merge' incorporates:
         *  Constant: '<S620>/Constant1'
         */
        rtB.Merge_a = 4;
      } else {
        /* Merge: '<S604>/Merge' incorporates:
         *  Constant: '<S620>/Constant'
         */
        rtB.Merge_a = 1;
      }

      /* End of Switch: '<S620>/Switch' */
      /* End of Outputs for SubSystem: '<S604>/Switch Case Action Subsystem' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S604>/Switch Case Action Subsystem1' incorporates:
       *  ActionPort: '<S621>/Action Port'
       */
      /* RelationalOperator: '<S630>/Compare' incorporates:
       *  Constant: '<S630>/Constant'
       */
      for (i = 0; i < 9; i++) {
        rtb_LogicalOperator3_i5[i] = (rtb_Divide1_a4[i] > 1.5);
      }

      /* End of RelationalOperator: '<S630>/Compare' */

      /* Logic: '<S629>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* DataTypeConversion: '<S629>/Data Type Conversion' incorporates:
       *  DataStoreWrite: '<S629>/Data Store Write1'
       *  Logic: '<S629>/Logical Operator'
       */
      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
      for (i = 0; i < 9; i++) {
        /* DataTypeConversion: '<S629>/Data Type Conversion1' incorporates:
         *  DataStoreWrite: '<S629>/Data Store Write2'
         */
        rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[i];
        rtDW.COM_private[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S629>/Data Type Conversion2' incorporates:
         *  DataStoreRead: '<S629>/Data Store Read'
         *  DataStoreWrite: '<S629>/Data Store Write3'
         *  Logic: '<S629>/Logical Operator1'
         */
        rtDW.ErrorActuator[i] = (uint8_t)(rtb_LogicalOperator1 ||
          (rtDW.ErrorActuator[i] != 0));

        /* DataStoreWrite: '<S629>/Data Store Write' */
        rtDW.MODE_private[i] = 2U;
      }

      /* MATLAB Function: '<S629>/Write ERROR' incorporates:
       *  DataStoreRead: '<S629>/Data Store Read6'
       */
      /* :  if(LOGGER>=0) */
      if (rtDW.LOGGER_LIN >= 0.0) {
        /* :  for i = 1:numel(ErrCallibration) */
        for (i = 0; i < 9; i++) {
          /* :  if ErrCallibration(i) == 1 */
          if (rtb_LogicalOperator3_i5[i]) {
            /* :  fprintf('[LIN 1] Failure with actuator #%d\n', int16(i)); */
            printf("[LIN 1] Failure with actuator #%d\n", (int16_t)(i + 1));
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S629>/Write ERROR' */
      for (i = 0; i < 9; i++) {
        /* Logic: '<S621>/Logical Operator1' */
        rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[i];

        /* DataTypeConversion: '<S621>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S621>/Data Store Read'
         *  DataStoreWrite: '<S621>/Data Store Write'
         *  Logic: '<S621>/Logical Operator'
         *  Logic: '<S621>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private[i] != 0));

        /* DataStoreWrite: '<S633>/Data Store Write' incorporates:
         *  DataTypeConversion: '<S633>/Data Type Conversion'
         */
        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
      }

      /* DataStoreWrite: '<S632>/Data Store Write' incorporates:
       *  Constant: '<S632>/Constant'
       */
      rtDW.stepSig_private = 1;

      /* MATLAB Function: '<S621>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S621>/Data Store Read5'
       *  DataStoreRead: '<S621>/MIN ACT1T 1'
       *  DataStoreWrite: '<S621>/Data Store Write'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 1] Homing 1. Start Callibration \n"); */
        printf("[LIN 1] Homing 1. Start Callibration \n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 9; i++) {
          /* :  if(ERRORS(i)==1) */
          if (rtDW.ErrorCalibration_private[i] == 1) {
            /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
            printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                   (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
                   rtb_Divide1_a4[i], (int16_t)rtDW.ErrorCalibration_private[i]);
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S621>/MAX POSITION' */

      /* Logic: '<S621>/Logical Operator2' incorporates:
       *  DataStoreWrite: '<S621>/Data Store Write'
       */
      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private[0] != 0);
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          (rtDW.ErrorCalibration_private[i + 1] != 0));
      }

      /* Switch: '<S621>/Switch' incorporates:
       *  Logic: '<S621>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S604>/Merge' incorporates:
         *  Constant: '<S632>/Constant1'
         */
        rtB.Merge_a = 2;
      } else {
        /* Merge: '<S604>/Merge' incorporates:
         *  Constant: '<S621>/Constant1'
         */
        rtB.Merge_a = 4;
      }

      /* End of Switch: '<S621>/Switch' */
      /* End of Outputs for SubSystem: '<S604>/Switch Case Action Subsystem1' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S604>/Switch Case Action Subsystem2' incorporates:
       *  ActionPort: '<S622>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S635>/Compare' */
        rtb_rate = rtb_Divide1_a4[i];

        /* Logic: '<S622>/Logical Operator3' incorporates:
         *  Constant: '<S635>/Constant'
         *  Constant: '<S636>/Constant'
         *  DataStoreRead: '<S622>/Data Store Read'
         *  Logic: '<S622>/Logical Operator1'
         *  Logic: '<S622>/Logical Operator4'
         *  RelationalOperator: '<S635>/Compare'
         *  RelationalOperator: '<S636>/Compare'
         */
        rtb_LogicalOperator1 = (((rtb_rate < 0.97) || (rtb_rate > 1.03)) &&
          (rtDW.ErrorCalibration_private[i] != 0));
        rtb_LogicalOperator3_i5[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S622>/Data Type Conversion' incorporates:
         *  DataStoreWrite: '<S622>/Data Store Write1'
         */
        rtDW.ErrorCalibration_private[i] = rtb_LogicalOperator1;
      }

      /* MATLAB Function: '<S622>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S622>/Data Store Read5'
       *  DataStoreRead: '<S622>/MIN ACT1T 1'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 1] Homing 3. Callibration \n"); */
        printf("[LIN 1] Homing 3. Callibration \n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 9; i++) {
          /* :  if(ERRORS(i)==1) */
          if (rtb_LogicalOperator3_i5[i]) {
            /* :  fprintf('[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
            printf("[LIN 1] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                   (int16_t)(i + 1), rtDW.MaxPositionCh0_private[i],
                   rtb_Divide1_a4[i], 1);
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S622>/MAX POSITION' */

      /* Logic: '<S622>/Logical Operator2' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* Switch: '<S622>/Switch' incorporates:
       *  Logic: '<S622>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S604>/Merge' incorporates:
         *  Constant: '<S622>/Constant3'
         */
        rtB.Merge_a = 3;
      } else {
        /* Merge: '<S604>/Merge' incorporates:
         *  Constant: '<S622>/Constant1'
         */
        rtB.Merge_a = 4;
      }

      /* End of Switch: '<S622>/Switch' */
      /* End of Outputs for SubSystem: '<S604>/Switch Case Action Subsystem2' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S604>/Switch Case Action Subsystem3' incorporates:
       *  ActionPort: '<S623>/Action Port'
       */
      /* MATLAB Function: '<S623>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S623>/Data Store Read1'
       *  DataStoreRead: '<S623>/Data Store Read5'
       */
      /* :  if(LOGGER>1) */
      if (rtDW.LOGGER_LIN > 1.0) {
        /* :  fprintf("[LIN 1] Homing 3. Start Time on step %d\n",int16(step)); */
        rtb_rate = rt_roundd(rtDW.ErrorHomming_private);
        if (rtb_rate < 32768.0) {
          if (rtb_rate >= -32768.0) {
            rtb_Saturation_n = (int16_t)rtb_rate;
          } else {
            rtb_Saturation_n = INT16_MIN;
          }
        } else {
          rtb_Saturation_n = INT16_MAX;
        }

        printf("[LIN 1] Homing 3. Start Time on step %d\n", rtb_Saturation_n);
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S623>/MAX POSITION' */

      /* If: '<S623>/If' incorporates:
       *  DataStoreRead: '<S623>/Data Store Read1'
       */
      if (rtDW.ErrorHomming_private < 10.0) {
        /* Outputs for IfAction SubSystem: '<S623>/If Action Subsystem' incorporates:
         *  ActionPort: '<S638>/Action Port'
         */
        /* MATLAB Function: '<S638>/MATLAB Function' incorporates:
         *  DataStoreRead: '<S638>/Data Store Read'
         *  DataStoreRead: '<S638>/Data Store Read1'
         */
        MATLABFunction(rtDW.Start_timer_n, rtDW.t_now, &rtb_dt_an,
                       &rtDW.sf_MATLABFunction);

        /* MATLAB Function: '<S638>/MAX POSITION' incorporates:
         *  DataStoreRead: '<S638>/Data Store Read5'
         */
        /* :  if(LOGGER>1) */
        if (rtDW.LOGGER_LIN > 1.0) {
          /* :  fprintf("[LIN 1] Homing 3. Start TIme dt = %d \n",int32(data)); */
          rtb_Subtract = rtb_dt_an;
          if (rtb_dt_an > 2147483647U) {
            rtb_Subtract = 2147483647U;
          }

          printf("[LIN 1] Homing 3. Start TIme dt = %d \n", (int32_t)
                 rtb_Subtract);
          fflush(stdout);
        }

        /* End of MATLAB Function: '<S638>/MAX POSITION' */

        /* If: '<S638>/If' */
        if (rtb_dt_an > 30000U) {
          /* Outputs for IfAction SubSystem: '<S638>/If Action Subsystem' incorporates:
           *  ActionPort: '<S641>/Action Port'
           */
          /* Merge: '<S604>/Merge' */
          IfActionSubsystem(&rtB.Merge_a, &rtDW.ErrorHomming_private,
                            &rtDW.Start_timer_n, &rtDW.stepSig_private);

          /* End of Outputs for SubSystem: '<S638>/If Action Subsystem' */
        } else {
          /* Outputs for IfAction SubSystem: '<S638>/If Action Subsystem1' incorporates:
           *  ActionPort: '<S642>/Action Port'
           */
          /* DataStoreWrite: '<S642>/Data Store Write2' incorporates:
           *  Constant: '<S642>/Constant3'
           */
          rtDW.Start_timer_n = 1.0;

          /* DataTypeConversion: '<S645>/Data Type Conversion2' incorporates:
           *  DataStoreRead: '<S645>/valves target in percent'
           */
          for (i = 0; i < 9; i++) {
            rtb_DataTypeConversion_bq[i] = (uint8_t)
              rtDW.valves_front_manual_target[i];
          }

          /* End of DataTypeConversion: '<S645>/Data Type Conversion2' */

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private[0] = rtb_DataTypeConversion_bq[8];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           *  DataStoreWrite: '<S597>/Data Store Write2'
           */
          rtDW.BUS_ADR_private[1] = rtb_DataTypeConversion_bh[1];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           *  DataStoreWrite: '<S597>/Data Store Write2'
           */
          rtDW.BUS_ADR_private[2] = rtb_DataTypeConversion_bh[2];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           *  DataStoreWrite: '<S597>/Data Store Write2'
           */
          rtDW.BUS_ADR_private[3] = rtb_DataTypeConversion_bh[3];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private[4] = rtb_DataTypeConversion_bq[1];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private[5] = rtb_DataTypeConversion_bq[0];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           *  DataStoreWrite: '<S597>/Data Store Write2'
           */
          rtDW.BUS_ADR_private[6] = rtb_DataTypeConversion_bh[6];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private[7] = rtb_DataTypeConversion_bq[6];

          /* SignalConversion generated from: '<S645>/Vector Concatenate' incorporates:
           *  Concatenate: '<S645>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private[8] = rtb_DataTypeConversion_bq[7];
          for (i = 0; i < 9; i++) {
            /* Product: '<S646>/Product' */
            rtb_Merge_j = rtDW.BUS_ADR_private[i];

            /* DataTypeConversion: '<S646>/Data Type Conversion1' incorporates:
             *  Constant: '<S646>/Constant1'
             *  DataStoreRead: '<S646>/Data Store Read'
             *  DataStoreWrite: '<S645>/Data Store Write'
             *  Product: '<S646>/Divide1'
             *  Product: '<S646>/Product'
             */
            rtDW.POS_private[i] = (uint16_t)((double)(rtb_Merge_j *
              rtDW.MaxPositionCh0_private[i]) / 100.0);

            /* RelationalOperator: '<S645>/Relational Operator1' incorporates:
             *  DataStoreWrite: '<S597>/Data Store Write2'
             */
            rtb_LogicalOperator3_i5[i] = (rtb_DataTypeConversion_bh[i] ==
              rtb_Merge_j);
          }

          /* Logic: '<S645>/Logical Operator' */
          rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
          for (i = 0; i < 8; i++) {
            rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
              rtb_LogicalOperator3_i5[i + 1]);
          }

          for (i = 0; i < 9; i++) {
            /* Switch: '<S645>/Switch' incorporates:
             *  Constant: '<S645>/Constant4'
             *  Constant: '<S645>/Constant9'
             *  DataStoreWrite: '<S645>/Data Store Write1'
             *  Logic: '<S645>/Logical Operator'
             */
            if (rtb_LogicalOperator1) {
              rtDW.COM_private[i] = 0U;
            } else {
              rtDW.COM_private[i] = 3U;
            }

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

            /* DataTypeConversion: '<S645>/Data Type Conversion1' incorporates:
             *  Concatenate: '<S645>/Vector Concatenate'
             *  Constant: '<S645>/Constant5'
             *  DataStoreWrite: '<S597>/Data Store Write2'
             *  DataStoreWrite: '<S645>/Data Store Write7'
             *  Product: '<S645>/Product'
             *  RelationalOperator: '<S645>/Relational Operator'
             */
            rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
              (rtb_DataTypeConversion_bh[i] != rtDW.BUS_ADR_private[i]) *
              rtConstP.pooled79[i]);

            /* DataStoreWrite: '<S645>/Data Store Write4' incorporates:
             *  Constant: '<S645>/Constant1'
             */
            rtDW.Autos_private[i] = 1U;

            /* DataStoreWrite: '<S645>/Data Store Write2' incorporates:
             *  Constant: '<S645>/Constant10'
             */
            rtDW.Stall_private[i] = 1U;

            /* DataStoreWrite: '<S645>/Data Store Write3' incorporates:
             *  Constant: '<S645>/Constant11'
             */
            rtDW.Lnoise_private[i] = 0U;

            /* DataStoreWrite: '<S645>/Data Store Write5' incorporates:
             *  Constant: '<S645>/Constant2'
             */
            rtDW.Speed_private[i] = 3U;

            /* DataStoreWrite: '<S645>/Data Store Write6' incorporates:
             *  Constant: '<S645>/Constant3'
             */
            rtDW.Coils_private[i] = 3U;
          }

          /* Merge: '<S604>/Merge' incorporates:
           *  Constant: '<S642>/Constant1'
           *  Merge: '<S638>/Merge'
           *  SignalConversion generated from: '<S642>/Out1'
           */
          rtB.Merge_a = 3;

          /* End of Outputs for SubSystem: '<S638>/If Action Subsystem1' */
        }

        /* End of If: '<S638>/If' */
        /* End of Outputs for SubSystem: '<S623>/If Action Subsystem' */
      } else {
        /* Outputs for IfAction SubSystem: '<S623>/If Action Subsystem1' incorporates:
         *  ActionPort: '<S639>/Action Port'
         */
        IfActionSubsystem1(&rtB.Merge_a, &rtDW.CCU_ActuatorErrF_Stat_private,
                           rtDW.COM_private, rtDW.ErrorActuator,
                           rtDW.ErrorCalibration_private, &rtDW.LOGGER_LIN,
                           rtDW.MODE_private, rtDW.dtc_state_error_model);

        /* End of Outputs for SubSystem: '<S623>/If Action Subsystem1' */
      }

      /* End of If: '<S623>/If' */
      /* End of Outputs for SubSystem: '<S604>/Switch Case Action Subsystem3' */
      break;

     case 4:
      /* Outputs for IfAction SubSystem: '<S604>/Switch Case Action Subsystem4' incorporates:
       *  ActionPort: '<S624>/Action Port'
       */
      /* DataTypeConversion: '<S650>/Data Type Conversion2' incorporates:
       *  DataStoreRead: '<S650>/valves target in percent'
       */
      for (i = 0; i < 9; i++) {
        rtb_DataTypeConversion_bq[i] = (uint8_t)
          rtDW.valves_front_manual_target[i];
      }

      /* End of DataTypeConversion: '<S650>/Data Type Conversion2' */

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private[0] = rtb_DataTypeConversion_bq[8];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       *  DataStoreWrite: '<S597>/Data Store Write2'
       */
      rtDW.BUS_ADR_private[1] = rtb_DataTypeConversion_bh[1];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       *  DataStoreWrite: '<S597>/Data Store Write2'
       */
      rtDW.BUS_ADR_private[2] = rtb_DataTypeConversion_bh[2];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       *  DataStoreWrite: '<S597>/Data Store Write2'
       */
      rtDW.BUS_ADR_private[3] = rtb_DataTypeConversion_bh[3];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private[4] = rtb_DataTypeConversion_bq[1];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private[5] = rtb_DataTypeConversion_bq[0];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       *  DataStoreWrite: '<S597>/Data Store Write2'
       */
      rtDW.BUS_ADR_private[6] = rtb_DataTypeConversion_bh[6];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private[7] = rtb_DataTypeConversion_bq[6];

      /* SignalConversion generated from: '<S650>/Vector Concatenate' incorporates:
       *  Concatenate: '<S645>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private[8] = rtb_DataTypeConversion_bq[7];
      for (i = 0; i < 9; i++) {
        /* Product: '<S651>/Product' */
        rtb_Merge_j = rtDW.BUS_ADR_private[i];

        /* DataTypeConversion: '<S651>/Data Type Conversion1' incorporates:
         *  Constant: '<S651>/Constant1'
         *  DataStoreRead: '<S651>/Data Store Read'
         *  DataStoreWrite: '<S650>/Data Store Write'
         *  Product: '<S651>/Divide1'
         *  Product: '<S651>/Product'
         */
        rtDW.POS_private[i] = (uint16_t)((double)(rtb_Merge_j *
          rtDW.MaxPositionCh0_private[i]) / 100.0);

        /* RelationalOperator: '<S650>/Relational Operator1' incorporates:
         *  DataStoreWrite: '<S597>/Data Store Write2'
         */
        rtb_LogicalOperator3_i5[i] = (rtb_DataTypeConversion_bh[i] ==
          rtb_Merge_j);
      }

      /* Logic: '<S650>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_LogicalOperator3_i5[i + 1]);
      }

      for (i = 0; i < 9; i++) {
        /* Switch: '<S650>/Switch' incorporates:
         *  Constant: '<S650>/Constant4'
         *  Constant: '<S650>/Constant9'
         *  DataStoreWrite: '<S650>/Data Store Write1'
         *  Logic: '<S650>/Logical Operator'
         */
        if (rtb_LogicalOperator1) {
          rtDW.COM_private[i] = 0U;
        } else {
          rtDW.COM_private[i] = 3U;
        }

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

        /* DataTypeConversion: '<S650>/Data Type Conversion1' incorporates:
         *  Concatenate: '<S645>/Vector Concatenate'
         *  Constant: '<S650>/Constant5'
         *  DataStoreWrite: '<S597>/Data Store Write2'
         *  DataStoreWrite: '<S650>/Data Store Write7'
         *  Product: '<S650>/Product'
         *  RelationalOperator: '<S650>/Relational Operator'
         */
        rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
          (rtb_DataTypeConversion_bh[i] != rtDW.BUS_ADR_private[i]) *
          rtConstP.pooled79[i]);

        /* DataStoreWrite: '<S650>/Data Store Write4' incorporates:
         *  Constant: '<S650>/Constant1'
         */
        rtDW.Autos_private[i] = 1U;

        /* DataStoreWrite: '<S650>/Data Store Write2' incorporates:
         *  Constant: '<S650>/Constant10'
         */
        rtDW.Stall_private[i] = 1U;

        /* DataStoreWrite: '<S650>/Data Store Write3' incorporates:
         *  Constant: '<S650>/Constant11'
         */
        rtDW.Lnoise_private[i] = 0U;

        /* DataStoreWrite: '<S650>/Data Store Write5' incorporates:
         *  Constant: '<S650>/Constant2'
         */
        rtDW.Speed_private[i] = 3U;

        /* DataStoreWrite: '<S650>/Data Store Write6' incorporates:
         *  Constant: '<S650>/Constant3'
         */
        rtDW.Coils_private[i] = 3U;
      }

      /* Merge: '<S604>/Merge' incorporates:
       *  Constant: '<S624>/Constant1'
       *  SignalConversion generated from: '<S624>/step'
       */
      rtB.Merge_a = 4;

      /* End of Outputs for SubSystem: '<S604>/Switch Case Action Subsystem4' */
      break;
    }

    /* End of SwitchCase: '<S604>/Switch Case' */

    /* DataStoreWrite: '<S604>/Data Store Write2' */
    rtDW.stepHoming_private = rtB.Merge_a;

    /* Merge: '<S597>/Merge' incorporates:
     *  DataStoreRead: '<S604>/Data Store Read7'
     */
    rtB.Merge_f1 = rtDW.stepSig_private;

    /* End of Outputs for SubSystem: '<S597>/Homing' */
    break;
  }

  /* End of SwitchCase: '<S597>/Switch Case' */

  /* DataStoreWrite: '<S597>/Finish write stepSig' */
  rtDW.stepSig_private = rtB.Merge_f1;
  for (i = 0; i < 9; i++) {
    /* BusCreator: '<S600>/Bus Creator' incorporates:
     *  DataStoreRead: '<S600>/Data Store Read'
     *  DataStoreRead: '<S600>/Data Store Read1'
     *  DataStoreRead: '<S600>/Data Store Read2'
     *  DataStoreRead: '<S600>/Data Store Read3'
     *  DataStoreRead: '<S600>/Data Store Read4'
     *  DataStoreRead: '<S600>/Data Store Read5'
     *  DataStoreRead: '<S600>/Data Store Read6'
     *  DataStoreRead: '<S600>/Data Store Read7'
     *  DataStoreRead: '<S600>/Data Store Read8'
     *  DataStoreWrite: '<S600>/Data Store Write'
     */
    Actuator_Ch0_Command_Model.POS[i] = rtDW.POS_private[i];
    Actuator_Ch0_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private[i];
    Actuator_Ch0_Command_Model.MODE[i] = rtDW.MODE_private[i];
    Actuator_Ch0_Command_Model.COM[i] = rtDW.COM_private[i];
    Actuator_Ch0_Command_Model.Stall_SET[i] = rtDW.Stall_private[i];
    Actuator_Ch0_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private[i];
    Actuator_Ch0_Command_Model.Autos_SET[i] = rtDW.Autos_private[i];
    Actuator_Ch0_Command_Model.Speed_SET[i] = rtDW.Speed_private[i];
    Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private[i];

    /* RelationalOperator: '<S612>/Compare' incorporates:
     *  Constant: '<S612>/Constant'
     *  DataStoreRead: '<S601>/Data Store Read2'
     */
    rtb_LogicalOperator3_i5[i] = (rtDW.ErrorCalibration_private[i] == 0);
  }

  /* Logic: '<S601>/Logical Operator' */
  rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
  for (i = 0; i < 8; i++) {
    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_LogicalOperator3_i5[i +
      1]);
  }

  for (i = 0; i < 9; i++) {
    /* Switch: '<S601>/Switch1' incorporates:
     *  Concatenate: '<S645>/Vector Concatenate'
     *  Constant: '<S601>/Constant'
     *  Constant: '<S601>/Constant3'
     *  DataStoreRead: '<S601>/Data Store Read2'
     *  DataStoreWrite: '<S601>/Data Store Write7'
     *  Logic: '<S601>/Logical Operator'
     *  Product: '<S601>/Product'
     */
    if (rtb_LogicalOperator1) {
      rtDW.BUS_ADR_private[i] = (uint8_t)((uint32_t)
        rtDW.ErrorCalibration_private[i] * rtConstP.pooled79[i]);
    } else {
      rtDW.BUS_ADR_private[i] = 0U;
    }

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

    /* DataStoreWrite: '<S601>/Data Store Write' */
    rtDW.COM_private[i] = 0U;
  }

  /* DataTypeConversion: '<S681>/Data Type Conversion' */
  for (i = 0; i < 6; i++) {
    /* Switch: '<S681>/Switch' incorporates:
     *  Constant: '<S681>/Constant'
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreRead: '<S681>/Data Store Read'
     *  Gain: '<S681>/Gain'
     *  Product: '<S681>/Divide'
     */
    rtb_Saturation_n = rtDW.MaxPositionCh1_private[i];
    if (rtb_Saturation_n != 0) {
      rtb_rate = (double)Actuator_Ch1_Status_Model.in_CPOS_ALL[i] / (double)
        rtb_Saturation_n * 100.0;
    } else {
      rtb_rate = 0.0;
    }

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

    /* Saturate: '<S681>/Saturation' */
    if (rtb_rate > 100.0) {
      rtb_DataTypeConversion_bq[i] = 100U;
    } else if (rtb_rate < 0.0) {
      rtb_DataTypeConversion_bq[i] = 0U;
    } else {
      rtb_DataTypeConversion_bq[i] = (uint8_t)rtb_rate;
    }

    /* End of Saturate: '<S681>/Saturation' */
  }

  /* End of DataTypeConversion: '<S681>/Data Type Conversion' */

  /* SignalConversion generated from: '<S681>/Vector Concatenate' incorporates:
   *  Constant: '<S681>/Constant1'
   */
  rtb_DataTypeConversion_bq[6] = 0U;
  rtb_DataTypeConversion_bq[7] = 0U;
  rtb_DataTypeConversion_bq[8] = 0U;

  /* DataStoreWrite: '<S598>/Data Store Write2' */
  for (i = 0; i < 9; i++) {
    Actuator_pos_percent_Ch1[i] = rtb_DataTypeConversion_bq[i];
  }

  /* Switch: '<S598>/Switch' incorporates:
   *  Constant: '<S598>/Constant1'
   *  DataStoreRead: '<S598>/Data Store Read'
   *  DataStoreRead: '<S598>/Data Store Read2'
   */
  if (rtDW.stepSig_private_h > 0) {
    rtb_Switch_nyq = rtDW.stepSig_private_h;
  } else {
    rtb_Switch_nyq = 1;
  }

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

  /* SwitchCase: '<S598>/Switch Case' */
  switch (rtb_Switch_nyq) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S598>/Stop Mode' incorporates:
     *  ActionPort: '<S680>/Action Port'
     */
    /* If: '<S680>/If1' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S680>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S738>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S738>/Data Store Write1' */
        rtDW.COM_private_g[i] = 1U;

        /* DataStoreWrite: '<S738>/Data Store Write' */
        rtDW.MODE_private_b[i] = 2U;
      }

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S738>/Constant'
       *  Sum: '<S738>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S738>/Write' incorporates:
       *  DataStoreRead: '<S738>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Stop Mode\n'); */
        printf("[LIN 2] Stop Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S738>/Write' */
      /* End of Outputs for SubSystem: '<S680>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S680>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S739>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S739>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S680>/If1' */
    /* End of Outputs for SubSystem: '<S598>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S598>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S676>/Action Port'
     */
    /* If: '<S676>/If' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S676>/If Action Subsystem' incorporates:
       *  ActionPort: '<S726>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S726>/Data Store Write' */
        rtDW.POS_private_m[i] = 6000U;

        /* DataStoreWrite: '<S726>/Data Store Write1' */
        rtDW.COM_private_g[i] = 2U;
      }

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S726>/Constant'
       *  Merge: '<S676>/Merge'
       *  Sum: '<S726>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S726>/Write' incorporates:
       *  DataStoreRead: '<S726>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Initial CPOS Min\n'); */
        printf("[LIN 2] Initial CPOS Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S726>/Write' */
      /* End of Outputs for SubSystem: '<S676>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S676>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S727>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  Merge: '<S676>/Merge'
       *  SignalConversion generated from: '<S727>/stepIn1'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S676>/If' */
    /* End of Outputs for SubSystem: '<S598>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S598>/Normal Mode' incorporates:
     *  ActionPort: '<S679>/Action Port'
     */
    /* If: '<S679>/If1' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S679>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S735>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S735>/Data Store Write' */
        rtDW.MODE_private_b[i] = 0U;

        /* DataStoreWrite: '<S735>/Data Store Write1' */
        rtDW.COM_private_g[i] = 1U;
      }

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S735>/Constant'
       *  Sum: '<S735>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S735>/Write' incorporates:
       *  DataStoreRead: '<S735>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('LIN 2] Normal Mode\n'); */
        printf("LIN 2] Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S735>/Write' */
      /* End of Outputs for SubSystem: '<S679>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S679>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S736>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S736>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S679>/If1' */
    /* End of Outputs for SubSystem: '<S598>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S598>/Move to position Min' incorporates:
     *  ActionPort: '<S678>/Action Port'
     */
    /* If: '<S678>/If1' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S678>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S732>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S732>/Data Store Write4' incorporates:
         *  Constant: '<S732>/Constant1'
         */
        rtDW.Autos_private_n[i] = 1U;

        /* DataStoreWrite: '<S732>/Data Store Write2' incorporates:
         *  Constant: '<S732>/Constant10'
         */
        rtDW.Stall_private_l[i] = 1U;

        /* DataStoreWrite: '<S732>/Data Store Write3' */
        rtDW.Lnoise_private_n[i] = 0U;

        /* DataStoreWrite: '<S732>/Data Store Write5' incorporates:
         *  Constant: '<S732>/Constant2'
         */
        rtDW.Speed_private_j[i] = 3U;

        /* DataStoreWrite: '<S732>/Data Store Write6' incorporates:
         *  Constant: '<S732>/Constant3'
         */
        rtDW.Coils_private_c[i] = 3U;

        /* DataStoreWrite: '<S732>/Data Store Write' */
        rtDW.POS_private_m[i] = 0U;

        /* DataStoreWrite: '<S732>/Data Store Write1' incorporates:
         *  Constant: '<S732>/Constant9'
         */
        rtDW.COM_private_g[i] = 3U;
      }

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S732>/Constant'
       *  Sum: '<S732>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S732>/Write' incorporates:
       *  DataStoreRead: '<S732>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Move to position Min\n'); */
        printf("[LIN 2] Move to position Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S732>/Write' */
      /* End of Outputs for SubSystem: '<S678>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S678>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S733>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S733>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S678>/If1' */
    /* End of Outputs for SubSystem: '<S598>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S598>/Check Stall Min' incorporates:
     *  ActionPort: '<S673>/Action Port'
     */
    /* Logic: '<S673>/Logical Operator3' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreRead: '<S673>/Data Store Read'
     *  Logic: '<S673>/Logical Operator1'
     *  Logic: '<S673>/Logical Operator2'
     *  RelationalOperator: '<S673>/Relational Operator'
     *  RelationalOperator: '<S673>/Relational Operator1'
     */
    for (i = 0; i < 6; i++) {
      rtb_LogicalOperator3_n1[i] =
        ((Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1) ||
         (Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 0) ||
         (rtDW.ErrorCalibration_private_p[i] == 0));
    }

    /* End of Logic: '<S673>/Logical Operator3' */

    /* Logic: '<S673>/Logical Operator' incorporates:
     *  Logic: '<S673>/Logical Operator3'
     */
    rtb_LogicalOperator1 = rtb_LogicalOperator3_n1[0];
    for (i = 0; i < 5; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_n1[i
        + 1]);
    }

    /* If: '<S673>/If2' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  DataTypeConversion: '<S673>/Data Type Conversion'
     *  DataTypeConversion: '<S673>/Data Type Conversion1'
     *  Logic: '<S673>/Logical Operator'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
    {
      /* Outputs for IfAction SubSystem: '<S673>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S686>/Action Port'
       */
      /* DataStoreWrite: '<S686>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        /* Switch: '<S686>/Switch' incorporates:
         *  DataStoreRead: '<S686>/Data Store Read1'
         */
        if (rtDW.ErrorCalibration_private_p[i] != 0) {
          rtDW.MinPositionCh1_private[i] =
            Actuator_Ch1_Status_Model.in_CPOS_ALL[i];
        }

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

      /* End of DataStoreWrite: '<S686>/Data Store Write1' */

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S686>/Constant'
       *  Sum: '<S686>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S686>/Write' incorporates:
       *  DataStoreRead: '<S686>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Check Stall Min\n'); */
        printf("[LIN 2] Check Stall Min\n");
        fflush(stdout);

        /* :  for i = 1:numel(data) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('[LIN 2] MIN = %d ', int16(data(i))); */
          printf("[LIN 2] MIN = %d ", Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S686>/Write' */
      /* End of Outputs for SubSystem: '<S673>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S673>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S687>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S687>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S673>/If2' */
    /* End of Outputs for SubSystem: '<S598>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S598>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S675>/Action Port'
     */
    /* If: '<S675>/If1' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S675>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S723>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S723>/Data Store Write1' */
        rtDW.COM_private_g[i] = 2U;

        /* DataStoreWrite: '<S723>/Data Store Write' */
        rtDW.POS_private_m[i] = 0U;
      }

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S723>/Constant'
       *  Sum: '<S723>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S723>/Write' incorporates:
       *  DataStoreRead: '<S723>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Initial CPOS Max\n'); */
        printf("[LIN 2] Initial CPOS Max\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S723>/Write' */
      /* End of Outputs for SubSystem: '<S675>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S675>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S724>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S724>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S675>/If1' */
    /* End of Outputs for SubSystem: '<S598>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S598>/Move to position Max' incorporates:
     *  ActionPort: '<S677>/Action Port'
     */
    /* If: '<S677>/If1' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S677>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S729>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S729>/Data Store Write4' incorporates:
         *  Constant: '<S729>/Constant1'
         */
        rtDW.Autos_private_n[i] = 1U;

        /* DataStoreWrite: '<S729>/Data Store Write2' incorporates:
         *  Constant: '<S729>/Constant10'
         */
        rtDW.Stall_private_l[i] = 1U;

        /* DataStoreWrite: '<S729>/Data Store Write3' */
        rtDW.Lnoise_private_n[i] = 0U;

        /* DataStoreWrite: '<S729>/Data Store Write5' incorporates:
         *  Constant: '<S729>/Constant2'
         */
        rtDW.Speed_private_j[i] = 3U;

        /* DataStoreWrite: '<S729>/Data Store Write6' incorporates:
         *  Constant: '<S729>/Constant3'
         */
        rtDW.Coils_private_c[i] = 3U;

        /* DataStoreWrite: '<S729>/Data Store Write' */
        rtDW.POS_private_m[i] = 6000U;

        /* DataStoreWrite: '<S729>/Data Store Write1' incorporates:
         *  Constant: '<S729>/Constant9'
         */
        rtDW.COM_private_g[i] = 3U;
      }

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S729>/Constant'
       *  Sum: '<S729>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S729>/Write' incorporates:
       *  DataStoreRead: '<S729>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Move to position Max\n'); */
        printf("[LIN 2] Move to position Max\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S729>/Write' */
      /* End of Outputs for SubSystem: '<S677>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S677>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S730>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S730>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S677>/If1' */
    /* End of Outputs for SubSystem: '<S598>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S598>/Check Stall Max' incorporates:
     *  ActionPort: '<S672>/Action Port'
     */
    /* Logic: '<S672>/Logical Operator3' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreRead: '<S672>/Data Store Read'
     *  Logic: '<S672>/Logical Operator'
     *  Logic: '<S672>/Logical Operator2'
     *  RelationalOperator: '<S672>/Relational Operator'
     *  RelationalOperator: '<S672>/Relational Operator1'
     */
    for (i = 0; i < 6; i++) {
      rtb_LogicalOperator3_n1[i] =
        ((Actuator_Ch1_Status_Model.in_Act_Stall_Slave[i] == 1) ||
         (Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 6000) ||
         (rtDW.ErrorCalibration_private_p[i] == 0));
    }

    /* End of Logic: '<S672>/Logical Operator3' */

    /* Logic: '<S672>/Logical Operator1' incorporates:
     *  Logic: '<S672>/Logical Operator3'
     */
    rtb_LogicalOperator1 = rtb_LogicalOperator3_n1[0];
    for (i = 0; i < 5; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_LogicalOperator3_n1[i
        + 1]);
    }

    /* If: '<S672>/If2' incorporates:
     *  DataStoreRead: '<S598>/Data Store Read1'
     *  DataStoreWrite: '<S598>/Data Store Write1'
     *  DataTypeConversion: '<S672>/Data Type Conversion'
     *  DataTypeConversion: '<S672>/Data Type Conversion1'
     *  Logic: '<S672>/Logical Operator1'
     *  SignalConversion generated from: '<S598>/Bus Selector'
     */
    if ((Actuator_Ch1_Status_Model.Busy == 0) &&
        (Actuator_Ch1_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
    {
      /* Outputs for IfAction SubSystem: '<S672>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S683>/Action Port'
       */
      /* DataStoreWrite: '<S683>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        /* Switch: '<S683>/Switch' incorporates:
         *  DataStoreRead: '<S683>/Data Store Read1'
         */
        if (rtDW.ErrorCalibration_private_p[i] != 0) {
          rtDW.MaxPositionCh1_private[i] =
            Actuator_Ch1_Status_Model.in_CPOS_ALL[i];
        } else {
          rtDW.MaxPositionCh1_private[i] = 0;
        }

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

      /* End of DataStoreWrite: '<S683>/Data Store Write1' */

      /* Merge: '<S598>/Merge' incorporates:
       *  Constant: '<S683>/Constant'
       *  Sum: '<S683>/step inc'
       */
      rtB.Merge_e = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S683>/Write' incorporates:
       *  DataStoreRead: '<S683>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 2] Check Stall MAX\n'); */
        printf("[LIN 2] Check Stall MAX\n");
        fflush(stdout);

        /* :  for i = 1:numel(data) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('[LIN 2] MAX = %d ', int16(data(i))); */
          printf("[LIN 2] MAX = %d ", Actuator_Ch1_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S683>/Write' */
      /* End of Outputs for SubSystem: '<S672>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S672>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S684>/Action Port'
       */
      /* Merge: '<S598>/Merge' incorporates:
       *  SignalConversion generated from: '<S684>/stepIn'
       */
      rtB.Merge_e = rtb_Switch_nyq;

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

    /* End of If: '<S672>/If2' */
    /* End of Outputs for SubSystem: '<S598>/Check Stall Max' */
    break;

   case 9:
    /* Outputs for IfAction SubSystem: '<S598>/Homing' incorporates:
     *  ActionPort: '<S674>/Action Port'
     */
    /* Product: '<S689>/Divide1' incorporates:
     *  Constant: '<S689>/ACT1'
     *  DataStoreRead: '<S689>/MAX ACT1T '
     */
    for (i = 0; i < 6; i++) {
      rtb_Divide1_a4[i] = (double)rtDW.MaxPositionCh1_private[i] / (double)
        rtConstP.ACT1_Value_c[i];
    }

    /* End of Product: '<S689>/Divide1' */

    /* SignalConversion generated from: '<S689>/Vector Concatenate' incorporates:
     *  Constant: '<S689>/Constant'
     */
    rtb_Divide1_a4[6] = 1.0;
    rtb_Divide1_a4[7] = 1.0;
    rtb_Divide1_a4[8] = 1.0;

    /* SwitchCase: '<S674>/Switch Case' incorporates:
     *  DataStoreRead: '<S674>/Data Store Read4'
     */
    switch (rtDW.stepHoming_private_f) {
     case 0:
      /* Outputs for IfAction SubSystem: '<S674>/Switch Case Action Subsystem' incorporates:
       *  ActionPort: '<S690>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S695>/Compare' */
        rtb_rate = rtb_Divide1_a4[i];

        /* Logic: '<S690>/Logical Operator' incorporates:
         *  Constant: '<S695>/Constant'
         *  Constant: '<S696>/Constant'
         *  RelationalOperator: '<S695>/Compare'
         *  RelationalOperator: '<S696>/Compare'
         */
        rtb_LogicalOperator1 = ((rtb_rate >= 0.9) && (rtb_rate <= 1.1));
        rtb_LogicalOperator3_i5[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S698>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S698>/Data Store Read'
         *  DataStoreWrite: '<S698>/Data Store Write'
         *  Logic: '<S698>/Logical Operator'
         *  Logic: '<S698>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private_p[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private_p[i] != 0));
      }

      /* MATLAB Function: '<S690>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S690>/Data Store Read5'
       *  DataStoreRead: '<S690>/MIN ACT1T 1'
       *  Logic: '<S690>/Logical Operator2'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 2] Homing 0\n"); */
        printf("[LIN 2] Homing 0\n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 6; i++) {
          /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
          printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                 (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
                 rtb_Divide1_a4[i], (int16_t)!rtb_LogicalOperator3_i5[i]);
          fflush(stdout);
        }
      }

      /* End of MATLAB Function: '<S690>/MAX POSITION' */

      /* Logic: '<S690>/Logical Operator1' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* Switch: '<S690>/Switch' incorporates:
       *  Logic: '<S690>/Logical Operator1'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S674>/Merge' incorporates:
         *  Constant: '<S690>/Constant1'
         */
        rtB.Merge_p = 4;
      } else {
        /* Merge: '<S674>/Merge' incorporates:
         *  Constant: '<S690>/Constant'
         */
        rtB.Merge_p = 1;
      }

      /* End of Switch: '<S690>/Switch' */
      /* End of Outputs for SubSystem: '<S674>/Switch Case Action Subsystem' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S674>/Switch Case Action Subsystem1' incorporates:
       *  ActionPort: '<S691>/Action Port'
       */
      /* RelationalOperator: '<S700>/Compare' incorporates:
       *  Constant: '<S700>/Constant'
       */
      for (i = 0; i < 9; i++) {
        rtb_LogicalOperator3_i5[i] = (rtb_Divide1_a4[i] > 1.5);
      }

      /* End of RelationalOperator: '<S700>/Compare' */

      /* Logic: '<S699>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* DataTypeConversion: '<S699>/Data Type Conversion' incorporates:
       *  DataStoreWrite: '<S699>/Data Store Write1'
       *  Logic: '<S699>/Logical Operator'
       */
      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
      for (i = 0; i < 9; i++) {
        /* DataTypeConversion: '<S699>/Data Type Conversion1' incorporates:
         *  DataStoreWrite: '<S699>/Data Store Write2'
         */
        rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[i];
        rtDW.COM_private_g[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S699>/Data Type Conversion2' incorporates:
         *  DataStoreRead: '<S699>/Data Store Read'
         *  DataStoreWrite: '<S699>/Data Store Write3'
         *  Logic: '<S699>/Logical Operator1'
         */
        rtDW.ErrorActuator_o[i] = (uint8_t)(rtb_LogicalOperator1 ||
          (rtDW.ErrorActuator_o[i] != 0));

        /* DataStoreWrite: '<S699>/Data Store Write' */
        rtDW.MODE_private_b[i] = 2U;
      }

      /* MATLAB Function: '<S699>/Write ERROR' incorporates:
       *  DataStoreRead: '<S699>/Data Store Read6'
       */
      /* :  if(LOGGER>=0) */
      if (rtDW.LOGGER_LIN >= 0.0) {
        /* :  for i = 1:numel(ErrCallibration) */
        for (i = 0; i < 9; i++) {
          /* :  if ErrCallibration(i) == 1 */
          if (rtb_LogicalOperator3_i5[i]) {
            /* :  fprintf('[LIN 2] Failure with actuator #%d\n', int16(i)); */
            printf("[LIN 2] Failure with actuator #%d\n", (int16_t)(i + 1));
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S699>/Write ERROR' */
      for (i = 0; i < 9; i++) {
        /* Logic: '<S691>/Logical Operator1' */
        rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[i];

        /* DataTypeConversion: '<S691>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S691>/Data Store Read'
         *  DataStoreWrite: '<S691>/Data Store Write'
         *  Logic: '<S691>/Logical Operator'
         *  Logic: '<S691>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private_p[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private_p[i] != 0));

        /* DataStoreWrite: '<S703>/Data Store Write' incorporates:
         *  DataTypeConversion: '<S703>/Data Type Conversion'
         */
        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
      }

      /* DataStoreWrite: '<S702>/Data Store Write' incorporates:
       *  Constant: '<S702>/Constant'
       */
      rtDW.stepSig_private_h = 1;

      /* MATLAB Function: '<S691>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S691>/Data Store Read5'
       *  DataStoreRead: '<S691>/MIN ACT1T 1'
       *  DataStoreWrite: '<S691>/Data Store Write'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 2] Homing 1. Start Callibration \n"); */
        printf("[LIN 2] Homing 1. Start Callibration \n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 6; i++) {
          /* :  if(ERRORS(i)==1) */
          if (rtDW.ErrorCalibration_private_p[i] == 1) {
            /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
            printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                   (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
                   rtb_Divide1_a4[i], (int16_t)rtDW.ErrorCalibration_private_p[i]);
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S691>/MAX POSITION' */

      /* Logic: '<S691>/Logical Operator2' incorporates:
       *  DataStoreWrite: '<S691>/Data Store Write'
       */
      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private_p[0] != 0);
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          (rtDW.ErrorCalibration_private_p[i + 1] != 0));
      }

      /* Switch: '<S691>/Switch' incorporates:
       *  Logic: '<S691>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S674>/Merge' incorporates:
         *  Constant: '<S702>/Constant1'
         */
        rtB.Merge_p = 2;
      } else {
        /* Merge: '<S674>/Merge' incorporates:
         *  Constant: '<S691>/Constant1'
         */
        rtB.Merge_p = 4;
      }

      /* End of Switch: '<S691>/Switch' */
      /* End of Outputs for SubSystem: '<S674>/Switch Case Action Subsystem1' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S674>/Switch Case Action Subsystem2' incorporates:
       *  ActionPort: '<S692>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S705>/Compare' */
        rtb_rate = rtb_Divide1_a4[i];

        /* Logic: '<S692>/Logical Operator3' incorporates:
         *  Constant: '<S705>/Constant'
         *  Constant: '<S706>/Constant'
         *  DataStoreRead: '<S692>/Data Store Read'
         *  Logic: '<S692>/Logical Operator1'
         *  Logic: '<S692>/Logical Operator4'
         *  RelationalOperator: '<S705>/Compare'
         *  RelationalOperator: '<S706>/Compare'
         */
        rtb_LogicalOperator1 = (((rtb_rate < 0.97) || (rtb_rate > 1.03)) &&
          (rtDW.ErrorCalibration_private_p[i] != 0));
        rtb_LogicalOperator3_i5[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S692>/Data Type Conversion' incorporates:
         *  DataStoreWrite: '<S692>/Data Store Write1'
         */
        rtDW.ErrorCalibration_private_p[i] = rtb_LogicalOperator1;
      }

      /* MATLAB Function: '<S692>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S692>/Data Store Read5'
       *  DataStoreRead: '<S692>/MIN ACT1T 1'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 2] Homing 3. Callibration \n"); */
        printf("[LIN 2] Homing 3. Callibration \n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 6; i++) {
          /* :  if(ERRORS(i)==1) */
          if (rtb_LogicalOperator3_i5[i]) {
            /* :  fprintf('[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
            printf("[LIN 2] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                   (int16_t)(i + 1), rtDW.MaxPositionCh1_private[i],
                   rtb_Divide1_a4[i], 1);
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S692>/MAX POSITION' */

      /* Logic: '<S692>/Logical Operator2' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* Switch: '<S692>/Switch' incorporates:
       *  Logic: '<S692>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S674>/Merge' incorporates:
         *  Constant: '<S692>/Constant3'
         */
        rtB.Merge_p = 3;
      } else {
        /* Merge: '<S674>/Merge' incorporates:
         *  Constant: '<S692>/Constant1'
         */
        rtB.Merge_p = 4;
      }

      /* End of Switch: '<S692>/Switch' */
      /* End of Outputs for SubSystem: '<S674>/Switch Case Action Subsystem2' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S674>/Switch Case Action Subsystem3' incorporates:
       *  ActionPort: '<S693>/Action Port'
       */
      /* MATLAB Function: '<S693>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S693>/Data Store Read1'
       *  DataStoreRead: '<S693>/Data Store Read5'
       */
      /* :  if(LOGGER>1) */
      if (rtDW.LOGGER_LIN > 1.0) {
        /* :  fprintf("[LIN 2] Homing 3. Start Time on step %d\n",int16(step)); */
        rtb_rate = rt_roundd(rtDW.ErrorHomming_private_h);
        if (rtb_rate < 32768.0) {
          if (rtb_rate >= -32768.0) {
            rtb_Saturation_n = (int16_t)rtb_rate;
          } else {
            rtb_Saturation_n = INT16_MIN;
          }
        } else {
          rtb_Saturation_n = INT16_MAX;
        }

        printf("[LIN 2] Homing 3. Start Time on step %d\n", rtb_Saturation_n);
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S693>/MAX POSITION' */

      /* If: '<S693>/If' incorporates:
       *  DataStoreRead: '<S693>/Data Store Read1'
       */
      if (rtDW.ErrorHomming_private_h < 10.0) {
        /* Outputs for IfAction SubSystem: '<S693>/If Action Subsystem' incorporates:
         *  ActionPort: '<S708>/Action Port'
         */
        /* MATLAB Function: '<S708>/MATLAB Function' incorporates:
         *  DataStoreRead: '<S708>/Data Store Read'
         *  DataStoreRead: '<S708>/Data Store Read1'
         */
        MATLABFunction(rtDW.Start_timer_j, rtDW.t_now, &rtb_dt_an,
                       &rtDW.sf_MATLABFunction_h);

        /* MATLAB Function: '<S708>/MAX POSITION' incorporates:
         *  DataStoreRead: '<S708>/Data Store Read5'
         */
        /* :  if(LOGGER>1) */
        if (rtDW.LOGGER_LIN > 1.0) {
          /* :  fprintf("[LIN 2] Homing 3. Start TIme dt = %d \n",int32(data)); */
          rtb_Subtract = rtb_dt_an;
          if (rtb_dt_an > 2147483647U) {
            rtb_Subtract = 2147483647U;
          }

          printf("[LIN 2] Homing 3. Start TIme dt = %d \n", (int32_t)
                 rtb_Subtract);
          fflush(stdout);
        }

        /* End of MATLAB Function: '<S708>/MAX POSITION' */

        /* If: '<S708>/If' */
        if (rtb_dt_an > 30000U) {
          /* Outputs for IfAction SubSystem: '<S708>/If Action Subsystem' incorporates:
           *  ActionPort: '<S711>/Action Port'
           */
          /* Merge: '<S674>/Merge' */
          IfActionSubsystem(&rtB.Merge_p, &rtDW.ErrorHomming_private_h,
                            &rtDW.Start_timer_j, &rtDW.stepSig_private_h);

          /* End of Outputs for SubSystem: '<S708>/If Action Subsystem' */
        } else {
          /* Outputs for IfAction SubSystem: '<S708>/If Action Subsystem1' incorporates:
           *  ActionPort: '<S712>/Action Port'
           */
          /* DataStoreWrite: '<S712>/Data Store Write2' incorporates:
           *  Constant: '<S712>/Constant3'
           */
          rtDW.Start_timer_j = 1.0;

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           *  DataStoreWrite: '<S598>/Data Store Write2'
           */
          rtDW.BUS_ADR_private_j[0] = rtb_DataTypeConversion_bq[0];

          /* DataTypeConversion: '<S715>/Data Type Conversion2' incorporates:
           *  DataStoreRead: '<S715>/valves target in percent'
           */
          for (i = 0; i < 9; i++) {
            rtb_DataTypeConversion_fb[i] = (uint8_t)
              rtDW.valves_front_manual_target[i];
          }

          /* End of DataTypeConversion: '<S715>/Data Type Conversion2' */

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           */
          rtDW.BUS_ADR_private_j[1] = rtb_DataTypeConversion_fb[2];

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           */
          rtDW.BUS_ADR_private_j[2] = rtb_DataTypeConversion_fb[3];

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           *  DataStoreWrite: '<S598>/Data Store Write2'
           */
          rtDW.BUS_ADR_private_j[3] = rtb_DataTypeConversion_bq[3];

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           */
          rtDW.BUS_ADR_private_j[4] = rtb_DataTypeConversion_fb[4];

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           */
          rtDW.BUS_ADR_private_j[5] = rtb_DataTypeConversion_fb[5];

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           *  Constant: '<S715>/Constant'
           */
          rtDW.BUS_ADR_private_j[6] = 0U;

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           *  Constant: '<S715>/Constant'
           */
          rtDW.BUS_ADR_private_j[7] = 0U;

          /* SignalConversion generated from: '<S715>/LIN1' incorporates:
           *  Concatenate: '<S715>/LIN1'
           *  Constant: '<S715>/Constant'
           */
          rtDW.BUS_ADR_private_j[8] = 0U;
          for (i = 0; i < 9; i++) {
            /* Product: '<S716>/Product' */
            rtb_Merge_j = rtDW.BUS_ADR_private_j[i];

            /* DataTypeConversion: '<S716>/Data Type Conversion1' incorporates:
             *  Constant: '<S716>/Constant1'
             *  DataStoreRead: '<S716>/Data Store Read'
             *  DataStoreWrite: '<S715>/Data Store Write'
             *  Product: '<S716>/Divide1'
             *  Product: '<S716>/Product'
             */
            rtDW.POS_private_m[i] = (uint16_t)((double)(rtb_Merge_j *
              rtDW.MaxPositionCh1_private[i]) / 100.0);

            /* RelationalOperator: '<S715>/Relational Operator1' incorporates:
             *  DataStoreWrite: '<S598>/Data Store Write2'
             */
            rtb_LogicalOperator3_i5[i] = (rtb_DataTypeConversion_bq[i] ==
              rtb_Merge_j);
          }

          /* Logic: '<S715>/Logical Operator' */
          rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
          for (i = 0; i < 8; i++) {
            rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
              rtb_LogicalOperator3_i5[i + 1]);
          }

          for (i = 0; i < 9; i++) {
            /* Switch: '<S715>/Switch' incorporates:
             *  Constant: '<S715>/Constant4'
             *  Constant: '<S715>/Constant9'
             *  DataStoreWrite: '<S715>/Data Store Write1'
             *  Logic: '<S715>/Logical Operator'
             */
            if (rtb_LogicalOperator1) {
              rtDW.COM_private_g[i] = 0U;
            } else {
              rtDW.COM_private_g[i] = 3U;
            }

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

            /* DataTypeConversion: '<S715>/Data Type Conversion1' incorporates:
             *  Concatenate: '<S715>/LIN1'
             *  Constant: '<S715>/Constant5'
             *  DataStoreWrite: '<S598>/Data Store Write2'
             *  DataStoreWrite: '<S715>/Data Store Write7'
             *  Product: '<S715>/Product'
             *  RelationalOperator: '<S715>/Relational Operator'
             */
            rtDW.BUS_ADR_private_j[i] = (uint8_t)((uint32_t)
              (rtb_DataTypeConversion_bq[i] != rtDW.BUS_ADR_private_j[i]) *
              rtConstP.pooled79[i]);

            /* DataStoreWrite: '<S715>/Data Store Write4' incorporates:
             *  Constant: '<S715>/Constant1'
             */
            rtDW.Autos_private_n[i] = 1U;

            /* DataStoreWrite: '<S715>/Data Store Write2' incorporates:
             *  Constant: '<S715>/Constant10'
             */
            rtDW.Stall_private_l[i] = 1U;

            /* DataStoreWrite: '<S715>/Data Store Write3' incorporates:
             *  Constant: '<S715>/Constant11'
             */
            rtDW.Lnoise_private_n[i] = 0U;

            /* DataStoreWrite: '<S715>/Data Store Write5' incorporates:
             *  Constant: '<S715>/Constant2'
             */
            rtDW.Speed_private_j[i] = 3U;

            /* DataStoreWrite: '<S715>/Data Store Write6' incorporates:
             *  Constant: '<S715>/Constant3'
             */
            rtDW.Coils_private_c[i] = 3U;
          }

          /* Merge: '<S674>/Merge' incorporates:
           *  Constant: '<S712>/Constant1'
           *  Merge: '<S708>/Merge'
           *  SignalConversion generated from: '<S712>/Out1'
           */
          rtB.Merge_p = 3;

          /* End of Outputs for SubSystem: '<S708>/If Action Subsystem1' */
        }

        /* End of If: '<S708>/If' */
        /* End of Outputs for SubSystem: '<S693>/If Action Subsystem' */
      } else {
        /* Outputs for IfAction SubSystem: '<S693>/If Action Subsystem1' incorporates:
         *  ActionPort: '<S709>/Action Port'
         */
        IfActionSubsystem1(&rtB.Merge_p, &rtDW.CCU_ActuatorErrF_Stat_private,
                           rtDW.COM_private_g, rtDW.ErrorActuator_o,
                           rtDW.ErrorCalibration_private_p, &rtDW.LOGGER_LIN,
                           rtDW.MODE_private_b, rtDW.dtc_state_error_model);

        /* End of Outputs for SubSystem: '<S693>/If Action Subsystem1' */
      }

      /* End of If: '<S693>/If' */
      /* End of Outputs for SubSystem: '<S674>/Switch Case Action Subsystem3' */
      break;

     case 4:
      /* Outputs for IfAction SubSystem: '<S674>/Switch Case Action Subsystem4' incorporates:
       *  ActionPort: '<S694>/Action Port'
       */
      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       *  DataStoreWrite: '<S598>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_j[0] = rtb_DataTypeConversion_bq[0];

      /* DataTypeConversion: '<S721>/Data Type Conversion2' incorporates:
       *  DataStoreRead: '<S721>/valves target in percent'
       */
      for (i = 0; i < 9; i++) {
        rtb_DataTypeConversion_fb[i] = (uint8_t)
          rtDW.valves_front_manual_target[i];
      }

      /* End of DataTypeConversion: '<S721>/Data Type Conversion2' */

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       */
      rtDW.BUS_ADR_private_j[1] = rtb_DataTypeConversion_fb[2];

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       */
      rtDW.BUS_ADR_private_j[2] = rtb_DataTypeConversion_fb[3];

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       *  DataStoreWrite: '<S598>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_j[3] = rtb_DataTypeConversion_bq[3];

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       */
      rtDW.BUS_ADR_private_j[4] = rtb_DataTypeConversion_fb[4];

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       */
      rtDW.BUS_ADR_private_j[5] = rtb_DataTypeConversion_fb[5];

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       *  DataStoreWrite: '<S598>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_j[6] = 0U;

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       *  DataStoreWrite: '<S598>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_j[7] = 0U;

      /* SignalConversion generated from: '<S721>/LIN1' incorporates:
       *  Concatenate: '<S715>/LIN1'
       *  DataStoreWrite: '<S598>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_j[8] = 0U;
      for (i = 0; i < 9; i++) {
        /* Product: '<S722>/Product' */
        rtb_Merge_j = rtDW.BUS_ADR_private_j[i];

        /* DataTypeConversion: '<S722>/Data Type Conversion1' incorporates:
         *  Constant: '<S722>/Constant1'
         *  DataStoreRead: '<S722>/Data Store Read'
         *  DataStoreWrite: '<S721>/Data Store Write'
         *  Product: '<S722>/Divide1'
         *  Product: '<S722>/Product'
         */
        rtDW.POS_private_m[i] = (uint16_t)((double)(rtb_Merge_j *
          rtDW.MaxPositionCh1_private[i]) / 100.0);

        /* RelationalOperator: '<S721>/Relational Operator1' incorporates:
         *  DataStoreWrite: '<S598>/Data Store Write2'
         */
        rtb_LogicalOperator3_i5[i] = (rtb_DataTypeConversion_bq[i] ==
          rtb_Merge_j);
      }

      /* Logic: '<S721>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_LogicalOperator3_i5[i + 1]);
      }

      for (i = 0; i < 9; i++) {
        /* Switch: '<S721>/Switch' incorporates:
         *  Constant: '<S721>/Constant4'
         *  Constant: '<S721>/Constant9'
         *  DataStoreWrite: '<S721>/Data Store Write1'
         *  Logic: '<S721>/Logical Operator'
         */
        if (rtb_LogicalOperator1) {
          rtDW.COM_private_g[i] = 0U;
        } else {
          rtDW.COM_private_g[i] = 3U;
        }

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

        /* DataTypeConversion: '<S721>/Data Type Conversion1' incorporates:
         *  Concatenate: '<S715>/LIN1'
         *  Constant: '<S721>/Constant5'
         *  DataStoreWrite: '<S598>/Data Store Write2'
         *  DataStoreWrite: '<S721>/Data Store Write7'
         *  Product: '<S721>/Product'
         *  RelationalOperator: '<S721>/Relational Operator'
         */
        rtDW.BUS_ADR_private_j[i] = (uint8_t)((uint32_t)
          (rtb_DataTypeConversion_bq[i] != rtDW.BUS_ADR_private_j[i]) *
          rtConstP.pooled79[i]);

        /* DataStoreWrite: '<S721>/Data Store Write4' incorporates:
         *  Constant: '<S721>/Constant1'
         */
        rtDW.Autos_private_n[i] = 1U;

        /* DataStoreWrite: '<S721>/Data Store Write2' incorporates:
         *  Constant: '<S721>/Constant10'
         */
        rtDW.Stall_private_l[i] = 1U;

        /* DataStoreWrite: '<S721>/Data Store Write3' incorporates:
         *  Constant: '<S721>/Constant11'
         */
        rtDW.Lnoise_private_n[i] = 0U;

        /* DataStoreWrite: '<S721>/Data Store Write5' incorporates:
         *  Constant: '<S721>/Constant2'
         */
        rtDW.Speed_private_j[i] = 3U;

        /* DataStoreWrite: '<S721>/Data Store Write6' incorporates:
         *  Constant: '<S721>/Constant3'
         */
        rtDW.Coils_private_c[i] = 3U;
      }

      /* Merge: '<S674>/Merge' incorporates:
       *  Constant: '<S694>/Constant1'
       *  SignalConversion generated from: '<S694>/step'
       */
      rtB.Merge_p = 4;

      /* MATLAB Function: '<S694>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S694>/Data Store Read5'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 2] Homing. Callibration successful \n"); */
        printf("[LIN 2] Homing. Callibration successful \n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S694>/MAX POSITION' */
      /* End of Outputs for SubSystem: '<S674>/Switch Case Action Subsystem4' */
      break;
    }

    /* End of SwitchCase: '<S674>/Switch Case' */

    /* DataStoreWrite: '<S674>/Data Store Write2' */
    rtDW.stepHoming_private_f = rtB.Merge_p;

    /* Merge: '<S598>/Merge' incorporates:
     *  DataStoreRead: '<S674>/Data Store Read7'
     */
    rtB.Merge_e = rtDW.stepSig_private_h;

    /* End of Outputs for SubSystem: '<S598>/Homing' */
    break;
  }

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

  /* DataStoreWrite: '<S598>/Finish write stepSig' */
  rtDW.stepSig_private_h = rtB.Merge_e;

  /* BusCreator: '<S670>/Bus Creator' incorporates:
   *  DataStoreRead: '<S670>/Data Store Read'
   *  DataStoreRead: '<S670>/Data Store Read1'
   *  DataStoreRead: '<S670>/Data Store Read2'
   *  DataStoreRead: '<S670>/Data Store Read3'
   *  DataStoreRead: '<S670>/Data Store Read4'
   *  DataStoreRead: '<S670>/Data Store Read5'
   *  DataStoreRead: '<S670>/Data Store Read6'
   *  DataStoreRead: '<S670>/Data Store Read7'
   *  DataStoreRead: '<S670>/Data Store Read8'
   *  DataStoreWrite: '<S670>/Data Store Write'
   */
  for (i = 0; i < 9; i++) {
    Actuator_Ch1_Command_Model.POS[i] = rtDW.POS_private_m[i];
    Actuator_Ch1_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_j[i];
    Actuator_Ch1_Command_Model.MODE[i] = rtDW.MODE_private_b[i];
    Actuator_Ch1_Command_Model.COM[i] = rtDW.COM_private_g[i];
    Actuator_Ch1_Command_Model.Stall_SET[i] = rtDW.Stall_private_l[i];
    Actuator_Ch1_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_n[i];
    Actuator_Ch1_Command_Model.Autos_SET[i] = rtDW.Autos_private_n[i];
    Actuator_Ch1_Command_Model.Speed_SET[i] = rtDW.Speed_private_j[i];
    Actuator_Ch1_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_c[i];
  }

  /* End of BusCreator: '<S670>/Bus Creator' */

  /* RelationalOperator: '<S682>/Compare' incorporates:
   *  Constant: '<S682>/Constant'
   *  DataStoreRead: '<S671>/Data Store Read2'
   */
  for (i = 0; i < 6; i++) {
    rtb_Compare_n[i] = (rtDW.ErrorCalibration_private_p[i] == 0);
  }

  /* End of RelationalOperator: '<S682>/Compare' */

  /* Logic: '<S671>/Logical Operator' */
  rtb_LogicalOperator1 = rtb_Compare_n[0];
  for (i = 0; i < 5; i++) {
    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_Compare_n[i + 1]);
  }

  /* Switch: '<S671>/Switch1' incorporates:
   *  Constant: '<S671>/Constant'
   *  Constant: '<S671>/Constant3'
   *  DataStoreRead: '<S671>/Data Store Read2'
   *  Logic: '<S671>/Logical Operator'
   *  Product: '<S671>/Product'
   */
  for (i = 0; i < 6; i++) {
    if (rtb_LogicalOperator1) {
      rtb_DataTypeConversion_bq[i] = (uint8_t)((uint32_t)
        rtDW.ErrorCalibration_private_p[i] * rtConstP.Constant3_Value[i]);
    } else {
      rtb_DataTypeConversion_bq[i] = 0U;
    }
  }

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

  /* SignalConversion generated from: '<S671>/Vector Concatenate' incorporates:
   *  Constant: '<S671>/Constant1'
   */
  rtb_DataTypeConversion_bq[6] = 0U;
  rtb_DataTypeConversion_bq[7] = 0U;
  rtb_DataTypeConversion_bq[8] = 0U;
  for (i = 0; i < 9; i++) {
    /* DataStoreWrite: '<S671>/Data Store Write7' incorporates:
     *  Concatenate: '<S715>/LIN1'
     */
    rtDW.BUS_ADR_private_j[i] = rtb_DataTypeConversion_bq[i];

    /* DataStoreWrite: '<S671>/Data Store Write' */
    rtDW.COM_private_g[i] = 0U;
  }

  /* DataTypeConversion: '<S752>/Data Type Conversion' */
  for (i = 0; i < 8; i++) {
    /* Switch: '<S752>/Switch' incorporates:
     *  Constant: '<S752>/Constant'
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreRead: '<S752>/Data Store Read'
     *  Gain: '<S752>/Gain'
     *  Product: '<S752>/Divide'
     */
    rtb_Saturation_n = rtDW.MaxPositionCh2_private[i];
    if (rtb_Saturation_n != 0) {
      rtb_rate = (double)Actuator_Ch2_Status_Model.in_CPOS_ALL[i] / (double)
        rtb_Saturation_n * 100.0;
    } else {
      rtb_rate = 0.0;
    }

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

    /* Saturate: '<S752>/Saturation' */
    if (rtb_rate > 100.0) {
      rtb_DataTypeConversion_bq[i] = 100U;
    } else if (rtb_rate < 0.0) {
      rtb_DataTypeConversion_bq[i] = 0U;
    } else {
      rtb_DataTypeConversion_bq[i] = (uint8_t)rtb_rate;
    }

    /* End of Saturate: '<S752>/Saturation' */
  }

  /* End of DataTypeConversion: '<S752>/Data Type Conversion' */

  /* SignalConversion generated from: '<S752>/Vector Concatenate' incorporates:
   *  Constant: '<S752>/Constant1'
   */
  rtb_DataTypeConversion_bq[8] = 0U;

  /* DataStoreWrite: '<S599>/Data Store Write2' */
  for (i = 0; i < 9; i++) {
    rtb_DataTypeConversion_fb[i] = rtb_DataTypeConversion_bq[i];
  }

  /* Switch: '<S599>/Switch' incorporates:
   *  Constant: '<S599>/Constant1'
   *  DataStoreRead: '<S599>/Data Store Read'
   *  DataStoreRead: '<S599>/Data Store Read2'
   */
  if (rtDW.stepSig_private_g > 0) {
    rtb_Switch_nyq = rtDW.stepSig_private_g;
  } else {
    rtb_Switch_nyq = 1;
  }

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

  /* SwitchCase: '<S599>/Switch Case' */
  switch (rtb_Switch_nyq) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S599>/Stop Mode' incorporates:
     *  ActionPort: '<S751>/Action Port'
     */
    /* If: '<S751>/If1' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S751>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S809>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S809>/Data Store Write1' */
        rtDW.COM_private_k[i] = 1U;

        /* DataStoreWrite: '<S809>/Data Store Write' */
        rtDW.MODE_private_c[i] = 2U;
      }

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S809>/Constant'
       *  Sum: '<S809>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S809>/Write' incorporates:
       *  DataStoreRead: '<S809>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Stop Mode\n'); */
        printf("[LIN 3] Stop Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S809>/Write' */
      /* End of Outputs for SubSystem: '<S751>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S751>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S810>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S810>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S751>/If1' */
    /* End of Outputs for SubSystem: '<S599>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S599>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S747>/Action Port'
     */
    /* If: '<S747>/If' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S747>/If Action Subsystem' incorporates:
       *  ActionPort: '<S797>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S797>/Data Store Write' */
        rtDW.POS_private_h[i] = 6000U;

        /* DataStoreWrite: '<S797>/Data Store Write1' */
        rtDW.COM_private_k[i] = 2U;
      }

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S797>/Constant'
       *  Merge: '<S747>/Merge'
       *  Sum: '<S797>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S797>/Write' incorporates:
       *  DataStoreRead: '<S797>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Initial CPOS Min\n'); */
        printf("[LIN 3] Initial CPOS Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S797>/Write' */
      /* End of Outputs for SubSystem: '<S747>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S747>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S798>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  Merge: '<S747>/Merge'
       *  SignalConversion generated from: '<S798>/stepIn1'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S747>/If' */
    /* End of Outputs for SubSystem: '<S599>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S599>/Normal Mode' incorporates:
     *  ActionPort: '<S750>/Action Port'
     */
    /* If: '<S750>/If1' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S750>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S806>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S806>/Data Store Write' */
        rtDW.MODE_private_c[i] = 0U;

        /* DataStoreWrite: '<S806>/Data Store Write1' */
        rtDW.COM_private_k[i] = 1U;
      }

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S806>/Constant'
       *  Sum: '<S806>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S806>/Write' incorporates:
       *  DataStoreRead: '<S806>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Normal Mode\n'); */
        printf("[LIN 3] Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S806>/Write' */
      /* End of Outputs for SubSystem: '<S750>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S750>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S807>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S807>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S750>/If1' */
    /* End of Outputs for SubSystem: '<S599>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S599>/Move to position Min' incorporates:
     *  ActionPort: '<S749>/Action Port'
     */
    /* If: '<S749>/If1' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S749>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S803>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S803>/Data Store Write4' incorporates:
         *  Constant: '<S803>/Constant1'
         */
        rtDW.Autos_private_g[i] = 1U;

        /* DataStoreWrite: '<S803>/Data Store Write2' incorporates:
         *  Constant: '<S803>/Constant10'
         */
        rtDW.Stall_private_f[i] = 1U;

        /* DataStoreWrite: '<S803>/Data Store Write3' */
        rtDW.Lnoise_private_g[i] = 0U;

        /* DataStoreWrite: '<S803>/Data Store Write5' incorporates:
         *  Constant: '<S803>/Constant2'
         */
        rtDW.Speed_private_b[i] = 3U;

        /* DataStoreWrite: '<S803>/Data Store Write6' incorporates:
         *  Constant: '<S803>/Constant3'
         */
        rtDW.Coils_private_l[i] = 3U;

        /* DataStoreWrite: '<S803>/Data Store Write' */
        rtDW.POS_private_h[i] = 0U;

        /* DataStoreWrite: '<S803>/Data Store Write1' incorporates:
         *  Constant: '<S803>/Constant9'
         */
        rtDW.COM_private_k[i] = 3U;
      }

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S803>/Constant'
       *  Sum: '<S803>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S803>/Write' incorporates:
       *  DataStoreRead: '<S803>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Move to position Min\n'); */
        printf("[LIN 3] Move to position Min\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S803>/Write' */
      /* End of Outputs for SubSystem: '<S749>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S749>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S804>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S804>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S749>/If1' */
    /* End of Outputs for SubSystem: '<S599>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S599>/Check Stall Min' incorporates:
     *  ActionPort: '<S744>/Action Port'
     */
    /* Logic: '<S744>/Logical Operator3' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreRead: '<S744>/Data Store Read'
     *  Logic: '<S744>/Logical Operator1'
     *  Logic: '<S744>/Logical Operator2'
     *  RelationalOperator: '<S744>/Relational Operator'
     *  RelationalOperator: '<S744>/Relational Operator1'
     */
    for (i = 0; i < 8; i++) {
      rtb_Compare_n[i] = ((Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1)
                          || (Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 0) ||
                          (rtDW.ErrorCalibration_private_b[i] == 0));
    }

    /* End of Logic: '<S744>/Logical Operator3' */

    /* Logic: '<S744>/Logical Operator' incorporates:
     *  Logic: '<S744>/Logical Operator3'
     */
    rtb_LogicalOperator1 = rtb_Compare_n[0];
    for (i = 0; i < 7; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_Compare_n[i + 1]);
    }

    /* If: '<S744>/If2' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  DataTypeConversion: '<S744>/Data Type Conversion'
     *  DataTypeConversion: '<S744>/Data Type Conversion1'
     *  Logic: '<S744>/Logical Operator'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
    {
      /* Outputs for IfAction SubSystem: '<S744>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S757>/Action Port'
       */
      /* DataStoreWrite: '<S757>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        /* Switch: '<S757>/Switch' incorporates:
         *  DataStoreRead: '<S757>/Data Store Read1'
         */
        if (rtDW.ErrorCalibration_private_b[i] != 0) {
          rtDW.MinPositionCh2_private[i] =
            Actuator_Ch2_Status_Model.in_CPOS_ALL[i];
        }

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

      /* End of DataStoreWrite: '<S757>/Data Store Write1' */

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S757>/Constant'
       *  Sum: '<S757>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S757>/Write' incorporates:
       *  DataStoreRead: '<S757>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Check Stall Min\n'); */
        printf("[LIN 3] Check Stall Min\n");
        fflush(stdout);

        /* :  for i = 1:numel(data) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('[LIN 3] MIN = %d ', int16(data(i))); */
          printf("[LIN 3] MIN = %d ", Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S757>/Write' */
      /* End of Outputs for SubSystem: '<S744>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S744>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S758>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S758>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S744>/If2' */
    /* End of Outputs for SubSystem: '<S599>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S599>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S746>/Action Port'
     */
    /* If: '<S746>/If1' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S746>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S794>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S794>/Data Store Write1' */
        rtDW.COM_private_k[i] = 2U;

        /* DataStoreWrite: '<S794>/Data Store Write' */
        rtDW.POS_private_h[i] = 0U;
      }

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S794>/Constant'
       *  Sum: '<S794>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S794>/Write' incorporates:
       *  DataStoreRead: '<S794>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Initial CPOS Max\n'); */
        printf("[LIN 3] Initial CPOS Max\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S794>/Write' */
      /* End of Outputs for SubSystem: '<S746>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S746>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S795>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S795>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S746>/If1' */
    /* End of Outputs for SubSystem: '<S599>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S599>/Move to position Max' incorporates:
     *  ActionPort: '<S748>/Action Port'
     */
    /* If: '<S748>/If1' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S748>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S800>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* DataStoreWrite: '<S800>/Data Store Write4' incorporates:
         *  Constant: '<S800>/Constant1'
         */
        rtDW.Autos_private_g[i] = 1U;

        /* DataStoreWrite: '<S800>/Data Store Write2' incorporates:
         *  Constant: '<S800>/Constant10'
         */
        rtDW.Stall_private_f[i] = 1U;

        /* DataStoreWrite: '<S800>/Data Store Write3' */
        rtDW.Lnoise_private_g[i] = 0U;

        /* DataStoreWrite: '<S800>/Data Store Write5' incorporates:
         *  Constant: '<S800>/Constant2'
         */
        rtDW.Speed_private_b[i] = 3U;

        /* DataStoreWrite: '<S800>/Data Store Write6' incorporates:
         *  Constant: '<S800>/Constant3'
         */
        rtDW.Coils_private_l[i] = 3U;

        /* DataStoreWrite: '<S800>/Data Store Write' */
        rtDW.POS_private_h[i] = 6000U;

        /* DataStoreWrite: '<S800>/Data Store Write1' incorporates:
         *  Constant: '<S800>/Constant9'
         */
        rtDW.COM_private_k[i] = 3U;
      }

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S800>/Constant'
       *  Sum: '<S800>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S800>/Write' incorporates:
       *  DataStoreRead: '<S800>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Move to position Max\n'); */
        printf("[LIN 3] Move to position Max\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S800>/Write' */
      /* End of Outputs for SubSystem: '<S748>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S748>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S801>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S801>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S748>/If1' */
    /* End of Outputs for SubSystem: '<S599>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S599>/Check Stall Max' incorporates:
     *  ActionPort: '<S743>/Action Port'
     */
    /* Logic: '<S743>/Logical Operator3' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreRead: '<S743>/Data Store Read'
     *  Logic: '<S743>/Logical Operator'
     *  Logic: '<S743>/Logical Operator2'
     *  RelationalOperator: '<S743>/Relational Operator'
     *  RelationalOperator: '<S743>/Relational Operator1'
     */
    for (i = 0; i < 8; i++) {
      rtb_Compare_n[i] = ((Actuator_Ch2_Status_Model.in_Act_Stall_Slave[i] == 1)
                          || (Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 6000) ||
                          (rtDW.ErrorCalibration_private_b[i] == 0));
    }

    /* End of Logic: '<S743>/Logical Operator3' */

    /* Logic: '<S743>/Logical Operator1' incorporates:
     *  Logic: '<S743>/Logical Operator3'
     */
    rtb_LogicalOperator1 = rtb_Compare_n[0];
    for (i = 0; i < 7; i++) {
      rtb_LogicalOperator1 = (rtb_LogicalOperator1 && rtb_Compare_n[i + 1]);
    }

    /* If: '<S743>/If2' incorporates:
     *  DataStoreRead: '<S599>/Data Store Read1'
     *  DataStoreWrite: '<S599>/Data Store Write1'
     *  DataTypeConversion: '<S743>/Data Type Conversion'
     *  DataTypeConversion: '<S743>/Data Type Conversion1'
     *  Logic: '<S743>/Logical Operator1'
     *  SignalConversion generated from: '<S599>/Bus Selector'
     */
    if ((Actuator_Ch2_Status_Model.Busy == 0) &&
        (Actuator_Ch2_Status_Model.Error_Connect == 0) && rtb_LogicalOperator1)
    {
      /* Outputs for IfAction SubSystem: '<S743>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S754>/Action Port'
       */
      /* DataStoreWrite: '<S754>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        /* Switch: '<S754>/Switch' incorporates:
         *  DataStoreRead: '<S754>/Data Store Read1'
         */
        if (rtDW.ErrorCalibration_private_b[i] != 0) {
          rtDW.MaxPositionCh2_private[i] =
            Actuator_Ch2_Status_Model.in_CPOS_ALL[i];
        } else {
          rtDW.MaxPositionCh2_private[i] = 0;
        }

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

      /* End of DataStoreWrite: '<S754>/Data Store Write1' */

      /* Merge: '<S599>/Merge' incorporates:
       *  Constant: '<S754>/Constant'
       *  Sum: '<S754>/step inc'
       */
      rtB.Merge_b4 = (int8_t)(rtb_Switch_nyq + 1);

      /* MATLAB Function: '<S754>/Write' incorporates:
       *  DataStoreRead: '<S754>/Data Store Read3'
       */
      /* :  if(LOGGER == 2) */
      if (rtDW.LOGGER_LIN == 2.0) {
        /* :  fprintf('[LIN 3] Check Stall MAX\n'); */
        printf("[LIN 3] Check Stall MAX\n");
        fflush(stdout);

        /* :  for i = 1:numel(data) */
        for (i = 0; i < 9; i++) {
          /* :  fprintf('[LIN 3] MAX = %d ', int16(data(i))); */
          printf("[LIN 3] MAX = %d ", Actuator_Ch2_Status_Model.in_CPOS_ALL[i]);
          fflush(stdout);
        }

        /* :  fprintf('\n'); */
        printf("\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S754>/Write' */
      /* End of Outputs for SubSystem: '<S743>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S743>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S755>/Action Port'
       */
      /* Merge: '<S599>/Merge' incorporates:
       *  SignalConversion generated from: '<S755>/stepIn'
       */
      rtB.Merge_b4 = rtb_Switch_nyq;

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

    /* End of If: '<S743>/If2' */
    /* End of Outputs for SubSystem: '<S599>/Check Stall Max' */
    break;

   case 9:
    /* Outputs for IfAction SubSystem: '<S599>/Homing' incorporates:
     *  ActionPort: '<S745>/Action Port'
     */
    /* Product: '<S760>/Divide1' incorporates:
     *  Constant: '<S760>/ACT1'
     *  DataStoreRead: '<S760>/MAX ACT1T '
     */
    for (i = 0; i < 8; i++) {
      rtb_Divide1_a4[i] = (double)rtDW.MaxPositionCh2_private[i] / (double)
        rtConstP.ACT1_Value_m[i];
    }

    /* End of Product: '<S760>/Divide1' */

    /* SignalConversion generated from: '<S760>/Vector Concatenate' incorporates:
     *  Constant: '<S760>/Constant'
     */
    rtb_Divide1_a4[8] = 1.0;

    /* SwitchCase: '<S745>/Switch Case' incorporates:
     *  DataStoreRead: '<S745>/Data Store Read4'
     */
    switch (rtDW.stepHoming_private_a) {
     case 0:
      /* Outputs for IfAction SubSystem: '<S745>/Switch Case Action Subsystem' incorporates:
       *  ActionPort: '<S761>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S766>/Compare' */
        rtb_rate = rtb_Divide1_a4[i];

        /* Logic: '<S761>/Logical Operator' incorporates:
         *  Constant: '<S766>/Constant'
         *  Constant: '<S767>/Constant'
         *  RelationalOperator: '<S766>/Compare'
         *  RelationalOperator: '<S767>/Compare'
         */
        rtb_LogicalOperator1 = ((rtb_rate >= 0.9) && (rtb_rate <= 1.1));
        rtb_LogicalOperator3_i5[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S769>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S769>/Data Store Read'
         *  DataStoreWrite: '<S769>/Data Store Write'
         *  Logic: '<S769>/Logical Operator'
         *  Logic: '<S769>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private_b[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private_b[i] != 0));
      }

      /* MATLAB Function: '<S761>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S761>/Data Store Read5'
       *  DataStoreRead: '<S761>/MIN ACT1T 1'
       *  Logic: '<S761>/Logical Operator2'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 3] Homing 0\n"); */
        printf("[LIN 3] Homing 0\n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 6; i++) {
          /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
          printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                 (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
                 rtb_Divide1_a4[i], (int16_t)!rtb_LogicalOperator3_i5[i]);
          fflush(stdout);
        }
      }

      /* End of MATLAB Function: '<S761>/MAX POSITION' */

      /* Logic: '<S761>/Logical Operator1' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* Switch: '<S761>/Switch' incorporates:
       *  Logic: '<S761>/Logical Operator1'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S745>/Merge' incorporates:
         *  Constant: '<S761>/Constant1'
         */
        rtB.Merge_h3 = 4;
      } else {
        /* Merge: '<S745>/Merge' incorporates:
         *  Constant: '<S761>/Constant'
         */
        rtB.Merge_h3 = 1;
      }

      /* End of Switch: '<S761>/Switch' */
      /* End of Outputs for SubSystem: '<S745>/Switch Case Action Subsystem' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S745>/Switch Case Action Subsystem1' incorporates:
       *  ActionPort: '<S762>/Action Port'
       */
      /* RelationalOperator: '<S771>/Compare' incorporates:
       *  Constant: '<S771>/Constant'
       */
      for (i = 0; i < 9; i++) {
        rtb_LogicalOperator3_i5[i] = (rtb_Divide1_a4[i] > 1.5);
      }

      /* End of RelationalOperator: '<S771>/Compare' */

      /* Logic: '<S770>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* DataTypeConversion: '<S770>/Data Type Conversion' incorporates:
       *  DataStoreWrite: '<S770>/Data Store Write1'
       *  Logic: '<S770>/Logical Operator'
       */
      rtDW.CCU_ActuatorErrF_Stat_private = rtb_LogicalOperator1;
      for (i = 0; i < 9; i++) {
        /* DataTypeConversion: '<S770>/Data Type Conversion1' incorporates:
         *  DataStoreWrite: '<S770>/Data Store Write2'
         */
        rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[i];
        rtDW.COM_private_k[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S770>/Data Type Conversion2' incorporates:
         *  DataStoreRead: '<S770>/Data Store Read'
         *  DataStoreWrite: '<S770>/Data Store Write3'
         *  Logic: '<S770>/Logical Operator1'
         */
        rtDW.ErrorActuator_a[i] = (uint8_t)(rtb_LogicalOperator1 ||
          (rtDW.ErrorActuator_a[i] != 0));

        /* DataStoreWrite: '<S770>/Data Store Write' */
        rtDW.MODE_private_c[i] = 2U;
      }

      /* MATLAB Function: '<S770>/Write ERROR' incorporates:
       *  DataStoreRead: '<S770>/Data Store Read6'
       */
      /* :  if(LOGGER>=0) */
      if (rtDW.LOGGER_LIN >= 0.0) {
        /* :  for i = 1:numel(ErrCallibration) */
        for (i = 0; i < 9; i++) {
          /* :  if ErrCallibration(i) == 1 */
          if (rtb_LogicalOperator3_i5[i]) {
            /* :  fprintf('[LIN 3] Failure with actuator #%d\n', int16(i)); */
            printf("[LIN 3] Failure with actuator #%d\n", (int16_t)(i + 1));
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S770>/Write ERROR' */
      for (i = 0; i < 9; i++) {
        /* Logic: '<S762>/Logical Operator1' */
        rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[i];

        /* DataTypeConversion: '<S762>/Data Type Conversion' incorporates:
         *  DataStoreRead: '<S762>/Data Store Read'
         *  DataStoreWrite: '<S762>/Data Store Write'
         *  Logic: '<S762>/Logical Operator'
         *  Logic: '<S762>/Logical Operator1'
         */
        rtDW.ErrorCalibration_private_b[i] = (uint8_t)((!rtb_LogicalOperator1) &&
          (rtDW.ErrorCalibration_private_b[i] != 0));

        /* DataStoreWrite: '<S774>/Data Store Write' incorporates:
         *  DataTypeConversion: '<S774>/Data Type Conversion'
         */
        rtDW.dtc_state_error_model[i + 54] = rtb_LogicalOperator1;
      }

      /* DataStoreWrite: '<S773>/Data Store Write' incorporates:
       *  Constant: '<S773>/Constant'
       */
      rtDW.stepSig_private_g = 1;

      /* MATLAB Function: '<S762>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S762>/Data Store Read5'
       *  DataStoreRead: '<S762>/MIN ACT1T 1'
       *  DataStoreWrite: '<S762>/Data Store Write'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 3] Homing 1. Start Callibration \n"); */
        printf("[LIN 3] Homing 1. Start Callibration \n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 6; i++) {
          /* :  if(ERRORS(i)==1) */
          if (rtDW.ErrorCalibration_private_b[i] == 1) {
            /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
            printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                   (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
                   rtb_Divide1_a4[i], (int16_t)rtDW.ErrorCalibration_private_b[i]);
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S762>/MAX POSITION' */

      /* Logic: '<S762>/Logical Operator2' incorporates:
       *  DataStoreWrite: '<S762>/Data Store Write'
       */
      rtb_LogicalOperator1 = (rtDW.ErrorCalibration_private_b[0] != 0);
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          (rtDW.ErrorCalibration_private_b[i + 1] != 0));
      }

      /* Switch: '<S762>/Switch' incorporates:
       *  Logic: '<S762>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S745>/Merge' incorporates:
         *  Constant: '<S773>/Constant1'
         */
        rtB.Merge_h3 = 2;
      } else {
        /* Merge: '<S745>/Merge' incorporates:
         *  Constant: '<S762>/Constant1'
         */
        rtB.Merge_h3 = 4;
      }

      /* End of Switch: '<S762>/Switch' */
      /* End of Outputs for SubSystem: '<S745>/Switch Case Action Subsystem1' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S745>/Switch Case Action Subsystem2' incorporates:
       *  ActionPort: '<S763>/Action Port'
       */
      for (i = 0; i < 9; i++) {
        /* RelationalOperator: '<S776>/Compare' */
        rtb_rate = rtb_Divide1_a4[i];

        /* Logic: '<S763>/Logical Operator3' incorporates:
         *  Constant: '<S776>/Constant'
         *  Constant: '<S777>/Constant'
         *  DataStoreRead: '<S763>/Data Store Read'
         *  Logic: '<S763>/Logical Operator1'
         *  Logic: '<S763>/Logical Operator4'
         *  RelationalOperator: '<S776>/Compare'
         *  RelationalOperator: '<S777>/Compare'
         */
        rtb_LogicalOperator1 = (((rtb_rate < 0.97) || (rtb_rate > 1.03)) &&
          (rtDW.ErrorCalibration_private_b[i] != 0));
        rtb_LogicalOperator3_i5[i] = rtb_LogicalOperator1;

        /* DataTypeConversion: '<S763>/Data Type Conversion' incorporates:
         *  DataStoreWrite: '<S763>/Data Store Write1'
         */
        rtDW.ErrorCalibration_private_b[i] = rtb_LogicalOperator1;
      }

      /* MATLAB Function: '<S763>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S763>/Data Store Read5'
       *  DataStoreRead: '<S763>/MIN ACT1T 1'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 3] Homing 3. Callibration \n"); */
        printf("[LIN 3] Homing 3. Callibration \n");
        fflush(stdout);

        /* :  for i = 1:numel(MAX) */
        for (i = 0; i < 6; i++) {
          /* :  if(ERRORS(i)==1) */
          if (rtb_LogicalOperator3_i5[i]) {
            /* :  fprintf('[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n', int16(i), int16(MAX(i)), KOEF(i), int16(ERRORS(i))); */
            printf("[LIN 3] ACT%d MAX = %d KOEF = %f Callibration = %d \n",
                   (int16_t)(i + 1), rtDW.MaxPositionCh2_private[i],
                   rtb_Divide1_a4[i], 1);
            fflush(stdout);
          }
        }
      }

      /* End of MATLAB Function: '<S763>/MAX POSITION' */

      /* Logic: '<S763>/Logical Operator2' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 ||
          rtb_LogicalOperator3_i5[i + 1]);
      }

      /* Switch: '<S763>/Switch' incorporates:
       *  Logic: '<S763>/Logical Operator2'
       */
      if (rtb_LogicalOperator1) {
        /* Merge: '<S745>/Merge' incorporates:
         *  Constant: '<S763>/Constant3'
         */
        rtB.Merge_h3 = 3;
      } else {
        /* Merge: '<S745>/Merge' incorporates:
         *  Constant: '<S763>/Constant1'
         */
        rtB.Merge_h3 = 4;
      }

      /* End of Switch: '<S763>/Switch' */
      /* End of Outputs for SubSystem: '<S745>/Switch Case Action Subsystem2' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S745>/Switch Case Action Subsystem3' incorporates:
       *  ActionPort: '<S764>/Action Port'
       */
      /* MATLAB Function: '<S764>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S764>/Data Store Read1'
       *  DataStoreRead: '<S764>/Data Store Read5'
       */
      /* :  if(LOGGER>1) */
      if (rtDW.LOGGER_LIN > 1.0) {
        /* :  fprintf("[LIN 3] Homing 3. Start Time on step %d\n",int16(step)); */
        rtb_rate = rt_roundd(rtDW.ErrorHomming_private_m);
        if (rtb_rate < 32768.0) {
          if (rtb_rate >= -32768.0) {
            rtb_Saturation_n = (int16_t)rtb_rate;
          } else {
            rtb_Saturation_n = INT16_MIN;
          }
        } else {
          rtb_Saturation_n = INT16_MAX;
        }

        printf("[LIN 3] Homing 3. Start Time on step %d\n", rtb_Saturation_n);
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S764>/MAX POSITION' */

      /* If: '<S764>/If' incorporates:
       *  DataStoreRead: '<S764>/Data Store Read1'
       */
      if (rtDW.ErrorHomming_private_m < 10.0) {
        /* Outputs for IfAction SubSystem: '<S764>/If Action Subsystem' incorporates:
         *  ActionPort: '<S779>/Action Port'
         */
        /* MATLAB Function: '<S779>/MATLAB Function' incorporates:
         *  DataStoreRead: '<S779>/Data Store Read'
         *  DataStoreRead: '<S779>/Data Store Read1'
         */
        MATLABFunction(rtDW.Start_timer, rtDW.t_now, &rtb_dt_an,
                       &rtDW.sf_MATLABFunction_g);

        /* MATLAB Function: '<S779>/MAX POSITION' incorporates:
         *  DataStoreRead: '<S779>/Data Store Read5'
         */
        /* :  if(LOGGER>1) */
        if (rtDW.LOGGER_LIN > 1.0) {
          /* :  fprintf("[LIN 3] Homing 3. Start TIme dt = %d \n",int32(data)); */
          rtb_Subtract = rtb_dt_an;
          if (rtb_dt_an > 2147483647U) {
            rtb_Subtract = 2147483647U;
          }

          printf("[LIN 3] Homing 3. Start TIme dt = %d \n", (int32_t)
                 rtb_Subtract);
          fflush(stdout);
        }

        /* End of MATLAB Function: '<S779>/MAX POSITION' */

        /* If: '<S779>/If' */
        if (rtb_dt_an > 30000U) {
          /* Outputs for IfAction SubSystem: '<S779>/If Action Subsystem' incorporates:
           *  ActionPort: '<S782>/Action Port'
           */
          /* Merge: '<S745>/Merge' */
          IfActionSubsystem(&rtB.Merge_h3, &rtDW.ErrorHomming_private_m,
                            &rtDW.Start_timer, &rtDW.stepSig_private_g);

          /* End of Outputs for SubSystem: '<S779>/If Action Subsystem' */
        } else {
          /* Outputs for IfAction SubSystem: '<S779>/If Action Subsystem1' incorporates:
           *  ActionPort: '<S783>/Action Port'
           */
          /* DataStoreWrite: '<S783>/Data Store Write2' incorporates:
           *  Constant: '<S783>/Constant3'
           */
          rtDW.Start_timer = 1.0;

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           *  DataStoreWrite: '<S599>/Data Store Write2'
           */
          rtDW.BUS_ADR_private_a[0] = rtb_DataTypeConversion_bq[0];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           *  DataStoreWrite: '<S599>/Data Store Write2'
           */
          rtDW.BUS_ADR_private_a[1] = rtb_DataTypeConversion_bq[1];

          /* DataTypeConversion: '<S786>/Data Type Conversion2' incorporates:
           *  DataStoreRead: '<S786>/valves target in percent'
           */
          for (i = 0; i < 6; i++) {
            rtb_DataTypeConversion2_l3[i] = (uint8_t)
              rtDW.valves_rear_manual_target[i];
          }

          /* End of DataTypeConversion: '<S786>/Data Type Conversion2' */

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[2] = rtb_DataTypeConversion2_l3[0];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[3] = rtb_DataTypeConversion2_l3[4];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[4] = rtb_DataTypeConversion2_l3[1];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[5] = rtb_DataTypeConversion2_l3[2];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[6] = rtb_DataTypeConversion2_l3[5];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[7] = rtb_DataTypeConversion2_l3[3];

          /* SignalConversion generated from: '<S786>/Vector Concatenate' incorporates:
           *  Concatenate: '<S786>/Vector Concatenate'
           *  Constant: '<S752>/Constant1'
           *  SignalConversion generated from: '<S752>/Vector Concatenate'
           */
          rtDW.BUS_ADR_private_a[8] = 0U;
          for (i = 0; i < 9; i++) {
            /* Product: '<S787>/Product' */
            rtb_Merge_j = rtDW.BUS_ADR_private_a[i];

            /* DataTypeConversion: '<S787>/Data Type Conversion1' incorporates:
             *  Constant: '<S787>/Constant1'
             *  DataStoreRead: '<S787>/Data Store Read'
             *  DataStoreWrite: '<S786>/Data Store Write'
             *  Product: '<S787>/Divide1'
             *  Product: '<S787>/Product'
             */
            rtDW.POS_private_h[i] = (uint16_t)((double)(rtb_Merge_j *
              rtDW.MaxPositionCh2_private[i]) / 100.0);

            /* RelationalOperator: '<S786>/Relational Operator1' incorporates:
             *  DataStoreWrite: '<S599>/Data Store Write2'
             */
            rtb_LogicalOperator3_i5[i] = (rtb_DataTypeConversion_bq[i] ==
              rtb_Merge_j);
          }

          /* Logic: '<S786>/Logical Operator' */
          rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
          for (i = 0; i < 8; i++) {
            rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
              rtb_LogicalOperator3_i5[i + 1]);
          }

          for (i = 0; i < 9; i++) {
            /* Switch: '<S786>/Switch' incorporates:
             *  Constant: '<S786>/Constant4'
             *  Constant: '<S786>/Constant9'
             *  DataStoreWrite: '<S786>/Data Store Write1'
             *  Logic: '<S786>/Logical Operator'
             */
            if (rtb_LogicalOperator1) {
              rtDW.COM_private_k[i] = 0U;
            } else {
              rtDW.COM_private_k[i] = 3U;
            }

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

            /* DataTypeConversion: '<S786>/Data Type Conversion1' incorporates:
             *  Concatenate: '<S786>/Vector Concatenate'
             *  Constant: '<S786>/Constant5'
             *  DataStoreWrite: '<S599>/Data Store Write2'
             *  DataStoreWrite: '<S786>/Data Store Write7'
             *  Product: '<S786>/Product'
             *  RelationalOperator: '<S786>/Relational Operator'
             */
            rtDW.BUS_ADR_private_a[i] = (uint8_t)((uint32_t)
              (rtb_DataTypeConversion_bq[i] != rtDW.BUS_ADR_private_a[i]) *
              rtConstP.pooled79[i]);

            /* DataStoreWrite: '<S786>/Data Store Write4' incorporates:
             *  Constant: '<S786>/Constant1'
             */
            rtDW.Autos_private_g[i] = 1U;

            /* DataStoreWrite: '<S786>/Data Store Write2' incorporates:
             *  Constant: '<S786>/Constant10'
             */
            rtDW.Stall_private_f[i] = 1U;

            /* DataStoreWrite: '<S786>/Data Store Write3' incorporates:
             *  Constant: '<S786>/Constant11'
             */
            rtDW.Lnoise_private_g[i] = 0U;

            /* DataStoreWrite: '<S786>/Data Store Write5' incorporates:
             *  Constant: '<S786>/Constant2'
             */
            rtDW.Speed_private_b[i] = 3U;

            /* DataStoreWrite: '<S786>/Data Store Write6' incorporates:
             *  Constant: '<S786>/Constant3'
             */
            rtDW.Coils_private_l[i] = 3U;
          }

          /* Merge: '<S745>/Merge' incorporates:
           *  Constant: '<S783>/Constant1'
           *  Merge: '<S779>/Merge'
           *  SignalConversion generated from: '<S783>/Out1'
           */
          rtB.Merge_h3 = 3;

          /* End of Outputs for SubSystem: '<S779>/If Action Subsystem1' */
        }

        /* End of If: '<S779>/If' */
        /* End of Outputs for SubSystem: '<S764>/If Action Subsystem' */
      } else {
        /* Outputs for IfAction SubSystem: '<S764>/If Action Subsystem1' incorporates:
         *  ActionPort: '<S780>/Action Port'
         */
        IfActionSubsystem1(&rtB.Merge_h3, &rtDW.CCU_ActuatorErrF_Stat_private,
                           rtDW.COM_private_k, rtDW.ErrorActuator_a,
                           rtDW.ErrorCalibration_private_b, &rtDW.LOGGER_LIN,
                           rtDW.MODE_private_c, rtDW.dtc_state_error_model);

        /* End of Outputs for SubSystem: '<S764>/If Action Subsystem1' */
      }

      /* End of If: '<S764>/If' */
      /* End of Outputs for SubSystem: '<S745>/Switch Case Action Subsystem3' */
      break;

     case 4:
      /* Outputs for IfAction SubSystem: '<S745>/Switch Case Action Subsystem4' incorporates:
       *  ActionPort: '<S765>/Action Port'
       */
      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       *  DataStoreWrite: '<S599>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_a[0] = rtb_DataTypeConversion_bq[0];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       *  DataStoreWrite: '<S599>/Data Store Write2'
       */
      rtDW.BUS_ADR_private_a[1] = rtb_DataTypeConversion_bq[1];

      /* DataTypeConversion: '<S792>/Data Type Conversion2' incorporates:
       *  DataStoreRead: '<S792>/valves target in percent'
       */
      for (i = 0; i < 6; i++) {
        rtb_DataTypeConversion2_l3[i] = (uint8_t)
          rtDW.valves_rear_manual_target[i];
      }

      /* End of DataTypeConversion: '<S792>/Data Type Conversion2' */

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[2] = rtb_DataTypeConversion2_l3[0];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[3] = rtb_DataTypeConversion2_l3[4];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[4] = rtb_DataTypeConversion2_l3[1];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[5] = rtb_DataTypeConversion2_l3[2];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[6] = rtb_DataTypeConversion2_l3[5];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[7] = rtb_DataTypeConversion2_l3[3];

      /* SignalConversion generated from: '<S792>/Vector Concatenate' incorporates:
       *  Concatenate: '<S786>/Vector Concatenate'
       *  Constant: '<S752>/Constant1'
       *  SignalConversion generated from: '<S752>/Vector Concatenate'
       */
      rtDW.BUS_ADR_private_a[8] = 0U;
      for (i = 0; i < 9; i++) {
        /* Product: '<S793>/Product' */
        rtb_Merge_j = rtDW.BUS_ADR_private_a[i];

        /* DataTypeConversion: '<S793>/Data Type Conversion1' incorporates:
         *  Constant: '<S793>/Constant1'
         *  DataStoreRead: '<S793>/Data Store Read'
         *  DataStoreWrite: '<S792>/Data Store Write'
         *  Product: '<S793>/Divide1'
         *  Product: '<S793>/Product'
         */
        rtDW.POS_private_h[i] = (uint16_t)((double)(rtb_Merge_j *
          rtDW.MaxPositionCh2_private[i]) / 100.0);

        /* RelationalOperator: '<S792>/Relational Operator1' incorporates:
         *  DataStoreWrite: '<S599>/Data Store Write2'
         */
        rtb_LogicalOperator3_i5[i] = (rtb_DataTypeConversion_bq[i] ==
          rtb_Merge_j);
      }

      /* Logic: '<S792>/Logical Operator' */
      rtb_LogicalOperator1 = rtb_LogicalOperator3_i5[0];
      for (i = 0; i < 8; i++) {
        rtb_LogicalOperator1 = (rtb_LogicalOperator1 &&
          rtb_LogicalOperator3_i5[i + 1]);
      }

      for (i = 0; i < 9; i++) {
        /* Switch: '<S792>/Switch' incorporates:
         *  Constant: '<S792>/Constant4'
         *  Constant: '<S792>/Constant9'
         *  DataStoreWrite: '<S792>/Data Store Write1'
         *  Logic: '<S792>/Logical Operator'
         */
        if (rtb_LogicalOperator1) {
          rtDW.COM_private_k[i] = 0U;
        } else {
          rtDW.COM_private_k[i] = 3U;
        }

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

        /* DataTypeConversion: '<S792>/Data Type Conversion1' incorporates:
         *  Concatenate: '<S786>/Vector Concatenate'
         *  Constant: '<S792>/Constant5'
         *  DataStoreWrite: '<S599>/Data Store Write2'
         *  DataStoreWrite: '<S792>/Data Store Write7'
         *  Product: '<S792>/Product'
         *  RelationalOperator: '<S792>/Relational Operator'
         */
        rtDW.BUS_ADR_private_a[i] = (uint8_t)((uint32_t)
          (rtb_DataTypeConversion_bq[i] != rtDW.BUS_ADR_private_a[i]) *
          rtConstP.pooled79[i]);

        /* DataStoreWrite: '<S792>/Data Store Write4' incorporates:
         *  Constant: '<S792>/Constant1'
         */
        rtDW.Autos_private_g[i] = 1U;

        /* DataStoreWrite: '<S792>/Data Store Write2' incorporates:
         *  Constant: '<S792>/Constant10'
         */
        rtDW.Stall_private_f[i] = 1U;

        /* DataStoreWrite: '<S792>/Data Store Write3' incorporates:
         *  Constant: '<S792>/Constant11'
         */
        rtDW.Lnoise_private_g[i] = 0U;

        /* DataStoreWrite: '<S792>/Data Store Write5' incorporates:
         *  Constant: '<S792>/Constant2'
         */
        rtDW.Speed_private_b[i] = 3U;

        /* DataStoreWrite: '<S792>/Data Store Write6' incorporates:
         *  Constant: '<S792>/Constant3'
         */
        rtDW.Coils_private_l[i] = 3U;
      }

      /* Merge: '<S745>/Merge' incorporates:
       *  Constant: '<S765>/Constant1'
       *  SignalConversion generated from: '<S765>/step'
       */
      rtB.Merge_h3 = 4;

      /* MATLAB Function: '<S765>/MAX POSITION' incorporates:
       *  DataStoreRead: '<S765>/Data Store Read5'
       */
      /* :  if(LOGGER>0) */
      if (rtDW.LOGGER_LIN > 0.0) {
        /* :  fprintf("[LIN 3] Homing. Callibration successful \n"); */
        printf("[LIN 3] Homing. Callibration successful \n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S765>/MAX POSITION' */
      /* End of Outputs for SubSystem: '<S745>/Switch Case Action Subsystem4' */
      break;
    }

    /* End of SwitchCase: '<S745>/Switch Case' */

    /* DataStoreWrite: '<S745>/Data Store Write2' */
    rtDW.stepHoming_private_a = rtB.Merge_h3;

    /* Merge: '<S599>/Merge' incorporates:
     *  DataStoreRead: '<S745>/Data Store Read7'
     */
    rtB.Merge_b4 = rtDW.stepSig_private_g;

    /* End of Outputs for SubSystem: '<S599>/Homing' */
    break;
  }

  /* End of SwitchCase: '<S599>/Switch Case' */

  /* Outport: '<Root>/CCU_Errors_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read10'
   */
  rtY.CCU_Errors_model = CCU_Errors_Model;

  /* DataStoreWrite: '<S599>/Finish write stepSig' */
  rtDW.stepSig_private_g = rtB.Merge_b4;

  /* BusCreator: '<S741>/Bus Creator' incorporates:
   *  DataStoreRead: '<S741>/Data Store Read'
   *  DataStoreRead: '<S741>/Data Store Read1'
   *  DataStoreRead: '<S741>/Data Store Read2'
   *  DataStoreRead: '<S741>/Data Store Read3'
   *  DataStoreRead: '<S741>/Data Store Read4'
   *  DataStoreRead: '<S741>/Data Store Read5'
   *  DataStoreRead: '<S741>/Data Store Read6'
   *  DataStoreRead: '<S741>/Data Store Read7'
   *  DataStoreRead: '<S741>/Data Store Read8'
   *  DataStoreWrite: '<S741>/Data Store Write'
   */
  for (i = 0; i < 9; i++) {
    Actuator_Ch2_Command_Model.POS[i] = rtDW.POS_private_h[i];
    Actuator_Ch2_Command_Model.BUS_ADR[i] = rtDW.BUS_ADR_private_a[i];
    Actuator_Ch2_Command_Model.MODE[i] = rtDW.MODE_private_c[i];
    Actuator_Ch2_Command_Model.COM[i] = rtDW.COM_private_k[i];
    Actuator_Ch2_Command_Model.Stall_SET[i] = rtDW.Stall_private_f[i];
    Actuator_Ch2_Command_Model.Lnoise_SET[i] = rtDW.Lnoise_private_g[i];
    Actuator_Ch2_Command_Model.Autos_SET[i] = rtDW.Autos_private_g[i];
    Actuator_Ch2_Command_Model.Speed_SET[i] = rtDW.Speed_private_b[i];
    Actuator_Ch2_Command_Model.Coils_Stop_SET[i] = rtDW.Coils_private_l[i];
  }

  /* End of BusCreator: '<S741>/Bus Creator' */

  /* RelationalOperator: '<S753>/Compare' incorporates:
   *  Constant: '<S753>/Constant'
   *  DataStoreRead: '<S742>/Data Store Read2'
   */
  for (i = 0; i < 8; i++) {
    rtb_Compare_n[i] = (rtDW.ErrorCalibration_private_b[i] == 0);
  }

  /* End of RelationalOperator: '<S753>/Compare' */

  /* Logic: '<S742>/Logical Operator' */
  rtb_LogicalOperator1 = rtb_Compare_n[0];
  for (i = 0; i < 7; i++) {
    rtb_LogicalOperator1 = (rtb_LogicalOperator1 || rtb_Compare_n[i + 1]);
  }

  /* Switch: '<S742>/Switch1' incorporates:
   *  Constant: '<S742>/Constant'
   *  Constant: '<S742>/Constant3'
   *  DataStoreRead: '<S742>/Data Store Read2'
   *  Logic: '<S742>/Logical Operator'
   *  Product: '<S742>/Product'
   */
  for (i = 0; i < 8; i++) {
    if (rtb_LogicalOperator1) {
      rtb_DataTypeConversion_bq[i] = (uint8_t)((uint32_t)
        rtDW.ErrorCalibration_private_b[i] * rtConstP.Constant3_Value_d[i]);
    } else {
      rtb_DataTypeConversion_bq[i] = 0U;
    }
  }

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

  /* SignalConversion generated from: '<S742>/Vector Concatenate' incorporates:
   *  Constant: '<S742>/Constant1'
   */
  rtb_DataTypeConversion_bq[8] = 0U;
  for (i = 0; i < 9; i++) {
    /* DataStoreWrite: '<S742>/Data Store Write7' incorporates:
     *  Concatenate: '<S786>/Vector Concatenate'
     */
    rtDW.BUS_ADR_private_a[i] = rtb_DataTypeConversion_bq[i];

    /* DataStoreWrite: '<S742>/Data Store Write' */
    rtDW.COM_private_k[i] = 0U;
  }

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

  /* Saturate: '<S8>/Saturation' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read3'
   */
  if (rtDW.PWM_front <= 100) {
    /* BusCreator: '<S8>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S8>/Data Store Write'
     */
    PWM_Get.pwmPercentFront = rtDW.PWM_front;
  } else {
    /* BusCreator: '<S8>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S8>/Data Store Write'
     */
    PWM_Get.pwmPercentFront = 100U;
  }

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

  /* Saturate: '<S8>/Saturation1' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read4'
   */
  if (rtDW.PWM_rear <= 100) {
    /* BusCreator: '<S8>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S8>/Data Store Write'
     */
    PWM_Get.pwmPercentRear = rtDW.PWM_rear;
  } else {
    /* BusCreator: '<S8>/Bus Creator' incorporates:
     *  DataStoreWrite: '<S8>/Data Store Write'
     */
    PWM_Get.pwmPercentRear = 100U;
  }

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

  /* BusCreator: '<S8>/Bus Creator' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read1'
   *  DataStoreRead: '<S8>/Data Store Read5'
   *  DataStoreWrite: '<S8>/Data Store Write'
   */
  PWM_Get.pwmPercentFrontReserved = rtDW.PWM_front;
  PWM_Get.pwmPercentRearReserved = rtDW.PWM_rear;

  /* MATLAB Function: '<S8>/Write4' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('GETPWMFront = %u \n',data); */
  printf("GETPWMFront = %u \n", rtDW.PWM_front);
  fflush(stdout);

  /* MATLAB Function: '<S8>/Write' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentFront = %u \n',data); */
  printf("pwmPercentFront = %u \n", rtDW.PWM_Set_Model.pwmPercentFront);
  fflush(stdout);

  /* MATLAB Function: '<S8>/Write1' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentRear = %u \n',data); */
  printf("pwmPercentRear = %u \n", rtDW.PWM_Set_Model.pwmPercentRear);
  fflush(stdout);

  /* MATLAB Function: '<S8>/Write2' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentFrontReserved = %u \n',data); */
  printf("pwmPercentFrontReserved = %u \n",
         rtDW.PWM_Set_Model.pwmPercentFrontReserved);
  fflush(stdout);

  /* MATLAB Function: '<S8>/Write3' incorporates:
   *  DataStoreRead: '<S8>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentRearReserved = %u \n',data); */
  printf("pwmPercentRearReserved = %u \n",
         rtDW.PWM_Set_Model.pwmPercentRearReserved);
  fflush(stdout);

  /* BusCreator: '<S1393>/Bus Creator1' incorporates:
   *  Constant: '<S1393>/Constant10'
   *  Constant: '<S1393>/Constant6'
   *  Constant: '<S1393>/Constant7'
   *  Constant: '<S1393>/Constant8'
   *  Constant: '<S1393>/Constant9'
   *  DataStoreRead: '<S1393>/Data Store Read1'
   *  DataStoreRead: '<S1393>/Data Store Read10'
   *  DataStoreRead: '<S1393>/Data Store Read11'
   *  DataStoreRead: '<S1393>/Data Store Read13'
   *  DataStoreRead: '<S1393>/Data Store Read15'
   *  DataStoreRead: '<S1393>/Data Store Read17'
   *  DataStoreRead: '<S1393>/Data Store Read19'
   *  DataStoreRead: '<S1393>/Data Store Read3'
   *  DataStoreRead: '<S1393>/Data Store Read4'
   *  DataStoreRead: '<S1393>/Data Store Read8'
   *  DataStoreWrite: '<Root>/Data Store Write2'
   *  DataStoreWrite: '<Root>/Data Store Write3'
   *  DataStoreWrite: '<Root>/Data Store Write4'
   *  DataStoreWrite: '<Root>/Data Store Write5'
   *  DataStoreWrite: '<Root>/Data Store Write6'
   *  DataStoreWrite: '<Root>/Data Store Write7'
   *  DataStoreWrite: '<S1393>/Data Store Write1'
   */
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_MultMsg_Idx = 0U;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Fb_Select = 0U;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Fb_Select = 0U;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Fb_Select = 0U;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Fb_Select = 0U;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Tgt_ro = 0;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Upper_Tgt_ro = 0;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Tgt_ro = 0;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Upper_Tgt_ro = 0;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Fb_ro = Duct2_R;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Fb_ro = Duct1_R;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Upper_Fb_ro = Duct2_F;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Upper_Fb_ro = Duct1_F;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Side_Fb_ro = Duct6_F;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Side_Fb_ro = Duct5_F;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RL_Side_Fb_ro = Duct3_R;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_RR_Side_Fb_ro = Duct4_R;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Lower_Tgt_ro = 0;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Lower_Tgt_ro = 0;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FR_Lower_Fb_ro = Duct4_F;
  rtDW.dbgCAN_dbg_Sen_Duct_model.dbg_Sen_Duct_FL_Lower_Fb_ro = Duct3_F;

  /* BusCreator: '<S1394>/Bus Creator1' incorporates:
   *  DataStoreRead: '<S1394>/Data Store Read4'
   *  DataStoreWrite: '<S1394>/Data Store Write1'
   *  DataStoreWrite: '<S597>/Data Store Write2'
   */
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act00_Def = rtb_DataTypeConversion_bh[0];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act01_Vent_SFL = rtb_DataTypeConversion_bh[5];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act02_Vent_CFL = rtb_DataTypeConversion_bh[4];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act03_Foot_1FL = rtb_DataTypeConversion_bh[7];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act04_Foot_2FL = rtb_DataTypeConversion_bh[8];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act05_Vent_CFR = Actuator_pos_percent_Ch1[1];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act06_Vent_SFR = Actuator_pos_percent_Ch1[2];
  rtDW.dbgCAN_dbg_Act0_model.dbg_Act07_Foot_1FR = Actuator_pos_percent_Ch1[4];

  /* BusCreator: '<S1394>/Bus Creator3' incorporates:
   *  DataStoreRead: '<S1394>/Data Store Read4'
   *  DataStoreRead: '<S1394>/Data Store Read5'
   *  DataStoreWrite: '<S1394>/Data Store Write2'
   *  DataStoreWrite: '<S597>/Data Store Write2'
   */
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act16_TempL_FL = rtb_DataTypeConversion_bh[6];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act17_TempU_FR = Actuator_pos_percent_Ch1[0];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act18_TempL_FR = Actuator_pos_percent_Ch1[3];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act19_Temp_RL = rtb_DataTypeConversion_fb[1];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act20_Temp_RR = rtb_DataTypeConversion_fb[0];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act21_Rec = rtb_DataTypeConversion_bh[1];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act22_OSA = rtb_DataTypeConversion_bh[2];
  rtDW.dbgCAN_dbg_Act2_model.dbg_Act23_SealingValve = rtb_DataTypeConversion_fb
    [8];

  /* BusCreator: '<S1394>/Bus Creator2' incorporates:
   *  DataStoreRead: '<S1394>/Data Store Read4'
   *  DataStoreRead: '<S1394>/Data Store Read5'
   *  DataStoreWrite: '<S1394>/Data Store Write3'
   *  DataStoreWrite: '<S597>/Data Store Write2'
   */
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act08_Foot_2FR = Actuator_pos_percent_Ch1[5];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act09_Vent_SRL = rtb_DataTypeConversion_fb[2];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act10_Vent_CRL = rtb_DataTypeConversion_fb[4];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act11_Foot_RL = rtb_DataTypeConversion_fb[3];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act12_Vent_CRR = rtb_DataTypeConversion_fb[5];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act13_Vent_SRR = rtb_DataTypeConversion_fb[7];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act14_Foot_RR = rtb_DataTypeConversion_fb[6];
  rtDW.dbgCAN_dbg_Act1_model.dbg_Act15_TempU_FL = rtb_DataTypeConversion_bh[3];

  /* BusCreator: '<S1395>/Bus Creator' incorporates:
   *  DataStoreRead: '<S1395>/Data Store Read'
   *  DataStoreRead: '<S1395>/Data Store Read1'
   *  DataStoreWrite: '<S1395>/Data Store Write'
   */
  rtDW.dbgCAN_dbg_Sen_Amb_model.dbg_Sen_Amb_ro = rtb_LVL;
  rtDW.dbgCAN_dbg_Sen_Amb_model.dbg_Sen_Amb_Raw_ro = rtDW.AMB_RAW;
  rtDW.dbgCAN_dbg_Sen_Amb_model.dbg_Amb_Tg_ro = 0;

  /* BusCreator: '<S1396>/Bus Creator' incorporates:
   *  DataStoreRead: '<S1396>/Data Store Read'
   *  DataStoreRead: '<S1396>/Data Store Read1'
   *  DataStoreRead: '<S1396>/Data Store Read2'
   *  DataStoreRead: '<S1396>/Data Store Read3'
   *  DataStoreRead: '<S1396>/Data Store Read4'
   *  DataStoreRead: '<S1396>/Data Store Read5'
   *  DataStoreWrite: '<S1396>/Data Store Write'
   */
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_FL = 0U;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_FR = 0U;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_RL = 0U;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Step_RR = 0U;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Pwm_Front = rtDW.PWM_front;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_Pwm_Rear = rtDW.PWM_rear;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_FL = rtDW.Blower_AF_FL;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_FR = rtDW.Blower_AF_FR;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_RL = rtDW.Blower_AF_RL;
  rtDW.dbgCAN_dbg_Logic_Blower_model.Logic_Blower_AF_RR = rtDW.Blower_AF_RR;

  /* BusCreator: '<S1397>/Bus Creator' incorporates:
   *  DataStoreRead: '<S1397>/Data Store Read'
   *  DataStoreRead: '<S1397>/Data Store Read1'
   *  DataStoreWrite: '<S1397>/Data Store Write'
   */
  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_F = 0;
  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_R = 0;
  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_Target = rtDW.Eva_F;
  rtDW.dbgCAN_dbg_Sen_Eva_model.dbg_Sen_Eva_Diff_FrontRear = rtDW.Eva_R;

  /* Outport: '<Root>/PWM_Get' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read7'
   */
  rtY.PWM_Get_f = PWM_Get;

  /* Outport: '<Root>/dtc_state_error_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read1'
   */
  memcpy(&rtY.dtc_state_error_model[0], &rtDW.dtc_state_error_model[0], 127U *
         sizeof(uint8_t));

  /* Outport: '<Root>/dbgCAN_dbg_Act0_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read3'
   */
  rtY.dbgCAN_dbg_Act0_model = rtDW.dbgCAN_dbg_Act0_model;

  /* Outport: '<Root>/dbgCAN_dbg_Act1_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read4'
   */
  rtY.dbgCAN_dbg_Act1_model = rtDW.dbgCAN_dbg_Act1_model;

  /* Outport: '<Root>/dbgCAN_dbg_Act2_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read5'
   */
  rtY.dbgCAN_dbg_Act2_model = rtDW.dbgCAN_dbg_Act2_model;

  /* Outport: '<Root>/CCU_Stat1_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read6'
   */
  rtY.CCU_Stat1_model = rtDW.CCU_STAT1_MODEL;

  /* Outport: '<Root>/dbgCAN_dbg_Sen_Duct_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read8'
   */
  rtY.dbgCAN_dbg_Sen_Duct_model = rtDW.dbgCAN_dbg_Sen_Duct_model;

  /* Outport: '<Root>/dbgCAN_dbg_Sen_Eva_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read9'
   */
  rtY.dbgCAN_dbg_Sen_Eva_model = rtDW.dbgCAN_dbg_Sen_Eva_model;

  /* Outport: '<Root>/dbgCAN_dbg_Logic_Blower_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read13'
   */
  rtY.dbgCAN_dbg_Logic_Blower_model = rtDW.dbgCAN_dbg_Logic_Blower_model;

  /* Outport: '<Root>/dbgCAN_dbg_Sen_Amb_model' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read29'
   */
  rtY.dbgCAN_dbg_Sen_Amb_model = rtDW.dbgCAN_dbg_Sen_Amb_model;

  /* Outputs for Atomic SubSystem: '<Root>/PWM and valves in manual1' */
  /* Outputs for Enabled SubSystem: '<S813>/Subsystem' incorporates:
   *  EnablePort: '<S843>/Enable'
   */
  /* Logic: '<S813>/Logical Operator1' incorporates:
   *  Constant: '<S813>/Constant2'
   *  Constant: '<S813>/Constant3'
   *  DataStoreRead: '<S813>/Data Store Read11'
   *  DataStoreRead: '<S813>/Data Store Read12'
   *  RelationalOperator: '<S813>/Equal2'
   *  RelationalOperator: '<S813>/Equal3'
   */
  if ((rtDW.FIU_MODE_FL == 1) && (rtDW.FIU_MODE_FR == 1)) {
    /* MATLAB Function: '<S845>/Valves for Def' */
    ValvesforDef(rtb_vals_m);

    /* MATLAB Function: '<S845>/Valves for Hi_Level' */
    /* :  out = g_ausFLOW_FR_VE2VALVE; */
    ValvesforHi_Level(Merge);

    /* MATLAB Function: '<S845>/Valves for Foot + Def' */
    /* :  out = g_ausFLOW_FR_FO2VALVE; */
    ValvesforFootDef(rtb_out_ic);

    /* MATLAB Function: '<S845>/Valves for Bi Level' */
    ValvesforBiLevel(rtb_out_k4);

    /* MATLAB Function: '<S845>/Valves for Tri-Level' */
    ValvesforTriLevel(rtDW.valves_front_manual_target);

    /* MultiPortSwitch: '<S845>/Multiport Switch' incorporates:
     *  Constant: '<S845>/Constant'
     *  Constant: '<S845>/Constant1'
     *  Constant: '<S845>/Constant2'
     *  DataStoreRead: '<S7>/Data Store Read10'
     *  DataStoreRead: '<S7>/Data Store Read4'
     *  DataStoreRead: '<S7>/Data Store Read5'
     *  Gain: '<S845>/Gain1'
     *  Gain: '<S845>/Gain2'
     *  RelationalOperator: '<S845>/Relational Operator'
     *  RelationalOperator: '<S845>/Relational Operator1'
     *  RelationalOperator: '<S845>/Relational Operator2'
     *  Sum: '<S845>/Add'
     */
    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FL == 1) << 1) + (uint32_t)
                       (rtDW.FIU_DEF_FL == 1)) + (uint32_t)((rtDW.FIU_FOOT_FL ==
               1) << 2))) {
     case 0:
      /* DataStoreWrite: '<S843>/Data Store Write' */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = 0U;
      }
      break;

     case 1:
      /* DataStoreWrite: '<S843>/Data Store Write' */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = rtb_vals_m[i];
      }
      break;

     case 2:
      /* DataStoreWrite: '<S843>/Data Store Write' incorporates:
       *  MATLAB Function: '<S845>/Valves for Vent mode'
       */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = g_ausFLOW_FR_VE2VALVE[i];
      }
      break;

     case 3:
      /* DataStoreWrite: '<S843>/Data Store Write' */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = Merge[i];
      }
      break;

     case 4:
      /* DataStoreWrite: '<S843>/Data Store Write' incorporates:
       *  MATLAB Function: '<S845>/Valves for Foot'
       */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = g_ausFLOW_FR_FO2VALVE[i];
      }
      break;

     case 5:
      /* DataStoreWrite: '<S843>/Data Store Write' */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = rtb_out_ic[i];
      }
      break;

     case 6:
      /* DataStoreWrite: '<S843>/Data Store Write' */
      for (i = 0; i < 9; i++) {
        rtDW.valves_front_manual_target[i] = rtb_out_k4[i];
      }
      break;
    }

    /* End of MultiPortSwitch: '<S845>/Multiport Switch' */

    /* MATLAB Function: '<S846>/Valves for Def' */
    ValvesforDef(rtb_vals_m);

    /* MATLAB Function: '<S846>/Valves for Hi_Level' */
    /* :  out = g_ausFLOW_FR_VE2VALVE; */
    ValvesforHi_Level(Merge);

    /* MATLAB Function: '<S846>/Valves for Foot + Def' */
    /* :  out = g_ausFLOW_FR_FO2VALVE; */
    ValvesforFootDef(rtb_out_ic);

    /* MATLAB Function: '<S846>/Valves for Bi Level' */
    ValvesforBiLevel(rtb_out_k4);

    /* MATLAB Function: '<S846>/Valves for Tri-Level' */
    ValvesforTriLevel(rtb_out_mj);

    /* MultiPortSwitch: '<S846>/Multiport Switch' incorporates:
     *  Constant: '<S846>/Constant'
     *  Constant: '<S846>/Constant1'
     *  Constant: '<S846>/Constant2'
     *  DataStoreRead: '<S7>/Data Store Read1'
     *  DataStoreRead: '<S7>/Data Store Read2'
     *  DataStoreRead: '<S7>/Data Store Read3'
     *  Gain: '<S846>/Gain1'
     *  Gain: '<S846>/Gain2'
     *  MATLAB Function: '<S846>/Valves for Foot'
     *  MATLAB Function: '<S846>/Valves for Vent mode'
     *  RelationalOperator: '<S846>/Relational Operator'
     *  RelationalOperator: '<S846>/Relational Operator1'
     *  RelationalOperator: '<S846>/Relational Operator2'
     *  Sum: '<S846>/Add'
     */
    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FR == 1) << 1) + (uint32_t)
                       (rtDW.FIU_DEF_FR == 1)) + (uint32_t)((rtDW.FIU_FOOT_FR ==
               1) << 2))) {
     case 0:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = 0U;
      }
      break;

     case 1:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = rtb_vals_m[i];
      }
      break;

     case 2:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = g_ausFLOW_FR_VE2VALVE[i];
      }
      break;

     case 3:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = Merge[i];
      }
      break;

     case 4:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = g_ausFLOW_FR_FO2VALVE[i];
      }
      break;

     case 5:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = rtb_out_ic[i];
      }
      break;

     case 6:
      for (i = 0; i < 9; i++) {
        rtb_out_mj[i] = rtb_out_k4[i];
      }
      break;
    }

    /* End of MultiPortSwitch: '<S846>/Multiport Switch' */

    /* Assignment: '<S843>/Присваивание в [3-4]' incorporates:
     *  DataStoreWrite: '<S843>/Data Store Write'
     */
    rtDW.valves_front_manual_target[2] = rtb_out_mj[2];

    /* Assignment: '<S843>/Присваивание в [7-8]' incorporates:
     *  DataStoreWrite: '<S843>/Data Store Write'
     */
    rtDW.valves_front_manual_target[6] = rtb_out_mj[6];

    /* Assignment: '<S843>/Присваивание в [3-4]' incorporates:
     *  DataStoreWrite: '<S843>/Data Store Write'
     */
    rtDW.valves_front_manual_target[3] = rtb_out_mj[3];

    /* Assignment: '<S843>/Присваивание в [7-8]' incorporates:
     *  DataStoreWrite: '<S843>/Data Store Write'
     */
    rtDW.valves_front_manual_target[7] = rtb_out_mj[7];
  }

  /* End of Logic: '<S813>/Logical Operator1' */
  /* End of Outputs for SubSystem: '<S813>/Subsystem' */

  /* Outputs for Enabled SubSystem: '<S813>/Subsystem1' incorporates:
   *  EnablePort: '<S844>/Enable'
   */
  /* Logic: '<S813>/Logical Operator2' incorporates:
   *  Constant: '<S813>/Constant1'
   *  Constant: '<S813>/Constant4'
   *  DataStoreRead: '<S813>/Data Store Read1'
   *  DataStoreRead: '<S813>/Data Store Read2'
   *  RelationalOperator: '<S813>/Equal1'
   *  RelationalOperator: '<S813>/Equal4'
   */
  if ((rtDW.FIU_MODE_RL == 1) && (rtDW.FIU_MODE_RR == 1)) {
    /* MATLAB Function: '<S861>/valves for Vent mode' */
    valvesforVentmode(rtb_urear);

    /* MATLAB Function: '<S861>/AF for Bi Level' */
    /* :  out = g_ausFLOW_RE_FO2VALVE; */
    AFforBiLevel_m(rtDW.valves_rear_manual_target);

    /* MultiPortSwitch: '<S861>/Multiport Switch' incorporates:
     *  Constant: '<S861>/Constant1'
     *  Constant: '<S861>/Constant2'
     *  DataStoreRead: '<S7>/Data Store Read23'
     *  DataStoreRead: '<S7>/Data Store Read24'
     *  Gain: '<S861>/Gain2'
     *  RelationalOperator: '<S861>/Relational Operator1'
     *  RelationalOperator: '<S861>/Relational Operator2'
     *  Sum: '<S861>/Add'
     */
    switch ((int32_t)((uint32_t)((rtDW.FIU_FOOT_RL == 1) << 1) + (uint32_t)
                      (rtDW.FIU_FACE_RL == 1))) {
     case 0:
      /* DataStoreWrite: '<S844>/Data Store Write1' */
      for (i = 0; i < 6; i++) {
        rtDW.valves_rear_manual_target[i] = 0U;
      }
      break;

     case 1:
      /* DataStoreWrite: '<S844>/Data Store Write1' */
      for (i = 0; i < 6; i++) {
        rtDW.valves_rear_manual_target[i] = rtb_urear[i];
      }
      break;

     case 2:
      /* DataStoreWrite: '<S844>/Data Store Write1' incorporates:
       *  MATLAB Function: '<S861>/AF for Foot'
       */
      for (i = 0; i < 6; i++) {
        rtDW.valves_rear_manual_target[i] = g_ausFLOW_RE_FO2VALVE[i];
      }
      break;
    }

    /* End of MultiPortSwitch: '<S861>/Multiport Switch' */

    /* MATLAB Function: '<S862>/valves for Vent mode' */
    valvesforVentmode(rtb_urear);

    /* MATLAB Function: '<S862>/AF for Bi Level' */
    /* :  out = g_ausFLOW_RE_FO2VALVE; */
    AFforBiLevel_m(rtb_out_kw);

    /* MultiPortSwitch: '<S862>/Multiport Switch' incorporates:
     *  Constant: '<S862>/Constant1'
     *  Constant: '<S862>/Constant2'
     *  DataStoreRead: '<S7>/Data Store Read21'
     *  DataStoreRead: '<S7>/Data Store Read22'
     *  Gain: '<S862>/Gain2'
     *  MATLAB Function: '<S862>/AF for Foot'
     *  RelationalOperator: '<S862>/Relational Operator1'
     *  RelationalOperator: '<S862>/Relational Operator2'
     *  Sum: '<S862>/Add'
     */
    switch ((int32_t)((uint32_t)((rtDW.FIU_FOOT_RR == 1) << 1) + (uint32_t)
                      (rtDW.FIU_FACE_RR == 1))) {
     case 0:
      for (i = 0; i < 6; i++) {
        rtb_vals_m[i] = 0U;
      }
      break;

     case 1:
      for (i = 0; i < 6; i++) {
        rtb_vals_m[i] = rtb_urear[i];
      }
      break;

     case 2:
      for (i = 0; i < 6; i++) {
        rtb_vals_m[i] = g_ausFLOW_RE_FO2VALVE[i];
      }
      break;

     default:
      for (i = 0; i < 6; i++) {
        rtb_vals_m[i] = rtb_out_kw[i];
      }
      break;
    }

    /* End of MultiPortSwitch: '<S862>/Multiport Switch' */

    /* Assignment: '<S844>/Присваивание в [3-4] rear' incorporates:
     *  DataStoreWrite: '<S844>/Data Store Write1'
     */
    rtDW.valves_rear_manual_target[2] = rtb_vals_m[2];
    rtDW.valves_rear_manual_target[3] = rtb_vals_m[3];

    /* Assignment: '<S844>/Присваивание в [6] rear' incorporates:
     *  DataStoreWrite: '<S844>/Data Store Write1'
     */
    rtDW.valves_rear_manual_target[5] = rtb_vals_m[5];
  }

  /* End of Logic: '<S813>/Logical Operator2' */
  /* End of Outputs for SubSystem: '<S813>/Subsystem1' */

  /* Outputs for Enabled SubSystem: '<S812>/Subsystem' incorporates:
   *  EnablePort: '<S814>/Enable'
   */
  /* Logic: '<S812>/Logical Operator1' incorporates:
   *  Constant: '<S812>/Constant2'
   *  Constant: '<S812>/Constant3'
   *  DataStoreRead: '<S812>/Data Store Read11'
   *  DataStoreRead: '<S812>/Data Store Read12'
   *  RelationalOperator: '<S812>/Equal2'
   *  RelationalOperator: '<S812>/Equal3'
   */
  if ((rtDW.FIU_MODE_FL == 1) && (rtDW.FIU_MODE_FR == 1)) {
    /* MATLAB Function: '<S816>/AF for Def' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforDef(rtDW.FIU_BLOWERS_FL, &rtb_out_khw);

    /* MATLAB Function: '<S816>/AF for Vent mode' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforVentmode(rtDW.FIU_BLOWERS_FL, &rtb_out_le);

    /* MATLAB Function: '<S816>/AF for Hi_Level' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforHi_Level(rtDW.FIU_BLOWERS_FL, &rtb_out_pf);

    /* MATLAB Function: '<S816>/AF for Foot' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforFoot(rtDW.FIU_BLOWERS_FL, &rtb_out_em);

    /* MATLAB Function: '<S816>/AF for Foor + Def' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforFoorDef(rtDW.FIU_BLOWERS_FL, &rtb_out_jv);

    /* MATLAB Function: '<S816>/AF for Bi Level' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforBiLevel(rtDW.FIU_BLOWERS_FL, &rtb_out_m4);

    /* MATLAB Function: '<S816>/AF for Tri-Level' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    AFforTriLevel(rtDW.FIU_BLOWERS_FL, &rtb_out_b);

    /* MultiPortSwitch: '<S816>/Multiport Switch' incorporates:
     *  Constant: '<S816>/Constant'
     *  Constant: '<S816>/Constant1'
     *  Constant: '<S816>/Constant2'
     *  Constant: '<S816>/Constant3'
     *  DataStoreRead: '<S7>/Data Store Read6'
     *  DataStoreRead: '<S7>/Data Store Read8'
     *  DataStoreRead: '<S7>/Data Store Read9'
     *  Gain: '<S816>/Gain1'
     *  Gain: '<S816>/Gain2'
     *  RelationalOperator: '<S816>/Relational Operator'
     *  RelationalOperator: '<S816>/Relational Operator1'
     *  RelationalOperator: '<S816>/Relational Operator2'
     *  Sum: '<S816>/Add'
     */
    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FL == 1) << 1) + (uint32_t)
                       (rtDW.FIU_DEF_FL == 1)) + (uint32_t)((rtDW.FIU_FOOT_FL ==
               1) << 2))) {
     case 0:
      rtb_out_b = 0U;
      break;

     case 1:
      rtb_out_b = rtb_out_khw;
      break;

     case 2:
      rtb_out_b = rtb_out_le;
      break;

     case 3:
      rtb_out_b = rtb_out_pf;
      break;

     case 4:
      rtb_out_b = rtb_out_em;
      break;

     case 5:
      rtb_out_b = rtb_out_jv;
      break;

     case 6:
      rtb_out_b = rtb_out_m4;
      break;
    }

    /* End of MultiPortSwitch: '<S816>/Multiport Switch' */

    /* MATLAB Function: '<S817>/AF for Def' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforDef(rtDW.FIU_BLOWERS_FR, &rtb_out_le);

    /* MATLAB Function: '<S817>/AF for Vent mode' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforVentmode(rtDW.FIU_BLOWERS_FR, &rtb_out_pf);

    /* MATLAB Function: '<S817>/AF for Hi_Level' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforHi_Level(rtDW.FIU_BLOWERS_FR, &rtb_out_em);

    /* MATLAB Function: '<S817>/AF for Foot' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforFoot(rtDW.FIU_BLOWERS_FR, &rtb_out_jv);

    /* MATLAB Function: '<S817>/AF for Foor + Def' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforFoorDef(rtDW.FIU_BLOWERS_FR, &rtb_out_m4);

    /* MATLAB Function: '<S817>/AF for Bi Level' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforBiLevel(rtDW.FIU_BLOWERS_FR, &rtb_out_pb);

    /* MATLAB Function: '<S817>/AF for Tri-Level' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read7'
     */
    AFforTriLevel(rtDW.FIU_BLOWERS_FR, &rtb_out_khw);

    /* MultiPortSwitch: '<S817>/Multiport Switch' incorporates:
     *  Constant: '<S817>/Constant'
     *  Constant: '<S817>/Constant1'
     *  Constant: '<S817>/Constant2'
     *  Constant: '<S817>/Constant3'
     *  DataStoreRead: '<S7>/Data Store Read12'
     *  DataStoreRead: '<S7>/Data Store Read13'
     *  DataStoreRead: '<S7>/Data Store Read14'
     *  Gain: '<S817>/Gain1'
     *  Gain: '<S817>/Gain2'
     *  RelationalOperator: '<S817>/Relational Operator'
     *  RelationalOperator: '<S817>/Relational Operator1'
     *  RelationalOperator: '<S817>/Relational Operator2'
     *  Sum: '<S817>/Add'
     */
    switch ((int32_t)(((uint32_t)((rtDW.FIU_FACE_FR == 1) << 1) + (uint32_t)
                       (rtDW.FIU_DEF_FR == 1)) + (uint32_t)((rtDW.FIU_FOOT_FR ==
               1) << 2))) {
     case 0:
      rtb_out_khw = 0U;
      break;

     case 1:
      rtb_out_khw = rtb_out_le;
      break;

     case 2:
      rtb_out_khw = rtb_out_pf;
      break;

     case 3:
      rtb_out_khw = rtb_out_em;
      break;

     case 4:
      rtb_out_khw = rtb_out_jv;
      break;

     case 5:
      rtb_out_khw = rtb_out_m4;
      break;

     case 6:
      rtb_out_khw = rtb_out_pb;
      break;
    }

    /* End of MultiPortSwitch: '<S817>/Multiport Switch' */

    /* DataTypeConversion: '<S814>/Data Type Conversion1' incorporates:
     *  Constant: '<S814>/Constant'
     *  DataStoreWrite: '<S814>/Data Store Write'
     *  Product: '<S814>/Divide'
     *  Sum: '<S814>/Add'
     */
    rtDW.PWM_front = (uint8_t)((double)(uint16_t)((uint32_t)rtb_out_b +
      rtb_out_khw) / 4.0);

    /* DataTypeConversion: '<S814>/Data Type Conversion3' incorporates:
     *  DataStoreWrite: '<S814>/Data Store Write2'
     */
    rtDW.Blower_AF_FL = (uint8_t)rtb_out_b;

    /* DataTypeConversion: '<S814>/Data Type Conversion2' incorporates:
     *  DataStoreWrite: '<S814>/Data Store Write3'
     */
    rtDW.Blower_AF_FR = (uint8_t)rtb_out_khw;

    /* MATLAB Function: '<S814>/Write' incorporates:
     *  DataStoreWrite: '<S814>/Data Store Write'
     */
    /* :  fprintf('pwmFront_output = %u \n',data); */
    printf("pwmFront_output = %u \n", rtDW.PWM_front);
    fflush(stdout);

    /* MATLAB Function: '<S814>/Write2' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read11'
     */
    /* :  fprintf('speedL_input = %u \n',data); */
    printf("speedL_input = %u \n", rtDW.FIU_BLOWERS_FL);
    fflush(stdout);
  }

  /* End of Logic: '<S812>/Logical Operator1' */
  /* End of Outputs for SubSystem: '<S812>/Subsystem' */

  /* Outputs for Enabled SubSystem: '<S812>/Subsystem1' incorporates:
   *  EnablePort: '<S815>/Enable'
   */
  /* Logic: '<S812>/Logical Operator2' incorporates:
   *  Constant: '<S812>/Constant1'
   *  Constant: '<S812>/Constant4'
   *  DataStoreRead: '<S812>/Data Store Read1'
   *  DataStoreRead: '<S812>/Data Store Read2'
   *  RelationalOperator: '<S812>/Equal1'
   *  RelationalOperator: '<S812>/Equal4'
   */
  if ((rtDW.FIU_MODE_RL == 1) && (rtDW.FIU_MODE_RR == 1)) {
    /* MATLAB Function: '<S834>/AF for Vent mode R' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read18'
     */
    AFforVentmodeR(rtDW.FIU_BLOWERS_RL, &rtb_out_khw);

    /* MATLAB Function: '<S834>/AF for Foot R' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read18'
     */
    AFforFootR(rtDW.FIU_BLOWERS_RL, &rtb_out_le);

    /* MATLAB Function: '<S834>/AF for Bi Level R' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read18'
     */
    AFforBiLevelR(rtDW.FIU_BLOWERS_RL, &rtb_out_b);

    /* MultiPortSwitch: '<S834>/Multiport Switch' incorporates:
     *  Constant: '<S834>/Constant1'
     *  Constant: '<S834>/Constant2'
     *  Constant: '<S834>/Constant3'
     *  DataStoreRead: '<S7>/Data Store Read19'
     *  DataStoreRead: '<S7>/Data Store Read20'
     *  Gain: '<S834>/Gain2'
     *  RelationalOperator: '<S834>/Relational Operator1'
     *  RelationalOperator: '<S834>/Relational Operator2'
     *  Sum: '<S834>/Add'
     */
    switch ((int32_t)((uint32_t)((rtDW.FIU_FOOT_RL == 1) << 1) + (uint32_t)
                      (rtDW.FIU_FACE_RL == 1))) {
     case 0:
      rtb_out_b = 0U;
      break;

     case 1:
      rtb_out_b = rtb_out_khw;
      break;

     case 2:
      rtb_out_b = rtb_out_le;
      break;
    }

    /* End of MultiPortSwitch: '<S834>/Multiport Switch' */

    /* MATLAB Function: '<S835>/AF for Vent mode R' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read15'
     */
    AFforVentmodeR(rtDW.FIU_BLOWERS_RR, &rtb_out_le);

    /* MATLAB Function: '<S835>/AF for Foot R' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read15'
     */
    AFforFootR(rtDW.FIU_BLOWERS_RR, &rtb_out_pf);

    /* MATLAB Function: '<S835>/AF for Bi Level R' incorporates:
     *  DataStoreRead: '<S7>/Data Store Read15'
     */
    AFforBiLevelR(rtDW.FIU_BLOWERS_RR, &rtb_out_khw);

    /* MultiPortSwitch: '<S835>/Multiport Switch' incorporates:
     *  Constant: '<S835>/Constant1'
     *  Constant: '<S835>/Constant2'
     *  Constant: '<S835>/Constant3'
     *  DataStoreRead: '<S7>/Data Store Read16'
     *  DataStoreRead: '<S7>/Data Store Read17'
     *  Gain: '<S835>/Gain2'
     *  RelationalOperator: '<S835>/Relational Operator1'
     *  RelationalOperator: '<S835>/Relational Operator2'
     *  Sum: '<S835>/Add'
     */
    switch ((int32_t)((uint32_t)((rtDW.FIU_FOOT_RR == 1) << 1) + (uint32_t)
                      (rtDW.FIU_FACE_RR == 1))) {
     case 0:
      rtb_out_khw = 0U;
      break;

     case 1:
      rtb_out_khw = rtb_out_le;
      break;

     case 2:
      rtb_out_khw = rtb_out_pf;
      break;
    }

    /* End of MultiPortSwitch: '<S835>/Multiport Switch' */

    /* DataTypeConversion: '<S815>/Data Type Conversion' incorporates:
     *  Constant: '<S815>/Constant1'
     *  DataStoreWrite: '<S815>/Data Store Write1'
     *  Product: '<S815>/Divide1'
     *  Sum: '<S815>/Add1'
     */
    rtDW.PWM_rear = (uint8_t)((double)(uint16_t)((uint32_t)rtb_out_b +
      rtb_out_khw) / 4.0);

    /* DataTypeConversion: '<S815>/Data Type Conversion4' incorporates:
     *  DataStoreWrite: '<S815>/Data Store Write4'
     */
    rtDW.Blower_AF_RL = (uint8_t)rtb_out_b;

    /* DataTypeConversion: '<S815>/Data Type Conversion5' incorporates:
     *  DataStoreWrite: '<S815>/Data Store Write5'
     */
    rtDW.Blower_AF_RR = (uint8_t)rtb_out_khw;

    /* MATLAB Function: '<S815>/Write1' incorporates:
     *  DataStoreWrite: '<S815>/Data Store Write1'
     */
    /* :  fprintf('pwmRear_output = %u \n',data); */
    printf("pwmRear_output = %u \n", rtDW.PWM_rear);
    fflush(stdout);
  }

  /* End of Logic: '<S812>/Logical Operator2' */
  /* End of Outputs for SubSystem: '<S812>/Subsystem1' */
  /* End of Outputs for SubSystem: '<Root>/PWM and valves in manual1' */

  /* If: '<S9>/если SC front не завершен' incorporates:
   *  DataStoreRead: '<S9>/Data Store Read'
   *  DataStoreRead: '<S9>/Data Store Read1'
   *  DataTypeConversion: '<S9>/Data Type Conversion'
   */
  if ((rtDW.start_control_finished_front == 0) &&
      (rtDW.SKIPPED_FIRST_SIMULATION_STEP == 0.0)) {
    /* Outputs for IfAction SubSystem: '<S9>/If Action Subsystem' incorporates:
     *  ActionPort: '<S874>/Action Port'
     */
    /* DataStoreWrite: '<S874>/Data Store Write' incorporates:
     *  Constant: '<S874>/Constant'
     */
    rtDW.SKIPPED_FIRST_SIMULATION_STEP = 1.0;

    /* End of Outputs for SubSystem: '<S9>/If Action Subsystem' */
  } else if (rtDW.start_control_finished_front == 0) {
    /* Outputs for IfAction SubSystem: '<S9>/Start Control Front' incorporates:
     *  ActionPort: '<S875>/Action Port'
     */
    /* SwitchCase: '<S875>/Switch Case' incorporates:
     *  DataStoreRead: '<S875>/Data Store Read'
     */
    switch (rtDW.step_start_controle_front) {
     case -1:
      /* Outputs for IfAction SubSystem: '<S875>/Step -1 F (Entry Condition)' incorporates:
       *  ActionPort: '<S877>/Action Port'
       */
      /* SwitchCase: '<S877>/Switch Case' incorporates:
       *  DataStoreWrite: '<S109>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S877>/Level 0' incorporates:
         *  ActionPort: '<S882>/Action Port'
         */
        /* MATLAB Function: '<S882>/g_assSTART_ENTER_INCAR' */
        g_assSTART_ENTER_INCAR_j(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S882>/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: '<S882>/Switch' incorporates:
         *  Constant: '<S882>/AUTO'
         *  DataStoreRead: '<S882>/Data Store Read'
         *  DataStoreRead: '<S882>/Data Store Read1'
         *  DataStoreRead: '<S882>/Data Store Read2'
         *  Logic: '<S882>/AND'
         *  MATLAB Function: '<S882>/g_ausSTART_ENTER_SETTEMP'
         *  RelationalOperator: '<S882>/Relational Operator'
         *  RelationalOperator: '<S882>/Relational Operator1'
         *  RelationalOperator: '<S882>/Relational Operator2'
         */
        if ((rtDW.Incar_FL > rtb_LVL) && (rtDW.MODE_DRIVER == 1.0) &&
            (rtDW.FIU_SET_FL < g_ausSTART_ENTER_SETTEMP[i - 1])) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S882>/Constant1'
           */
          rtB.Merge_h = 0;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S882>/Constant'
           */
          rtB.Merge_h = -1;
        }

        /* End of Switch: '<S882>/Switch' */
        /* End of Outputs for SubSystem: '<S877>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S877>/Level 1' incorporates:
         *  ActionPort: '<S883>/Action Port'
         */
        /* MATLAB Function: '<S883>/g_assSTART_ENTER_INCAR' */
        g_assSTART_ENTER_INCAR_j(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S883>/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;
        }

        rtb_out_b = g_ausSTART_ENTER_SETTEMP[i - 1];
        if (rtb_out_b > 32767) {
          rtb_out_b = 32767U;
        }

        /* Switch: '<S883>/Switch' incorporates:
         *  Constant: '<S883>/AUTO'
         *  DataStoreRead: '<S883>/Data Store Read'
         *  DataStoreRead: '<S883>/Data Store Read1'
         *  DataStoreRead: '<S883>/Data Store Read2'
         *  Logic: '<S883>/AND'
         *  MATLAB Function: '<S883>/g_ausSTART_ENTER_SETTEMP'
         *  RelationalOperator: '<S883>/Relational Operator'
         *  RelationalOperator: '<S883>/Relational Operator1'
         *  RelationalOperator: '<S883>/Relational Operator2'
         */
        if ((rtDW.Incar_FL > rtb_LVL) && (rtDW.MODE_DRIVER == 1.0) &&
            (rtDW.FIU_SET_FL < rtb_out_b)) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S883>/Constant1'
           */
          rtB.Merge_h = 0;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S883>/Constant'
           */
          rtB.Merge_h = -1;
        }

        /* End of Switch: '<S883>/Switch' */
        /* End of Outputs for SubSystem: '<S877>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S877>/Level 2' incorporates:
         *  ActionPort: '<S884>/Action Port'
         */
        /* Merge: '<S875>/Merge' incorporates:
         *  Constant: '<S884>/Constant'
         *  SignalConversion generated from: '<S884>/step'
         */
        rtB.Merge_h = 0;

        /* End of Outputs for SubSystem: '<S877>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S877>/Level 3' incorporates:
         *  ActionPort: '<S885>/Action Port'
         */
        /* MATLAB Function: '<S885>/g_assSTART_ENTER_COOLANT ' */
        g_assSTART_ENTER_COOLANT_p(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S885>/Switch' incorporates:
         *  Constant: '<S885>/AUTO'
         *  DataStoreRead: '<S885>/Data Store Read'
         *  DataStoreRead: '<S885>/Data Store Read1'
         *  Logic: '<S885>/AND'
         *  RelationalOperator: '<S885>/Relational Operator'
         *  RelationalOperator: '<S885>/Relational Operator2'
         */
        if ((rtDW.ECT < rtb_LVL) && (rtDW.MODE_DRIVER == 1.0)) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S885>/Constant1'
           */
          rtB.Merge_h = 0;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S885>/Constant'
           */
          rtB.Merge_h = -1;
        }

        /* End of Switch: '<S885>/Switch' */
        /* End of Outputs for SubSystem: '<S877>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S877>/Level 4' incorporates:
         *  ActionPort: '<S886>/Action Port'
         */
        Level4(&rtB.Merge_h, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);

        /* End of Outputs for SubSystem: '<S877>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S877>/Level 5' incorporates:
         *  ActionPort: '<S887>/Action Port'
         */
        Level4(&rtB.Merge_h, &rtDW.ECT, &rtB.Merge_b, &rtDW.MODE_DRIVER);

        /* End of Outputs for SubSystem: '<S877>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S877>/Switch Case' */
      /* End of Outputs for SubSystem: '<S875>/Step -1 F (Entry Condition)' */
      break;

     case 0:
      /* Outputs for IfAction SubSystem: '<S875>/Step 0 F' incorporates:
       *  ActionPort: '<S878>/Action Port'
       */
      /* SwitchCase: '<S878>/Switch Case' incorporates:
       *  DataStoreWrite: '<S109>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S878>/Level 0' incorporates:
         *  ActionPort: '<S895>/Action Port'
         */
        Level0(&rtB.Merge_h);

        /* End of Outputs for SubSystem: '<S878>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S878>/Level 1' incorporates:
         *  ActionPort: '<S896>/Action Port'
         */
        Level0(&rtB.Merge_h);

        /* End of Outputs for SubSystem: '<S878>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S878>/Level 2' incorporates:
         *  ActionPort: '<S897>/Action Port'
         */
        Level0(&rtB.Merge_h);

        /* End of Outputs for SubSystem: '<S878>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S878>/Level 3' incorporates:
         *  ActionPort: '<S898>/Action Port'
         */
        /* DataStoreWrite: '<S898>/Data Store Write6' incorporates:
         *  Constant: '<S898>/Constant3'
         */
        rtDW.Blower_FL = 20U;

        /* DataStoreWrite: '<S898>/Data Store Write11' incorporates:
         *  Constant: '<S898>/Constant5'
         */
        rtDW.Dtg_FUL = 60U;

        /* DataStoreWrite: '<S898>/Data Store Write13' incorporates:
         *  Constant: '<S898>/Constant7'
         */
        rtDW.Dtg_FLL = 80U;

        /* DataStoreWrite: '<S898>/Data Store Write' incorporates:
         *  MATLAB Function: '<S898>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S898>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S898>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* DataStoreWrite: '<S898>/Data Store Write3' incorporates:
         *  Constant: '<S898>/Mode - def'
         */
        rtDW.Mode_FL = 80U;

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

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

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

        /* MATLAB Function: '<S898>/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_Subtract = (uint32_t)i - 2U;
        if ((uint32_t)i - 2U > (uint32_t)i) {
          rtb_Subtract = 0U;
        }

        /* Merge: '<S875>/Merge' incorporates:
         *  DataStoreRead: '<S898>/Engine coolant temp'
         *  MATLAB Function: '<S898>/g_assSTART_COOLANT_STEP0_TO_1 '
         *  RelationalOperator: '<S898>/Relational Operator'
         *  Switch: '<S898>/Switch'
         */
        rtB.Merge_h = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1[(int32_t)
          rtb_Subtract - 1]);

        /* End of Outputs for SubSystem: '<S878>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S878>/Level 4' incorporates:
         *  ActionPort: '<S899>/Action Port'
         */
        /* DataStoreWrite: '<S899>/Data Store Write6' incorporates:
         *  Constant: '<S899>/Constant3'
         */
        rtDW.Blower_FL = 20U;

        /* DataStoreWrite: '<S899>/Data Store Write11' incorporates:
         *  Constant: '<S899>/Constant5'
         */
        rtDW.Dtg_FUL = 60U;

        /* DataStoreWrite: '<S899>/Data Store Write13' incorporates:
         *  Constant: '<S899>/Constant7'
         */
        rtDW.Dtg_FLL = 80U;

        /* DataStoreWrite: '<S899>/Data Store Write' incorporates:
         *  MATLAB Function: '<S899>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S899>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S899>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* DataStoreWrite: '<S899>/Data Store Write3' incorporates:
         *  Constant: '<S899>/Mode - def'
         */
        rtDW.Mode_FL = 80U;

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

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

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

        /* MATLAB Function: '<S899>/g_assSTART_COOLANT_STEP0_TO_1 ' */
        g_assSTART_COOLANT_STEP0_TO_1_h(rtB.Merge_b, &rtb_LVL);

        /* Merge: '<S875>/Merge' incorporates:
         *  DataStoreRead: '<S899>/Engine coolant temp'
         *  RelationalOperator: '<S899>/Relational Operator'
         *  Switch: '<S899>/Switch'
         */
        rtB.Merge_h = (int8_t)(rtDW.ECT > rtb_LVL);

        /* End of Outputs for SubSystem: '<S878>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S878>/Level 5' incorporates:
         *  ActionPort: '<S900>/Action Port'
         */
        /* DataStoreWrite: '<S900>/Data Store Write6' incorporates:
         *  Constant: '<S900>/Constant3'
         */
        rtDW.Blower_FL = 20U;

        /* DataStoreWrite: '<S900>/Data Store Write11' incorporates:
         *  Constant: '<S900>/Constant5'
         */
        rtDW.Dtg_FUL = 80U;

        /* DataStoreWrite: '<S900>/Data Store Write13' incorporates:
         *  Constant: '<S900>/Constant7'
         */
        rtDW.Dtg_FLL = 80U;

        /* DataStoreWrite: '<S900>/Data Store Write' incorporates:
         *  MATLAB Function: '<S900>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S900>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S900>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* DataStoreWrite: '<S900>/Data Store Write3' incorporates:
         *  Constant: '<S900>/Mode - def'
         */
        rtDW.Mode_FL = 80U;

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

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

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

        /* MATLAB Function: '<S900>/g_assSTART_COOLANT_STEP0_TO_1 ' */
        g_assSTART_COOLANT_STEP0_TO_1_h(rtB.Merge_b, &rtb_LVL);

        /* Merge: '<S875>/Merge' incorporates:
         *  DataStoreRead: '<S900>/Engine coolant temp'
         *  RelationalOperator: '<S900>/Relational Operator'
         *  Switch: '<S900>/Switch'
         */
        rtB.Merge_h = (int8_t)(rtDW.ECT > rtb_LVL);

        /* End of Outputs for SubSystem: '<S878>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S878>/Switch Case' */
      /* End of Outputs for SubSystem: '<S875>/Step 0 F' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S875>/Step 1 F' incorporates:
       *  ActionPort: '<S879>/Action Port'
       */
      /* SwitchCase: '<S879>/Switch Case' incorporates:
       *  DataStoreWrite: '<S109>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S879>/Level 0' incorporates:
         *  ActionPort: '<S910>/Action Port'
         */
        /* DataStoreWrite: '<S910>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S910>/3 way valve status'
         */
        uwayvalvestatus(rtB.Merge_b, &rtb_Merge_m);

        /* DataStoreWrite: '<S910>/Data Store Write' incorporates:
         *  MATLAB Function: '<S910>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S910>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S910>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* DataStoreWrite: '<S910>/Data Store Write3' incorporates:
         *  MATLAB Function: '<S910>/mode FR step 1'
         */
        modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);

        /* DataStoreWrite: '<S910>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S910>/window heating'
         */
        windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S910>/Data Store Write6' incorporates:
         *  MATLAB Function: '<S910>/blower FR'
         */
        blowerFR(rtB.Merge_b, &rtDW.Blower_FL);

        /* DataStoreWrite: '<S910>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S910>/Dtg_FrontUpper_X'
         */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S910>/Data Store Write13' incorporates:
         *  MATLAB Function: '<S910>/Dtg_FrontLower_X'
         */
        Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);

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

        /* RelationalOperator: '<S910>/Equal' incorporates:
         *  DataStoreRead: '<S910>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S910>/Incar temp goto from step 1 to step 2 ' */
        Incartempgotofromstep1tostep2(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S910>/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;
        }

        rtb_out_b = g_ausSTART_TIME_STEP1_TO_2[i - 1];
        if (rtb_out_b > 32767) {
          rtb_out_b = 32767U;
        }

        /* Switch: '<S910>/Switch' incorporates:
         *  DataStoreRead: '<S910>/incar temp'
         *  DataStoreRead: '<S920>/Data Store Read4'
         *  Gain: '<S910>/из сек в мс'
         *  Logic: '<S910>/Logical Operator'
         *  MATLAB Function: '<S910>/Time goto from step 1 to step 2 '
         *  RelationalOperator: '<S910>/Relational Operator'
         *  RelationalOperator: '<S910>/Relational Operator1'
         *  Sum: '<S920>/Subtract'
         *  UnitDelay: '<S920>/t_start_delay_private '
         */
        if ((rtDW.Incar_FL < rtb_LVL) || (rtDW.t_now -
             rtDW.t_start_delay_private_DSTATE_pd > (uint16_t)(1000 * rtb_out_b)))
        {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S910>/go to next step'
           *  SignalConversion generated from: '<S910>/step'
           */
          rtB.Merge_h = 2;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S910>/stay at step 1'
           *  SignalConversion generated from: '<S910>/step'
           */
          rtB.Merge_h = 1;
        }

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

        /* Switch: '<S920>/Switch' incorporates:
         *  DataStoreRead: '<S920>/Data Store Read4'
         *  Logic: '<S920>/Logical Operator3'
         *  Logic: '<S920>/Logical Operator4'
         *  UnitDelay: '<S920>/Cond_prev_private '
         *  UnitDelay: '<S920>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_gx)) {
          rtDW.t_start_delay_private_DSTATE_pd = rtDW.t_now;
        }

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

        /* Update for UnitDelay: '<S920>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_gx = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S879>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S879>/Level 1' incorporates:
         *  ActionPort: '<S911>/Action Port'
         */
        /* DataStoreWrite: '<S911>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S911>/3 way valve status'
         */
        uwayvalvestatus(rtB.Merge_b, &rtb_Merge_m);

        /* DataStoreWrite: '<S911>/Data Store Write' incorporates:
         *  MATLAB Function: '<S911>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S911>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S911>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* DataStoreWrite: '<S911>/Data Store Write3' incorporates:
         *  MATLAB Function: '<S911>/mode FR step 1'
         */
        modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);

        /* DataStoreWrite: '<S911>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S911>/window heating'
         */
        windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S911>/Data Store Write6' incorporates:
         *  MATLAB Function: '<S911>/blower FR'
         */
        blowerFR(rtB.Merge_b, &rtDW.Blower_FL);

        /* DataStoreWrite: '<S911>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S911>/Dtg_FrontUpper_X'
         */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S911>/Data Store Write13' incorporates:
         *  MATLAB Function: '<S911>/Dtg_FrontLower_X'
         */
        Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);

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

        /* RelationalOperator: '<S911>/Equal' incorporates:
         *  DataStoreRead: '<S911>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S911>/Incar temp goto from step 1 to step 2 ' */
        Incartempgotofromstep1tostep2(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S911>/Time goto from step 1 to step 2 ' */
        Timegotofromstep1tostep2(rtB.Merge_b, &Duct2_F);

        /* RelationalOperator: '<S911>/Relational Operator1' incorporates:
         *  DataStoreRead: '<S931>/Data Store Read4'
         *  Gain: '<S911>/из сек в мс'
         *  Sum: '<S931>/Subtract'
         *  UnitDelay: '<S931>/t_start_delay_private '
         */
        rtb_LogicalOperator1_dv = (rtDW.t_now -
          rtDW.t_start_delay_private_DSTATE_mk > (uint32_t)(1000 * Duct2_F));

        /* Switch: '<S931>/Switch' incorporates:
         *  DataStoreRead: '<S931>/Data Store Read4'
         *  Logic: '<S931>/Logical Operator3'
         *  Logic: '<S931>/Logical Operator4'
         *  UnitDelay: '<S931>/Cond_prev_private '
         *  UnitDelay: '<S931>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_hs)) {
          rtDW.t_start_delay_private_DSTATE_mk = rtDW.t_now;
        }

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

        /* Switch: '<S911>/Switch' incorporates:
         *  DataStoreRead: '<S911>/incar temp'
         *  Logic: '<S911>/Logical Operator'
         *  RelationalOperator: '<S911>/Relational Operator'
         */
        if ((rtDW.Incar_FL < rtb_LVL) || rtb_LogicalOperator1_dv) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S911>/go to next step'
           */
          rtB.Merge_h = 2;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S911>/stay at step 1'
           */
          rtB.Merge_h = 1;
        }

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

        /* Update for UnitDelay: '<S931>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_hs = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S879>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S879>/Level 2' incorporates:
         *  ActionPort: '<S912>/Action Port'
         */
        /* Merge: '<S875>/Merge' incorporates:
         *  Constant: '<S912>/Constant'
         *  SignalConversion generated from: '<S912>/step'
         */
        rtB.Merge_h = 2;

        /* End of Outputs for SubSystem: '<S879>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S879>/Level 3' incorporates:
         *  ActionPort: '<S913>/Action Port'
         */
        /* DataStoreWrite: '<S913>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S913>/3 way valve status'
         */
        uwayvalvestatus(rtB.Merge_b, &rtb_Merge_m);

        /* DataStoreWrite: '<S913>/Data Store Write' incorporates:
         *  MATLAB Function: '<S913>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S913>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S913>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* DataStoreWrite: '<S913>/Data Store Write3' incorporates:
         *  MATLAB Function: '<S913>/mode FR step 1'
         */
        modeFRstep1(rtB.Merge_b, &rtDW.Mode_FL);

        /* DataStoreWrite: '<S913>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S913>/window heating'
         */
        windowheating(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* MATLAB Function: '<S944>/blower min max' */
        blowerminmax(rtB.Merge_b, rtb_out_f0);

        /* MATLAB Function: '<S944>/ECT min max' */
        ECTminmax(rtB.Merge_b, rtb_out_md);

        /* Lookup_n-D: '<S944>/blower для текущего ECT' incorporates:
         *  DataStoreRead: '<S944>/engine coolant temp'
         */
        rtb_LVL = look1_is16lu64n32tu16Ds32Is16_binlcs(rtDW.ECT, rtb_out_md,
          rtb_out_f0, 1U);

        /* DataStoreWrite: '<S913>/Data Store Write6' incorporates:
         *  DataTypeConversion: '<S944>/Data Type Conversion'
         */
        rtDW.Blower_FL = (uint16_t)rtb_LVL;

        /* DataStoreWrite: '<S913>/Data Store Write11' incorporates:
         *  MATLAB Function: '<S913>/Dtg_FrontUpper_X'
         */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtDW.Dtg_FUL);

        /* DataStoreWrite: '<S913>/Data Store Write13' incorporates:
         *  MATLAB Function: '<S913>/Dtg_FrontLower_X'
         */
        Dtg_FrontLower_X(rtB.Merge_b, &rtDW.Dtg_FLL);

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

        /* RelationalOperator: '<S913>/Equal' incorporates:
         *  DataStoreRead: '<S913>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 1);

        /* MATLAB Function: '<S913>/Incar temp goto from step 1 to step 2 ' */
        Incartempgotofromstep1tostep2(rtB.Merge_b, &Duct2_F);

        /* MATLAB Function: '<S913>/Time goto from step 1 to step 2 ' */
        Timegotofromstep1tostep2(rtB.Merge_b, &rtb_LVL);

        /* RelationalOperator: '<S913>/Relational Operator1' incorporates:
         *  DataStoreRead: '<S942>/Data Store Read4'
         *  Gain: '<S913>/из сек в мс'
         *  Sum: '<S942>/Subtract'
         *  UnitDelay: '<S942>/t_start_delay_private '
         */
        rtb_LogicalOperator1_dv = (rtDW.t_now -
          rtDW.t_start_delay_private_DSTATE_fm > (uint32_t)(1000 * rtb_LVL));

        /* Switch: '<S942>/Switch' incorporates:
         *  DataStoreRead: '<S942>/Data Store Read4'
         *  Logic: '<S942>/Logical Operator3'
         *  Logic: '<S942>/Logical Operator4'
         *  UnitDelay: '<S942>/Cond_prev_private '
         *  UnitDelay: '<S942>/t_start_delay_private '
         */
        /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(LVL + 1 - 3)); */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_fi)) {
          rtDW.t_start_delay_private_DSTATE_fm = rtDW.t_now;
        }

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

        /* MATLAB Function: '<S913>/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_Subtract = (uint32_t)i - 3U;

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

        /* Switch: '<S913>/Switch' incorporates:
         *  DataStoreRead: '<S913>/engine coolant temp'
         *  DataStoreRead: '<S913>/incar temp'
         *  Logic: '<S913>/Logical Operator'
         *  MATLAB Function: '<S913>/g_assSTART_COOLANT_TO_STEP2 '
         *  RelationalOperator: '<S913>/Relational Operator'
         *  RelationalOperator: '<S913>/Relational Operator2'
         */
        if ((rtDW.Incar_FL < Duct2_F) || rtb_LogicalOperator1_dv || (rtDW.ECT >
             g_assSTART_COOLANT_TO_STEP2[(int32_t)rtb_Subtract - 1])) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S913>/go to next step 2'
           */
          rtB.Merge_h = 2;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S913>/stay at step 1'
           */
          rtB.Merge_h = 1;
        }

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

        /* Update for UnitDelay: '<S942>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_fi = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S879>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S879>/Level 4' incorporates:
         *  ActionPort: '<S914>/Action Port'
         */
        Level4_c(&rtB.Merge_h, &rtDW.Blower_FL, &rtb_out_b, &rtDW.Dtg_FLL,
                 &rtb_Merge_a, &rtDW.Dtg_FUL, &Dtg_FUR, &rtDW.ECT,
                 &El_window_heating, &rtDW.Incar_FL, &rtb_Merge_e, &rtb_Merge_j,
                 &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtb_rate, &rtb_Merge_m,
                 &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level4_cw);

        /* End of Outputs for SubSystem: '<S879>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S879>/Level 5' incorporates:
         *  ActionPort: '<S915>/Action Port'
         */
        Level4_c(&rtB.Merge_h, &rtDW.Blower_FL, &rtb_out_b, &rtDW.Dtg_FLL,
                 &rtb_Merge_a, &rtDW.Dtg_FUL, &Dtg_FUR, &rtDW.ECT,
                 &El_window_heating, &rtDW.Incar_FL, &rtb_Merge_e, &rtb_Merge_j,
                 &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtb_rate, &rtb_Merge_m,
                 &rtDW.step_start_controle_front, &rtDW.t_now, &rtDW.Level5_g);

        /* End of Outputs for SubSystem: '<S879>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S879>/Switch Case' */
      /* End of Outputs for SubSystem: '<S875>/Step 1 F' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S875>/Step 2 F' incorporates:
       *  ActionPort: '<S880>/Action Port'
       */
      /* SwitchCase: '<S880>/Switch Case' incorporates:
       *  DataStoreWrite: '<S109>/Data Store Write'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S880>/Level 0' incorporates:
         *  ActionPort: '<S978>/Action Port'
         */
        /* DataStoreWrite: '<S978>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S978>/3 way valve status'
         */
        uwayvalvestatus_a(rtB.Merge_b, &rtb_Merge_m);

        /* MATLAB Function: '<S985>/step' */
        Dtg_FrontLower_X(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S985>/time for step' */
        timeforstep(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S985>/Switch' incorporates:
         *  Constant: '<S994>/epsilon'
         *  DataStoreRead: '<S985>/Текущее значение blower '
         *  DataStoreRead: '<S985>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S994>/Relational Operator'
         *  RelationalOperator: '<S998>/Relational Operator'
         *  Sum: '<S994>/Add'
         *  Switch: '<S998>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
          /* DataStoreWrite: '<S978>/Data Store Write13' */
          rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
        } else {
          if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
            /* Switch: '<S998>/Switch' incorporates:
             *  Constant: '<S998>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S998>/Switch' incorporates:
             *  Constant: '<S998>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S978>/Data Store Write13' incorporates:
           *  Constant: '<S985>/Constant'
           *  DataStoreRead: '<S985>/текущее время в мс'
           *  Product: '<S985>/Product1'
           *  Product: '<S985>/change rate (dtg//sec)'
           *  Product: '<S985>/скорость в мс'
           *  Product: '<S985>/шаг изменения'
           *  Sum: '<S985>/Add'
           *  Sum: '<S995>/Subtract'
           *  Switch: '<S998>/Switch'
           *  UnitDelay: '<S995>/Unit Delay'
           */
          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_k) * (double)i
            + (double)rtDW.Dtg_FLL);
        }

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

        /* MATLAB Function: '<S986>/step' */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S986>/time for step' */
        timeforstep_j(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S986>/Switch' incorporates:
         *  Constant: '<S999>/epsilon'
         *  DataStoreRead: '<S986>/Текущее значение blower '
         *  DataStoreRead: '<S986>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1003>/Relational Operator'
         *  RelationalOperator: '<S999>/Relational Operator'
         *  Sum: '<S999>/Add'
         *  Switch: '<S1003>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
          /* DataStoreWrite: '<S978>/Data Store Write11' */
          rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
        } else {
          if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
            /* Switch: '<S1003>/Switch' incorporates:
             *  Constant: '<S1003>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1003>/Switch' incorporates:
             *  Constant: '<S1003>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S978>/Data Store Write11' incorporates:
           *  Constant: '<S986>/Constant'
           *  DataStoreRead: '<S986>/текущее время в мс'
           *  Product: '<S986>/Product1'
           *  Product: '<S986>/change rate (dtg//sec)'
           *  Product: '<S986>/скорость в мс'
           *  Product: '<S986>/шаг изменения'
           *  Sum: '<S1000>/Subtract'
           *  Sum: '<S986>/Add'
           *  Switch: '<S1003>/Switch'
           *  UnitDelay: '<S1000>/Unit Delay'
           */
          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_pb) * (double)i
            + (double)rtDW.Dtg_FUL);
        }

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

        /* DataStoreWrite: '<S978>/Data Store Write' incorporates:
         *  MATLAB Function: '<S978>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S978>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S978>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* Sum: '<S1009>/Add' incorporates:
         *  DataStoreRead: '<S992>/Текущее значение blower '
         *  DataStoreRead: '<S992>/значение auto (в соответствии с логикой)'
         */
        rtb_Merge_j = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);

        /* RelationalOperator: '<S1009>/Relational Operator' incorporates:
         *  Constant: '<S1009>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_Merge_j <= 0.01);

        /* MATLAB Function: '<S992>/step' */
        step_j(rtB.Merge_b, &rtb_Merge_e);

        /* MATLAB Function: '<S992>/time for step' */
        timeforstep_g(rtB.Merge_b, &rtb_Merge_j);

        /* Switch: '<S992>/Switch' incorporates:
         *  DataStoreRead: '<S992>/Текущее значение blower '
         *  DataStoreRead: '<S992>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1013>/Relational Operator'
         *  Switch: '<S1013>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S978>/Data Store Write3' incorporates:
           *  DataStoreRead: '<S992>/значение auto (в соответствии с логикой)'
           */
          rtDW.Mode_FL = rtDW.Mode_logic_FL;
        } else {
          if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
            /* Switch: '<S1013>/Switch' incorporates:
             *  Constant: '<S1013>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1013>/Switch' incorporates:
             *  Constant: '<S1013>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S978>/Data Store Write3' incorporates:
           *  Constant: '<S992>/Constant'
           *  DataStoreRead: '<S992>/Текущее значение blower '
           *  DataStoreRead: '<S992>/текущее время в мс'
           *  Product: '<S992>/Product1'
           *  Product: '<S992>/change rate (step//sec)'
           *  Product: '<S992>/скорость в мс'
           *  Product: '<S992>/шаг изменения'
           *  Sum: '<S1010>/Subtract'
           *  Sum: '<S992>/Add'
           *  Switch: '<S1013>/Switch'
           *  UnitDelay: '<S1010>/Unit Delay'
           */
          rtDW.Mode_FL = (uint8_t)((double)rtb_Merge_e / (double)rtb_Merge_j /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_mk) * (double)i
            + (double)rtDW.Mode_FL);
        }

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

        /* Sum: '<S1004>/Add' incorporates:
         *  DataStoreRead: '<S989>/Текущее значение blower '
         *  DataStoreRead: '<S989>/значение auto (в соответствии с логикой)'
         */
        /* :  out = g_aucSTART_ELEC_WINDOW(LVL + 1 + 6); */
        rtb_out_b = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);

        /* RelationalOperator: '<S1004>/Relational Operator' incorporates:
         *  Constant: '<S1004>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_out_b <= 0.01);

        /* MATLAB Function: '<S989>/blower step' */
        blowerstep(rtB.Merge_b, &rtb_out_khw);

        /* MATLAB Function: '<S989>/blower time for step' */
        blowertimeforstep(rtB.Merge_b, &rtb_out_b);

        /* Switch: '<S989>/Switch' incorporates:
         *  DataStoreRead: '<S989>/Текущее значение blower '
         *  DataStoreRead: '<S989>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1008>/Relational Operator'
         *  Switch: '<S1008>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S978>/Data Store Write6' incorporates:
           *  DataStoreRead: '<S989>/значение auto (в соответствии с логикой)'
           */
          rtDW.Blower_FL = rtDW.Blower_logic_FL;
        } else {
          if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
            /* Switch: '<S1008>/Switch' incorporates:
             *  Constant: '<S1008>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1008>/Switch' incorporates:
             *  Constant: '<S1008>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S978>/Data Store Write6' incorporates:
           *  Constant: '<S989>/Constant'
           *  DataStoreRead: '<S989>/Текущее значение blower '
           *  DataStoreRead: '<S989>/текущее время в мс'
           *  Product: '<S989>/Product1'
           *  Product: '<S989>/change rate (step//sec)'
           *  Product: '<S989>/скорость в мс'
           *  Product: '<S989>/шаг изменения'
           *  Sum: '<S1005>/Subtract'
           *  Sum: '<S989>/Add'
           *  Switch: '<S1008>/Switch'
           *  UnitDelay: '<S1005>/Unit Delay'
           */
          rtDW.Blower_FL = (uint16_t)((double)rtb_out_khw / (double)rtb_out_b /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gm) * (double)i
            + (double)rtDW.Blower_FL);
        }

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

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

        /* RelationalOperator: '<S978>/Equal' incorporates:
         *  DataStoreRead: '<S978>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 2);

        /* Sum: '<S987>/Subtract' incorporates:
         *  DataStoreRead: '<S987>/Data Store Read4'
         *  UnitDelay: '<S987>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_gp;

        /* Switch: '<S987>/Switch' incorporates:
         *  DataStoreRead: '<S987>/Data Store Read4'
         *  Logic: '<S987>/Logical Operator3'
         *  Logic: '<S987>/Logical Operator4'
         *  UnitDelay: '<S987>/Cond_prev_private '
         *  UnitDelay: '<S987>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_mb)) {
          rtDW.t_start_delay_private_DSTATE_gp = rtDW.t_now;
        }

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

        /* MATLAB Function: '<S978>/Time goto from step 2 to step 3 ' */
        Timegotofromstep2tostep3(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S978>/Switch' incorporates:
         *  Gain: '<S978>/из сек в мс'
         *  RelationalOperator: '<S978>/Relational Operator1'
         */
        if (rtb_Subtract > (uint32_t)(1000 * rtb_LVL)) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S978>/go to next step'
           */
          rtB.Merge_h = 3;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S978>/stay at step'
           */
          rtB.Merge_h = 2;
        }

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

        /* Update for UnitDelay: '<S995>/Unit Delay' incorporates:
         *  DataStoreRead: '<S985>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_k = rtDW.t_now;

        /* Update for UnitDelay: '<S1000>/Unit Delay' incorporates:
         *  DataStoreRead: '<S986>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_pb = rtDW.t_now;

        /* Update for UnitDelay: '<S1010>/Unit Delay' incorporates:
         *  DataStoreRead: '<S992>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_mk = rtDW.t_now;

        /* Update for UnitDelay: '<S1005>/Unit Delay' incorporates:
         *  DataStoreRead: '<S989>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_gm = rtDW.t_now;

        /* Update for UnitDelay: '<S987>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_mb = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S880>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S880>/Level 1' incorporates:
         *  ActionPort: '<S979>/Action Port'
         */
        /* DataStoreWrite: '<S979>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S979>/3 way valve status'
         */
        uwayvalvestatus_a(rtB.Merge_b, &rtb_Merge_m);

        /* MATLAB Function: '<S1015>/step' */
        Dtg_FrontLower_X(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1015>/time for step' */
        timeforstep(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1015>/Switch' incorporates:
         *  Constant: '<S1024>/epsilon'
         *  DataStoreRead: '<S1015>/Текущее значение blower '
         *  DataStoreRead: '<S1015>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1024>/Relational Operator'
         *  RelationalOperator: '<S1028>/Relational Operator'
         *  Sum: '<S1024>/Add'
         *  Switch: '<S1028>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
          /* DataStoreWrite: '<S979>/Data Store Write13' */
          rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
        } else {
          if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
            /* Switch: '<S1028>/Switch' incorporates:
             *  Constant: '<S1028>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1028>/Switch' incorporates:
             *  Constant: '<S1028>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S979>/Data Store Write13' incorporates:
           *  Constant: '<S1015>/Constant'
           *  DataStoreRead: '<S1015>/текущее время в мс'
           *  Product: '<S1015>/Product1'
           *  Product: '<S1015>/change rate (dtg//sec)'
           *  Product: '<S1015>/скорость в мс'
           *  Product: '<S1015>/шаг изменения'
           *  Sum: '<S1015>/Add'
           *  Sum: '<S1025>/Subtract'
           *  Switch: '<S1028>/Switch'
           *  UnitDelay: '<S1025>/Unit Delay'
           */
          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_m) * (double)i
            + (double)rtDW.Dtg_FLL);
        }

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

        /* MATLAB Function: '<S1016>/step' */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1016>/time for step' */
        timeforstep_j(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1016>/Switch' incorporates:
         *  Constant: '<S1029>/epsilon'
         *  DataStoreRead: '<S1016>/Текущее значение blower '
         *  DataStoreRead: '<S1016>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1029>/Relational Operator'
         *  RelationalOperator: '<S1033>/Relational Operator'
         *  Sum: '<S1029>/Add'
         *  Switch: '<S1033>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
          /* DataStoreWrite: '<S979>/Data Store Write11' */
          rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
        } else {
          if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
            /* Switch: '<S1033>/Switch' incorporates:
             *  Constant: '<S1033>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1033>/Switch' incorporates:
             *  Constant: '<S1033>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S979>/Data Store Write11' incorporates:
           *  Constant: '<S1016>/Constant'
           *  DataStoreRead: '<S1016>/текущее время в мс'
           *  Product: '<S1016>/Product1'
           *  Product: '<S1016>/change rate (dtg//sec)'
           *  Product: '<S1016>/скорость в мс'
           *  Product: '<S1016>/шаг изменения'
           *  Sum: '<S1016>/Add'
           *  Sum: '<S1030>/Subtract'
           *  Switch: '<S1033>/Switch'
           *  UnitDelay: '<S1030>/Unit Delay'
           */
          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_gf) * (double)i
            + (double)rtDW.Dtg_FUL);
        }

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

        /* DataStoreWrite: '<S979>/Data Store Write' incorporates:
         *  MATLAB Function: '<S979>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S979>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S979>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* Sum: '<S1039>/Add' incorporates:
         *  DataStoreRead: '<S1022>/Текущее значение blower '
         *  DataStoreRead: '<S1022>/значение auto (в соответствии с логикой)'
         */
        rtb_Merge_j = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);

        /* MATLAB Function: '<S1022>/step' */
        step_j(rtB.Merge_b, &rtb_Merge_e);

        /* MATLAB Function: '<S1022>/time for step' */
        timeforstep_g(rtB.Merge_b, &rtb_Merge_m);

        /* Switch: '<S1022>/Switch' incorporates:
         *  Constant: '<S1039>/epsilon'
         *  DataStoreRead: '<S1022>/Текущее значение blower '
         *  DataStoreRead: '<S1022>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1039>/Relational Operator'
         *  RelationalOperator: '<S1043>/Relational Operator'
         *  Switch: '<S1043>/Switch'
         */
        if (rtb_Merge_j <= 0.01) {
          /* DataStoreWrite: '<S979>/Data Store Write3' incorporates:
           *  DataStoreRead: '<S1022>/значение auto (в соответствии с логикой)'
           */
          rtDW.Mode_FL = rtDW.Mode_logic_FL;
        } else {
          if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
            /* Switch: '<S1043>/Switch' incorporates:
             *  Constant: '<S1043>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1043>/Switch' incorporates:
             *  Constant: '<S1043>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S979>/Data Store Write3' incorporates:
           *  Constant: '<S1022>/Constant'
           *  DataStoreRead: '<S1022>/Текущее значение blower '
           *  DataStoreRead: '<S1022>/текущее время в мс'
           *  Product: '<S1022>/Product1'
           *  Product: '<S1022>/change rate (step//sec)'
           *  Product: '<S1022>/скорость в мс'
           *  Product: '<S1022>/шаг изменения'
           *  Sum: '<S1022>/Add'
           *  Sum: '<S1040>/Subtract'
           *  Switch: '<S1043>/Switch'
           *  UnitDelay: '<S1040>/Unit Delay'
           */
          rtDW.Mode_FL = (uint8_t)((double)rtb_Merge_e / (double)rtb_Merge_m /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_l) * (double)i
            + (double)rtDW.Mode_FL);
        }

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

        /* MATLAB Function: '<S979>/window heating' */
        windowheating_k(rtB.Merge_b, &rtb_Merge_j);

        /* Sum: '<S1034>/Add' incorporates:
         *  DataStoreRead: '<S1019>/Текущее значение blower '
         *  DataStoreRead: '<S1019>/значение auto (в соответствии с логикой)'
         */
        rtb_out_b = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);

        /* RelationalOperator: '<S1034>/Relational Operator' incorporates:
         *  Constant: '<S1034>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_out_b <= 0.01);

        /* MATLAB Function: '<S1019>/blower step' */
        blowerstep(rtB.Merge_b, &rtb_out_khw);

        /* MATLAB Function: '<S1019>/blower time for step' */
        blowertimeforstep(rtB.Merge_b, &rtb_out_b);

        /* Switch: '<S1019>/Switch' incorporates:
         *  DataStoreRead: '<S1019>/Текущее значение blower '
         *  DataStoreRead: '<S1019>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1038>/Relational Operator'
         *  Switch: '<S1038>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S979>/Data Store Write6' incorporates:
           *  DataStoreRead: '<S1019>/значение auto (в соответствии с логикой)'
           */
          rtDW.Blower_FL = rtDW.Blower_logic_FL;
        } else {
          if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
            /* Switch: '<S1038>/Switch' incorporates:
             *  Constant: '<S1038>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1038>/Switch' incorporates:
             *  Constant: '<S1038>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S979>/Data Store Write6' incorporates:
           *  Constant: '<S1019>/Constant'
           *  DataStoreRead: '<S1019>/Текущее значение blower '
           *  DataStoreRead: '<S1019>/текущее время в мс'
           *  Product: '<S1019>/Product1'
           *  Product: '<S1019>/change rate (step//sec)'
           *  Product: '<S1019>/скорость в мс'
           *  Product: '<S1019>/шаг изменения'
           *  Sum: '<S1019>/Add'
           *  Sum: '<S1035>/Subtract'
           *  Switch: '<S1038>/Switch'
           *  UnitDelay: '<S1035>/Unit Delay'
           */
          rtDW.Blower_FL = (uint16_t)((double)rtb_out_khw / (double)rtb_out_b /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p0) * (double)i
            + (double)rtDW.Blower_FL);
        }

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

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

        /* RelationalOperator: '<S979>/Equal' incorporates:
         *  DataStoreRead: '<S979>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 2);

        /* Sum: '<S1017>/Subtract' incorporates:
         *  DataStoreRead: '<S1017>/Data Store Read4'
         *  UnitDelay: '<S1017>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_mz;

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

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

        /* MATLAB Function: '<S979>/Time goto from step 2 to step 3 ' */
        Timegotofromstep2tostep3(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S979>/Switch' incorporates:
         *  Gain: '<S979>/из сек в мс'
         *  RelationalOperator: '<S979>/Relational Operator1'
         */
        if (rtb_Subtract > (uint32_t)(1000 * rtb_LVL)) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S979>/go to next step'
           */
          rtB.Merge_h = 3;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S979>/stay at step'
           */
          rtB.Merge_h = 2;
        }

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

        /* Update for UnitDelay: '<S1025>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1015>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_m = rtDW.t_now;

        /* Update for UnitDelay: '<S1030>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1016>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_gf = rtDW.t_now;

        /* Update for UnitDelay: '<S1040>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1022>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_l = rtDW.t_now;

        /* Update for UnitDelay: '<S1035>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1019>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_p0 = rtDW.t_now;

        /* Update for UnitDelay: '<S1017>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_b = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S880>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S880>/Level 2' incorporates:
         *  ActionPort: '<S980>/Action Port'
         */
        /* Merge: '<S875>/Merge' incorporates:
         *  Constant: '<S980>/Constant'
         *  SignalConversion generated from: '<S980>/step'
         */
        rtB.Merge_h = 3;

        /* End of Outputs for SubSystem: '<S880>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S880>/Level 3' incorporates:
         *  ActionPort: '<S981>/Action Port'
         */
        Level3(&rtB.Merge_h, &Autodefog, &rtDW.Blower_FL, &rtb_out_b,
               &rtDW.Blower_logic_FL, &rtDW.Dtg_FLL, &rtb_Merge_a, &rtDW.Dtg_FUL,
               &Dtg_FUR, &rtDW.Dtg_logic_FLL, &rtDW.Dtg_logic_FUL,
               &El_window_heating, &rtDW.HI_logic_on, &rtb_Merge_e, &rtb_Merge_j,
               &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtDW.Mode_logic_FL,
               &rtb_rate, &rtb_Merge_m, &rtDW.step_start_controle_front,
               &rtDW.t_now, &rtDW.Level3_l);

        /* End of Outputs for SubSystem: '<S880>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S880>/Level 4' incorporates:
         *  ActionPort: '<S982>/Action Port'
         */
        Level3(&rtB.Merge_h, &Autodefog, &rtDW.Blower_FL, &rtb_out_b,
               &rtDW.Blower_logic_FL, &rtDW.Dtg_FLL, &rtb_Merge_a, &rtDW.Dtg_FUL,
               &Dtg_FUR, &rtDW.Dtg_logic_FLL, &rtDW.Dtg_logic_FUL,
               &El_window_heating, &rtDW.HI_logic_on, &rtb_Merge_e, &rtb_Merge_j,
               &rtB.Merge_b, &rtDW.Mode_FL, &Mode_FR, &rtDW.Mode_logic_FL,
               &rtb_rate, &rtb_Merge_m, &rtDW.step_start_controle_front,
               &rtDW.t_now, &rtDW.Level4_a);

        /* End of Outputs for SubSystem: '<S880>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S880>/Level 5' incorporates:
         *  ActionPort: '<S983>/Action Port'
         */
        /* DataStoreWrite: '<S983>/Data Store Write8' incorporates:
         *  MATLAB Function: '<S983>/3 way valve status'
         */
        uwayvalvestatus_a(rtB.Merge_b, &rtb_Merge_m);

        /* MATLAB Function: '<S1107>/step' */
        Dtg_FrontLower_X(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1107>/time for step' */
        timeforstep(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1107>/Switch' incorporates:
         *  Constant: '<S1117>/epsilon'
         *  DataStoreRead: '<S1107>/Текущее значение blower '
         *  DataStoreRead: '<S1107>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1117>/Relational Operator'
         *  RelationalOperator: '<S1121>/Relational Operator'
         *  Sum: '<S1117>/Add'
         *  Switch: '<S1121>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FLL - rtDW.Dtg_logic_FLL) <= 0.01) {
          /* DataStoreWrite: '<S983>/Data Store Write13' */
          rtDW.Dtg_FLL = rtDW.Dtg_logic_FLL;
        } else {
          if (rtDW.Dtg_FLL <= rtDW.Dtg_logic_FLL) {
            /* Switch: '<S1121>/Switch' incorporates:
             *  Constant: '<S1121>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1121>/Switch' incorporates:
             *  Constant: '<S1121>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S983>/Data Store Write13' incorporates:
           *  Constant: '<S1107>/Constant'
           *  DataStoreRead: '<S1107>/текущее время в мс'
           *  Product: '<S1107>/Product1'
           *  Product: '<S1107>/change rate (dtg//sec)'
           *  Product: '<S1107>/скорость в мс'
           *  Product: '<S1107>/шаг изменения'
           *  Sum: '<S1107>/Add'
           *  Sum: '<S1118>/Subtract'
           *  Switch: '<S1121>/Switch'
           *  UnitDelay: '<S1118>/Unit Delay'
           */
          rtDW.Dtg_FLL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_f) * (double)i
            + (double)rtDW.Dtg_FLL);
        }

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

        /* MATLAB Function: '<S1108>/step' */
        Dtg_FrontUpper_X(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1108>/time for step' */
        timeforstep_j(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1108>/Switch' incorporates:
         *  Constant: '<S1122>/epsilon'
         *  DataStoreRead: '<S1108>/Текущее значение blower '
         *  DataStoreRead: '<S1108>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1122>/Relational Operator'
         *  RelationalOperator: '<S1126>/Relational Operator'
         *  Sum: '<S1122>/Add'
         *  Switch: '<S1126>/Switch'
         */
        if ((uint8_t)(rtDW.Dtg_FUL - rtDW.Dtg_logic_FUL) <= 0.01) {
          /* DataStoreWrite: '<S983>/Data Store Write11' */
          rtDW.Dtg_FUL = rtDW.Dtg_logic_FUL;
        } else {
          if (rtDW.Dtg_FUL <= rtDW.Dtg_logic_FUL) {
            /* Switch: '<S1126>/Switch' incorporates:
             *  Constant: '<S1126>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1126>/Switch' incorporates:
             *  Constant: '<S1126>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S983>/Data Store Write11' incorporates:
           *  Constant: '<S1108>/Constant'
           *  DataStoreRead: '<S1108>/текущее время в мс'
           *  Product: '<S1108>/Product1'
           *  Product: '<S1108>/change rate (dtg//sec)'
           *  Product: '<S1108>/скорость в мс'
           *  Product: '<S1108>/шаг изменения'
           *  Sum: '<S1108>/Add'
           *  Sum: '<S1123>/Subtract'
           *  Switch: '<S1126>/Switch'
           *  UnitDelay: '<S1123>/Unit Delay'
           */
          rtDW.Dtg_FUL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_pu) * (double)i
            + (double)rtDW.Dtg_FUL);
        }

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

        /* DataStoreWrite: '<S983>/Data Store Write' incorporates:
         *  MATLAB Function: '<S983>/incar filter up'
         */
        incarfilterup(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S983>/Data Store Write1' incorporates:
         *  MATLAB Function: '<S983>/incar filter down'
         */
        incarfilterdown(rtB.Merge_b, &rtb_Merge_e);

        /* MATLAB Function: '<S983>/autodemist (autodefog)' */
        autodemistautodefog(rtB.Merge_b, &rtb_Merge_j);

        /* Sum: '<S1132>/Add' incorporates:
         *  DataStoreRead: '<S1115>/Текущее значение blower '
         *  DataStoreRead: '<S1115>/значение auto (в соответствии с логикой)'
         */
        rtb_Merge_e = (uint8_t)(rtDW.Mode_FL - rtDW.Mode_logic_FL);

        /* MATLAB Function: '<S1115>/step' */
        step_j(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1115>/time for step' */
        timeforstep_g(rtB.Merge_b, &rtb_Merge_m);

        /* Switch: '<S1115>/Switch' incorporates:
         *  Constant: '<S1132>/epsilon'
         *  DataStoreRead: '<S1115>/Текущее значение blower '
         *  DataStoreRead: '<S1115>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1132>/Relational Operator'
         *  RelationalOperator: '<S1136>/Relational Operator'
         *  Switch: '<S1136>/Switch'
         */
        if (rtb_Merge_e <= 0.01) {
          /* DataStoreWrite: '<S983>/Data Store Write3' incorporates:
           *  DataStoreRead: '<S1115>/значение auto (в соответствии с логикой)'
           */
          rtDW.Mode_FL = rtDW.Mode_logic_FL;
        } else {
          if (rtDW.Mode_FL <= rtDW.Mode_logic_FL) {
            /* Switch: '<S1136>/Switch' incorporates:
             *  Constant: '<S1136>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1136>/Switch' incorporates:
             *  Constant: '<S1136>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S983>/Data Store Write3' incorporates:
           *  Constant: '<S1115>/Constant'
           *  DataStoreRead: '<S1115>/Текущее значение blower '
           *  DataStoreRead: '<S1115>/текущее время в мс'
           *  Product: '<S1115>/Product1'
           *  Product: '<S1115>/change rate (step//sec)'
           *  Product: '<S1115>/скорость в мс'
           *  Product: '<S1115>/шаг изменения'
           *  Sum: '<S1115>/Add'
           *  Sum: '<S1133>/Subtract'
           *  Switch: '<S1136>/Switch'
           *  UnitDelay: '<S1133>/Unit Delay'
           */
          rtDW.Mode_FL = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_m /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_b) * (double)i
            + (double)rtDW.Mode_FL);
        }

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

        /* MATLAB Function: '<S983>/window heating' */
        windowheating_k(rtB.Merge_b, &rtb_Merge_e);

        /* Sum: '<S1127>/Add' incorporates:
         *  DataStoreRead: '<S1112>/Текущее значение blower '
         *  DataStoreRead: '<S1112>/значение auto (в соответствии с логикой)'
         */
        rtb_out_b = (uint16_t)(rtDW.Blower_FL - rtDW.Blower_logic_FL);

        /* RelationalOperator: '<S1127>/Relational Operator' incorporates:
         *  Constant: '<S1127>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_out_b <= 0.01);

        /* MATLAB Function: '<S1112>/blower step' */
        blowerstep(rtB.Merge_b, &rtb_out_khw);

        /* MATLAB Function: '<S1112>/blower time for step' */
        blowertimeforstep(rtB.Merge_b, &rtb_out_b);

        /* Switch: '<S1112>/Switch' incorporates:
         *  DataStoreRead: '<S1112>/Текущее значение blower '
         *  DataStoreRead: '<S1112>/значение auto (в соответствии с логикой)'
         *  RelationalOperator: '<S1131>/Relational Operator'
         *  Switch: '<S1131>/Switch'
         */
        if (rtb_LogicalOperator1) {
          /* DataStoreWrite: '<S983>/Data Store Write6' incorporates:
           *  DataStoreRead: '<S1112>/значение auto (в соответствии с логикой)'
           */
          rtDW.Blower_FL = rtDW.Blower_logic_FL;
        } else {
          if (rtDW.Blower_FL <= rtDW.Blower_logic_FL) {
            /* Switch: '<S1131>/Switch' incorporates:
             *  Constant: '<S1131>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1131>/Switch' incorporates:
             *  Constant: '<S1131>/Constant1'
             */
            i = -1;
          }

          /* DataStoreWrite: '<S983>/Data Store Write6' incorporates:
           *  Constant: '<S1112>/Constant'
           *  DataStoreRead: '<S1112>/Текущее значение blower '
           *  DataStoreRead: '<S1112>/текущее время в мс'
           *  Product: '<S1112>/Product1'
           *  Product: '<S1112>/change rate (step//sec)'
           *  Product: '<S1112>/скорость в мс'
           *  Product: '<S1112>/шаг изменения'
           *  Sum: '<S1112>/Add'
           *  Sum: '<S1128>/Subtract'
           *  Switch: '<S1131>/Switch'
           *  UnitDelay: '<S1128>/Unit Delay'
           */
          rtDW.Blower_FL = (uint16_t)((double)rtb_out_khw / (double)rtb_out_b /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_e) * (double)i
            + (double)rtDW.Blower_FL);
        }

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

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

        /* RelationalOperator: '<S983>/Equal' incorporates:
         *  DataStoreRead: '<S983>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_front == 2);

        /* MATLAB Function: '<S983>/Time goto from step 2 to step 3 ' */
        Timegotofromstep2tostep3(rtB.Merge_b, &rtb_LVL);

        /* RelationalOperator: '<S983>/Relational Operator1' incorporates:
         *  DataStoreRead: '<S1109>/Data Store Read4'
         *  Gain: '<S983>/из сек в мс'
         *  Sum: '<S1109>/Subtract'
         *  UnitDelay: '<S1109>/t_start_delay_private '
         */
        rtb_LogicalOperator1_dv = (rtDW.t_now -
          rtDW.t_start_delay_private_DSTATE_n > (uint32_t)(1000 * rtb_LVL));

        /* Switch: '<S1109>/Switch' incorporates:
         *  DataStoreRead: '<S1109>/Data Store Read4'
         *  Logic: '<S1109>/Logical Operator3'
         *  Logic: '<S1109>/Logical Operator4'
         *  UnitDelay: '<S1109>/Cond_prev_private '
         *  UnitDelay: '<S1109>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_iy)) {
          rtDW.t_start_delay_private_DSTATE_n = rtDW.t_now;
        }

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

        /* Switch: '<S983>/Switch' incorporates:
         *  DataStoreRead: '<S983>/Data Store Read'
         *  Logic: '<S983>/Logical Operator'
         */
        if (rtb_LogicalOperator1_dv || rtDW.HI_logic_on) {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S983>/go to next step'
           */
          rtB.Merge_h = 3;
        } else {
          /* Merge: '<S875>/Merge' incorporates:
           *  Constant: '<S983>/stay at step'
           */
          rtB.Merge_h = 2;
        }

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

        /* Update for UnitDelay: '<S1118>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1107>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_f = rtDW.t_now;

        /* Update for UnitDelay: '<S1123>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1108>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_pu = rtDW.t_now;

        /* Update for UnitDelay: '<S1133>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1115>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_b = rtDW.t_now;

        /* Update for UnitDelay: '<S1128>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1112>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_e = rtDW.t_now;

        /* Update for UnitDelay: '<S1109>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_iy = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S880>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S880>/Switch Case' */
      /* End of Outputs for SubSystem: '<S875>/Step 2 F' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S875>/Step 3 F' incorporates:
       *  ActionPort: '<S881>/Action Port'
       */
      Step3F(&rtB.Merge_h, &rtDW.start_control_finished_front);

      /* End of Outputs for SubSystem: '<S875>/Step 3 F' */
      break;
    }

    /* End of SwitchCase: '<S875>/Switch Case' */

    /* DataStoreWrite: '<S875>/Data Store Write' */
    rtDW.step_start_controle_front = rtB.Merge_h;

    /* End of Outputs for SubSystem: '<S9>/Start Control Front' */
  }

  /* End of If: '<S9>/если SC front не завершен' */

  /* If: '<S9>/если SC rear не завершен1' incorporates:
   *  DataStoreRead: '<S9>/Data Store Read3'
   */
  if (rtDW.start_control_finished_rear == 0.0) {
    /* Outputs for IfAction SubSystem: '<S9>/Start Control Rear' incorporates:
     *  ActionPort: '<S876>/Action Port'
     */
    /* SwitchCase: '<S876>/Switch Case' incorporates:
     *  DataStoreRead: '<S876>/Data Store Read'
     */
    switch (rtDW.step_start_controle_rear) {
     case -1:
      /* Outputs for IfAction SubSystem: '<S876>/Step -1 R (Entry Condition)' incorporates:
       *  ActionPort: '<S1137>/Action Port'
       */
      /* SwitchCase: '<S1137>/Switch Case' incorporates:
       *  DataStoreRead: '<S1137>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S1137>/Level 0' incorporates:
         *  ActionPort: '<S1142>/Action Port'
         */
        /* MATLAB Function: '<S1142>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S1142>/Data Store Read4'
         */
        /* :  out = int16(g_assSTART_ENTER_INCAR(LVL + 1 + 6)); */
        g_ausSTART_ENTER_SETTEMP_b(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S1142>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S1142>/Data Store Read3'
         */
        i = (int32_t)(rtB.Merge_b + 1U);
        if (rtB.Merge_b + 1U > 255U) {
          i = 255;
        }

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

        /* Switch: '<S1142>/Switch' incorporates:
         *  Constant: '<S1142>/AUTO'
         *  DataStoreRead: '<S1142>/Data Store Read'
         *  DataStoreRead: '<S1142>/Data Store Read1'
         *  DataStoreRead: '<S1142>/Data Store Read2'
         *  Logic: '<S1142>/AND'
         *  MATLAB Function: '<S1142>/g_assSTART_ENTER_INCAR'
         *  RelationalOperator: '<S1142>/Relational Operator'
         *  RelationalOperator: '<S1142>/Relational Operator1'
         *  RelationalOperator: '<S1142>/Relational Operator2'
         */
        if ((rtDW.Incar_RR > g_assSTART_ENTER_INCAR[tmp - 1]) &&
            (rtDW.MODE_RR_passenger == 1.0) && (rtDW.FIU_SET_RR < rtb_LVL)) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1142>/Constant1'
           */
          rtB.Merge_c = 0;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1142>/Constant'
           */
          rtB.Merge_c = -1;
        }

        /* End of Switch: '<S1142>/Switch' */
        /* End of Outputs for SubSystem: '<S1137>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S1137>/Level 1' incorporates:
         *  ActionPort: '<S1143>/Action Port'
         */
        /* MATLAB Function: '<S1143>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S1143>/Data Store Read3'
         */
        g_assSTART_ENTER_INCAR_p(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S1143>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S1143>/Data Store Read4'
         */
        g_ausSTART_ENTER_SETTEMP_b(rtB.Merge_b, &Duct2_F);

        /* Switch: '<S1143>/Switch' incorporates:
         *  Constant: '<S1143>/AUTO'
         *  DataStoreRead: '<S1143>/Data Store Read'
         *  DataStoreRead: '<S1143>/Data Store Read1'
         *  DataStoreRead: '<S1143>/Data Store Read2'
         *  Logic: '<S1143>/AND'
         *  RelationalOperator: '<S1143>/Relational Operator'
         *  RelationalOperator: '<S1143>/Relational Operator1'
         *  RelationalOperator: '<S1143>/Relational Operator2'
         */
        if ((rtDW.Incar_RR > rtb_LVL) && (rtDW.MODE_RR_passenger == 1.0) &&
            (rtDW.FIU_SET_RR < Duct2_F)) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1143>/Constant1'
           */
          rtB.Merge_c = 0;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1143>/Constant'
           */
          rtB.Merge_c = -1;
        }

        /* End of Switch: '<S1143>/Switch' */
        /* End of Outputs for SubSystem: '<S1137>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S1137>/Level 2' incorporates:
         *  ActionPort: '<S1144>/Action Port'
         */
        /* MATLAB Function: '<S1144>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S1144>/Data Store Read3'
         */
        g_assSTART_ENTER_INCAR_p(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S1144>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S1144>/Data Store Read4'
         */
        g_ausSTART_ENTER_SETTEMP_b(rtB.Merge_b, &Duct2_F);

        /* Switch: '<S1144>/Switch' incorporates:
         *  Constant: '<S1144>/AUTO'
         *  DataStoreRead: '<S1144>/Data Store Read'
         *  DataStoreRead: '<S1144>/Data Store Read1'
         *  DataStoreRead: '<S1144>/Data Store Read2'
         *  Logic: '<S1144>/AND'
         *  RelationalOperator: '<S1144>/Relational Operator'
         *  RelationalOperator: '<S1144>/Relational Operator1'
         *  RelationalOperator: '<S1144>/Relational Operator2'
         */
        if ((rtDW.Incar_RR < rtb_LVL) && (rtDW.MODE_RR_passenger == 1.0) &&
            (rtDW.FIU_SET_RR > Duct2_F)) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1144>/Constant1'
           */
          rtB.Merge_c = 0;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1144>/Constant'
           */
          rtB.Merge_c = -1;
        }

        /* End of Switch: '<S1144>/Switch' */
        /* End of Outputs for SubSystem: '<S1137>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S1137>/Level 3' incorporates:
         *  ActionPort: '<S1145>/Action Port'
         */
        /* MATLAB Function: '<S1145>/g_assSTART_ENTER_INCAR' incorporates:
         *  DataStoreRead: '<S1145>/Data Store Read4'
         */
        g_assSTART_ENTER_INCAR_p(rtB.Merge_b, &rtb_LVL);

        /* MATLAB Function: '<S1145>/g_assSTART_ENTER_COOLANT ' incorporates:
         *  DataStoreRead: '<S1145>/Data Store Read3'
         */
        g_assSTART_ENTER_COOLANT_e(rtB.Merge_b, &Duct2_F);

        /* MATLAB Function: '<S1145>/g_ausSTART_ENTER_SETTEMP' incorporates:
         *  DataStoreRead: '<S1145>/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 = (int32_t)((uint32_t)i + 6U);
        if ((uint32_t)i + 6U > 255U) {
          tmp = 255;
        }

        rtb_out_b = g_ausSTART_ENTER_SETTEMP[tmp - 1];
        if (rtb_out_b > 32767) {
          rtb_out_b = 32767U;
        }

        /* Switch: '<S1145>/Switch' incorporates:
         *  Constant: '<S1145>/AUTO'
         *  DataStoreRead: '<S1145>/Data Store Read'
         *  DataStoreRead: '<S1145>/Data Store Read1'
         *  DataStoreRead: '<S1145>/Data Store Read2'
         *  DataStoreRead: '<S1145>/Data Store Read5'
         *  Logic: '<S1145>/AND'
         *  Logic: '<S1145>/AND1'
         *  MATLAB Function: '<S1145>/g_ausSTART_ENTER_SETTEMP'
         *  RelationalOperator: '<S1145>/Relational Operator'
         *  RelationalOperator: '<S1145>/Relational Operator1'
         *  RelationalOperator: '<S1145>/Relational Operator2'
         *  RelationalOperator: '<S1145>/Relational Operator3'
         */
        if (((rtDW.Incar_RR < rtb_LVL) || (rtDW.ECT < Duct2_F)) &&
            (rtDW.MODE_RR_passenger == 1.0) && (rtDW.FIU_SET_RR > rtb_out_b)) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1145>/Constant1'
           */
          rtB.Merge_c = 0;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1145>/Constant'
           */
          rtB.Merge_c = -1;
        }

        /* End of Switch: '<S1145>/Switch' */
        /* End of Outputs for SubSystem: '<S1137>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S1137>/Level 4' incorporates:
         *  ActionPort: '<S1146>/Action Port'
         */
        Level4_e(&rtB.Merge_c, &rtDW.ECT, &rtDW.Incar_RR, &rtB.Merge_b,
                 &rtDW.MODE_RR_passenger);

        /* End of Outputs for SubSystem: '<S1137>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S1137>/Level 5' incorporates:
         *  ActionPort: '<S1147>/Action Port'
         */
        Level4_e(&rtB.Merge_c, &rtDW.ECT, &rtDW.Incar_RR, &rtB.Merge_b,
                 &rtDW.MODE_RR_passenger);

        /* End of Outputs for SubSystem: '<S1137>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S1137>/Switch Case' */
      /* End of Outputs for SubSystem: '<S876>/Step -1 R (Entry Condition)' */
      break;

     case 0:
      /* Outputs for IfAction SubSystem: '<S876>/Step 0 R' incorporates:
       *  ActionPort: '<S1138>/Action Port'
       */
      /* SwitchCase: '<S1138>/Switch Case' incorporates:
       *  DataStoreRead: '<S1138>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S1138>/Level 0' incorporates:
         *  ActionPort: '<S1161>/Action Port'
         */
        Level0(&rtB.Merge_c);

        /* End of Outputs for SubSystem: '<S1138>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S1138>/Level 1' incorporates:
         *  ActionPort: '<S1162>/Action Port'
         */
        Level0(&rtB.Merge_c);

        /* End of Outputs for SubSystem: '<S1138>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S1138>/Level 2' incorporates:
         *  ActionPort: '<S1163>/Action Port'
         */
        /* DataStoreWrite: '<S1163>/Data Store Write5' incorporates:
         *  Constant: '<S1163>/Constant2'
         */
        rtDW.Blower_RR = 10U;

        /* DataStoreWrite: '<S1163>/Data Store Write10' incorporates:
         *  Constant: '<S1163>/Constant4'
         */
        rtDW.Dtg_RR = 65U;

        /* MATLAB Function: '<S1163>/incar filter up' incorporates:
         *  DataStoreRead: '<S1163>/Data Store Read1'
         */
        incarfilterup_i(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1163>/incar filter down' incorporates:
         *  DataStoreRead: '<S1163>/Data Store Read2'
         */
        incarfilterdown_c(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S1163>/Data Store Write2' incorporates:
         *  Constant: '<S1163>/Mode - foot'
         */
        rtDW.Mode_RR = 60U;

        /* MATLAB Function: '<S1163>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
         *  DataStoreRead: '<S1163>/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: '<S876>/Merge' incorporates:
         *  DataStoreRead: '<S1163>/Engine coolant temp'
         *  MATLAB Function: '<S1163>/g_assSTART_COOLANT_STEP0_TO_1 '
         *  RelationalOperator: '<S1163>/Relational Operator'
         *  Switch: '<S1163>/Switch'
         */
        rtB.Merge_c = (int8_t)(rtDW.ECT > g_assSTART_COOLANT_STEP0_TO_1[i - 1]);

        /* End of Outputs for SubSystem: '<S1138>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S1138>/Level 3' incorporates:
         *  ActionPort: '<S1164>/Action Port'
         */
        /* DataStoreWrite: '<S1164>/Data Store Write5' incorporates:
         *  Constant: '<S1164>/Constant2'
         */
        rtDW.Blower_RR = 10U;

        /* DataStoreWrite: '<S1164>/Data Store Write10' incorporates:
         *  Constant: '<S1164>/Constant4'
         */
        rtDW.Dtg_RR = 65U;

        /* MATLAB Function: '<S1164>/incar filter up' incorporates:
         *  DataStoreRead: '<S1164>/Data Store Read1'
         */
        incarfilterup_i(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1164>/incar filter down' incorporates:
         *  DataStoreRead: '<S1164>/Data Store Read2'
         */
        incarfilterdown_c(rtB.Merge_b, &rtb_Merge_j);

        /* DataStoreWrite: '<S1164>/Data Store Write2' incorporates:
         *  Constant: '<S1164>/Mode - foot'
         */
        rtDW.Mode_RR = 60U;

        /* MATLAB Function: '<S1164>/g_assSTART_COOLANT_STEP0_TO_1 ' incorporates:
         *  DataStoreRead: '<S1164>/Data Store Read3'
         */
        g_assSTART_COOLANT_STEP0_TO_1_e(rtB.Merge_b, &rtb_LVL);

        /* Merge: '<S876>/Merge' incorporates:
         *  DataStoreRead: '<S1164>/Engine coolant temp'
         *  RelationalOperator: '<S1164>/Relational Operator'
         *  Switch: '<S1164>/Switch'
         */
        rtB.Merge_c = (int8_t)(rtDW.ECT > rtb_LVL);

        /* End of Outputs for SubSystem: '<S1138>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S1138>/Level 4' incorporates:
         *  ActionPort: '<S1165>/Action Port'
         */
        Level4_m(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Merge_e, &rtb_Merge_j,
                 &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Merge_a,
                 &rtb_Merge_m);

        /* End of Outputs for SubSystem: '<S1138>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S1138>/Level 5' incorporates:
         *  ActionPort: '<S1166>/Action Port'
         */
        Level4_m(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &rtb_Merge_e, &rtb_Merge_j,
                 &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_Merge_a,
                 &rtb_Merge_m);

        /* End of Outputs for SubSystem: '<S1138>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S1138>/Switch Case' */
      /* End of Outputs for SubSystem: '<S876>/Step 0 R' */
      break;

     case 1:
      /* Outputs for IfAction SubSystem: '<S876>/Step 1 R' incorporates:
       *  ActionPort: '<S1139>/Action Port'
       */
      /* SwitchCase: '<S1139>/Switch Case' incorporates:
       *  DataStoreRead: '<S1139>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S1139>/Level 0' incorporates:
         *  ActionPort: '<S1179>/Action Port'
         */
        Level0_b(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.Incar_RR, &rtb_Merge_e, &rtb_Merge_j,
                 &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_rate,
                 &rtb_Merge_a, &rtDW.step_start_controle_rear, &rtDW.t_now,
                 &rtDW.Level0_bc);

        /* End of Outputs for SubSystem: '<S1139>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S1139>/Level 1' incorporates:
         *  ActionPort: '<S1180>/Action Port'
         */
        Level0_b(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.Incar_RR, &rtb_Merge_e, &rtb_Merge_j,
                 &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR, &rtb_rate,
                 &rtb_Merge_a, &rtDW.step_start_controle_rear, &rtDW.t_now,
                 &rtDW.Level1_d3);

        /* End of Outputs for SubSystem: '<S1139>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S1139>/Level 2' incorporates:
         *  ActionPort: '<S1181>/Action Port'
         */
        /* DataStoreWrite: '<S1181>/Data Store Write2' incorporates:
         *  DataStoreRead: '<S1181>/Data Store Read1'
         *  DataStoreRead: '<S1181>/Data Store Read2'
         *  DataStoreRead: '<S1181>/Data Store Read5'
         *  DataStoreRead: '<S1181>/Data Store Read6'
         *  MATLAB Function: '<S1181>/2 way valve'
         *  MATLAB Function: '<S1181>/incar filter down'
         *  MATLAB Function: '<S1181>/incar filter up'
         *  MATLAB Function: '<S1181>/mode rear step 1'
         */
        uwayvalve(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterup_i(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterdown_c(rtB.Merge_b, &rtDW.Mode_RR);
        moderearstep1(rtB.Merge_b, &rtDW.Mode_RR);

        /* MATLAB Function: '<S1208>/blower start finish' incorporates:
         *  DataStoreRead: '<S1181>/Data Store Read7'
         */
        blowerstartfinish(rtB.Merge_b, rtb_out_f0);

        /* MATLAB Function: '<S1208>/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_md[0] = g_assSTART_COOLANT_STEP0_TO_1[4];
        rtb_out_md[1] = g_assSTART_COOLANT_TO_STEP2[1];

        /* Lookup_n-D: '<S1208>/blower для текущего ECT' incorporates:
         *  DataStoreRead: '<S1208>/engine coolant temp'
         */
        rtb_LVL = look1_is16lu64n32tu16Ds32Is16_binlcs(rtDW.ECT, rtb_out_md,
          rtb_out_f0, 1U);

        /* DataTypeConversion: '<S1208>/Data Type Conversion1' incorporates:
         *  DataStoreWrite: '<S1181>/Data Store Write5'
         */
        rtDW.Blower_RR = (uint16_t)rtb_LVL;

        /* DataStoreWrite: '<S1181>/Data Store Write10' incorporates:
         *  DataStoreRead: '<S1181>/Data Store Read8'
         *  MATLAB Function: '<S1181>/Dtg_rear'
         */
        Dtg_rear(rtB.Merge_b, &rtDW.Dtg_RR);

        /* RelationalOperator: '<S1181>/Equal' incorporates:
         *  DataStoreRead: '<S1181>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 1);

        /* MATLAB Function: '<S1181>/Incar temp goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1181>/Data Store Read3'
         */
        Incartempgotofromstep1tostep2_j(rtB.Merge_b, &Duct2_F);

        /* Sum: '<S1206>/Subtract' incorporates:
         *  DataStoreRead: '<S1206>/Data Store Read4'
         *  UnitDelay: '<S1206>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_em;

        /* MATLAB Function: '<S1181>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1181>/Data Store Read4'
         */
        Timegotofromstep1tostep2_l(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S1206>/Switch' incorporates:
         *  DataStoreRead: '<S1206>/Data Store Read4'
         *  Logic: '<S1206>/Logical Operator3'
         *  Logic: '<S1206>/Logical Operator4'
         *  UnitDelay: '<S1206>/Cond_prev_private '
         *  UnitDelay: '<S1206>/t_start_delay_private '
         */
        /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(2)); */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_cp)) {
          rtDW.t_start_delay_private_DSTATE_em = rtDW.t_now;
        }

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

        /* Switch: '<S1181>/Switch' incorporates:
         *  DataStoreRead: '<S1181>/engine coolant temp'
         *  DataStoreRead: '<S1181>/incar temp'
         *  Gain: '<S1181>/из сек в мс'
         *  Logic: '<S1181>/Logical Operator'
         *  MATLAB Function: '<S1181>/g_assSTART_COOLANT_TO_STEP2 '
         *  RelationalOperator: '<S1181>/Relational Operator'
         *  RelationalOperator: '<S1181>/Relational Operator1'
         *  RelationalOperator: '<S1181>/Relational Operator2'
         */
        if ((rtDW.Incar_RR > Duct2_F) || (rtb_Subtract > (uint16_t)(1000 *
              rtb_LVL)) || (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[1])) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1181>/go to next step'
           */
          rtB.Merge_c = 2;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1181>/stay at step 1'
           */
          rtB.Merge_c = 1;
        }

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

        /* Update for UnitDelay: '<S1206>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_cp = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S1139>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S1139>/Level 3' incorporates:
         *  ActionPort: '<S1182>/Action Port'
         */
        /* DataStoreWrite: '<S1182>/Data Store Write2' incorporates:
         *  DataStoreRead: '<S1182>/Data Store Read1'
         *  DataStoreRead: '<S1182>/Data Store Read2'
         *  DataStoreRead: '<S1182>/Data Store Read5'
         *  DataStoreRead: '<S1182>/Data Store Read6'
         *  MATLAB Function: '<S1182>/2 way valve'
         *  MATLAB Function: '<S1182>/incar filter down'
         *  MATLAB Function: '<S1182>/incar filter up'
         *  MATLAB Function: '<S1182>/mode rear step 1'
         */
        uwayvalve(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterup_i(rtB.Merge_b, &rtDW.Mode_RR);
        incarfilterdown_c(rtB.Merge_b, &rtDW.Mode_RR);
        moderearstep1(rtB.Merge_b, &rtDW.Mode_RR);

        /* MATLAB Function: '<S1220>/blower start finish' incorporates:
         *  DataStoreRead: '<S1182>/Data Store Read7'
         */
        blowerstartfinish(rtB.Merge_b, rtb_out_f0);

        /* MATLAB Function: '<S1220>/ECT min max' incorporates:
         *  DataStoreRead: '<S1182>/Data Store Read7'
         */
        ECTminmax_l(rtB.Merge_b, rtb_out_md);

        /* Lookup_n-D: '<S1220>/blower для текущего ECT' incorporates:
         *  DataStoreRead: '<S1220>/engine coolant temp'
         */
        rtb_LVL = look1_is16lu64n32tu16Ds32Is16_binlcs(rtDW.ECT, rtb_out_md,
          rtb_out_f0, 1U);

        /* DataTypeConversion: '<S1220>/Data Type Conversion1' incorporates:
         *  DataStoreWrite: '<S1182>/Data Store Write5'
         */
        rtDW.Blower_RR = (uint16_t)rtb_LVL;

        /* DataStoreWrite: '<S1182>/Data Store Write10' incorporates:
         *  DataStoreRead: '<S1182>/Data Store Read8'
         *  MATLAB Function: '<S1182>/Dtg_rear'
         */
        Dtg_rear(rtB.Merge_b, &rtDW.Dtg_RR);

        /* RelationalOperator: '<S1182>/Equal' incorporates:
         *  DataStoreRead: '<S1182>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 1);

        /* MATLAB Function: '<S1182>/Incar temp goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1182>/Data Store Read3'
         */
        Incartempgotofromstep1tostep2_j(rtB.Merge_b, &Duct2_F);

        /* Sum: '<S1218>/Subtract' incorporates:
         *  DataStoreRead: '<S1218>/Data Store Read4'
         *  UnitDelay: '<S1218>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_oc;

        /* MATLAB Function: '<S1182>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1182>/Data Store Read4'
         */
        Timegotofromstep1tostep2_l(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S1218>/Switch' incorporates:
         *  DataStoreRead: '<S1218>/Data Store Read4'
         *  Logic: '<S1218>/Logical Operator3'
         *  Logic: '<S1218>/Logical Operator4'
         *  UnitDelay: '<S1218>/Cond_prev_private '
         *  UnitDelay: '<S1218>/t_start_delay_private '
         */
        /* :  out = int16(g_assSTART_COOLANT_TO_STEP2(3)); */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_aw)) {
          rtDW.t_start_delay_private_DSTATE_oc = rtDW.t_now;
        }

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

        /* Switch: '<S1182>/Switch' incorporates:
         *  DataStoreRead: '<S1182>/engine coolant temp'
         *  DataStoreRead: '<S1182>/incar temp'
         *  Gain: '<S1182>/из сек в мс'
         *  Logic: '<S1182>/Logical Operator'
         *  MATLAB Function: '<S1182>/g_assSTART_COOLANT_TO_STEP2 '
         *  RelationalOperator: '<S1182>/Relational Operator'
         *  RelationalOperator: '<S1182>/Relational Operator1'
         *  RelationalOperator: '<S1182>/Relational Operator2'
         */
        if ((rtDW.Incar_RR > Duct2_F) || (rtb_Subtract > (uint16_t)(1000 *
              rtb_LVL)) || (rtDW.ECT > g_assSTART_COOLANT_TO_STEP2[2])) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1182>/go to next step'
           */
          rtB.Merge_c = 2;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1182>/stay at step 1'
           */
          rtB.Merge_c = 1;
        }

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

        /* Update for UnitDelay: '<S1218>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_aw = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S1139>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S1139>/Level 4' incorporates:
         *  ActionPort: '<S1183>/Action Port'
         */
        Level4_d(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &rtDW.Incar_RR, &rtb_Merge_e,
                 &rtb_Merge_j, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                 &rtb_rate, &rtb_Merge_a, &rtDW.step_start_controle_rear,
                 &rtDW.t_now, &rtDW.Level4_dp);

        /* End of Outputs for SubSystem: '<S1139>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S1139>/Level 5' incorporates:
         *  ActionPort: '<S1184>/Action Port'
         */
        Level4_d(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR, &Dtg_FUR,
                 &rtDW.Dtg_RR, &rtDW.ECT, &rtDW.Incar_RR, &rtb_Merge_e,
                 &rtb_Merge_j, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                 &rtb_rate, &rtb_Merge_a, &rtDW.step_start_controle_rear,
                 &rtDW.t_now, &rtDW.Level5_f);

        /* End of Outputs for SubSystem: '<S1139>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S1139>/Switch Case' */
      /* End of Outputs for SubSystem: '<S876>/Step 1 R' */
      break;

     case 2:
      /* Outputs for IfAction SubSystem: '<S876>/Step 2 R' incorporates:
       *  ActionPort: '<S1140>/Action Port'
       */
      /* SwitchCase: '<S1140>/Switch Case' incorporates:
       *  DataStoreRead: '<S1140>/Data Store Read1'
       */
      switch (rtB.Merge_b) {
       case 0:
        /* Outputs for IfAction SubSystem: '<S1140>/Level 0' incorporates:
         *  ActionPort: '<S1249>/Action Port'
         */
        /* MATLAB Function: '<S1249>/2 way valve' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read6'
         */
        uwayvalve(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1256>/step' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read8'
         */
        Dtg_rear(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1256>/time for step' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read8'
         */
        timeforstep_jn(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1256>/Switch' incorporates:
         *  Constant: '<S1256>/Constant'
         *  Constant: '<S1263>/epsilon'
         *  DataStoreRead: '<S1256>/Текущее значение blower '
         *  DataStoreRead: '<S1256>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1256>/текущее время в мс'
         *  DataStoreWrite: '<S1249>/Data Store Write10'
         *  Product: '<S1256>/Product1'
         *  Product: '<S1256>/change rate (dtg//sec)'
         *  Product: '<S1256>/скорость в мс'
         *  Product: '<S1256>/шаг изменения'
         *  RelationalOperator: '<S1263>/Relational Operator'
         *  RelationalOperator: '<S1267>/Relational Operator'
         *  Sum: '<S1256>/Add'
         *  Sum: '<S1263>/Add'
         *  Sum: '<S1264>/Subtract'
         *  Switch: '<S1267>/Switch'
         *  UnitDelay: '<S1264>/Unit Delay'
         */
        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
        } else {
          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
            /* Switch: '<S1267>/Switch' incorporates:
             *  Constant: '<S1267>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1267>/Switch' incorporates:
             *  Constant: '<S1267>/Constant1'
             */
            i = -1;
          }

          rtDW.Dtg_RR = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_d) * (double)i
            + (double)rtDW.Dtg_RR);
        }

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

        /* MATLAB Function: '<S1249>/incar filter up' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read1'
         */
        incarfilterup_i(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1249>/incar filter down' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read2'
         */
        incarfilterdown_c(rtB.Merge_b, &rtb_Merge_j);

        /* Sum: '<S1273>/Add' incorporates:
         *  DataStoreRead: '<S1262>/Текущее значение blower '
         *  DataStoreRead: '<S1262>/значение auto (в соответствии с логикой)'
         */
        rtb_Merge_e = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);

        /* RelationalOperator: '<S1273>/Relational Operator' incorporates:
         *  Constant: '<S1273>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_Merge_e <= 0.01);

        /* MATLAB Function: '<S1262>/step' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read5'
         */
        step_a(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1262>/time for step' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read5'
         */
        timeforstep_h(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1262>/Switch' incorporates:
         *  Constant: '<S1262>/Constant'
         *  DataStoreRead: '<S1262>/Текущее значение blower '
         *  DataStoreRead: '<S1262>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1262>/текущее время в мс'
         *  DataStoreWrite: '<S1249>/Data Store Write2'
         *  Product: '<S1262>/Product1'
         *  Product: '<S1262>/change rate (step//sec)'
         *  Product: '<S1262>/скорость в мс'
         *  Product: '<S1262>/шаг изменения'
         *  RelationalOperator: '<S1277>/Relational Operator'
         *  Sum: '<S1262>/Add'
         *  Sum: '<S1274>/Subtract'
         *  Switch: '<S1277>/Switch'
         *  UnitDelay: '<S1274>/Unit Delay'
         */
        if (rtb_LogicalOperator1) {
          rtDW.Mode_RR = rtDW.Mode_logic_RR;
        } else {
          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
            /* Switch: '<S1277>/Switch' incorporates:
             *  Constant: '<S1277>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1277>/Switch' incorporates:
             *  Constant: '<S1277>/Constant1'
             */
            i = -1;
          }

          rtDW.Mode_RR = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_nc) * (double)i
            + (double)rtDW.Mode_RR);
        }

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

        /* MATLAB Function: '<S1259>/blower step' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read7'
         */
        blowerstep_d(rtB.Merge_b, &rtb_out_b);

        /* MATLAB Function: '<S1259>/blower time for step' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read7'
         */
        blowertimeforstep_l(rtB.Merge_b, &rtb_out_khw);

        /* Switch: '<S1259>/Switch' incorporates:
         *  Constant: '<S1259>/Constant'
         *  Constant: '<S1268>/epsilon'
         *  DataStoreRead: '<S1259>/Текущее значение blower '
         *  DataStoreRead: '<S1259>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1259>/текущее время в мс'
         *  DataStoreWrite: '<S1249>/Data Store Write5'
         *  Product: '<S1259>/Product1'
         *  Product: '<S1259>/change rate (step//sec)'
         *  Product: '<S1259>/скорость в мс'
         *  Product: '<S1259>/шаг изменения'
         *  RelationalOperator: '<S1268>/Relational Operator'
         *  RelationalOperator: '<S1272>/Relational Operator'
         *  Sum: '<S1259>/Add'
         *  Sum: '<S1268>/Add'
         *  Sum: '<S1269>/Subtract'
         *  Switch: '<S1272>/Switch'
         *  UnitDelay: '<S1269>/Unit Delay'
         */
        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
          rtDW.Blower_RR = rtDW.Blower_logic_RR;
        } else {
          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
            /* Switch: '<S1272>/Switch' incorporates:
             *  Constant: '<S1272>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1272>/Switch' incorporates:
             *  Constant: '<S1272>/Constant1'
             */
            i = -1;
          }

          rtDW.Blower_RR = (uint16_t)((double)rtb_out_b / (double)rtb_out_khw /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_hs) * (double)i
            + (double)rtDW.Blower_RR);
        }

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

        /* RelationalOperator: '<S1249>/Equal' incorporates:
         *  DataStoreRead: '<S1249>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);

        /* Sum: '<S1257>/Subtract' incorporates:
         *  DataStoreRead: '<S1257>/Data Store Read4'
         *  UnitDelay: '<S1257>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_f;

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

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

        /* MATLAB Function: '<S1249>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1249>/Data Store Read4'
         */
        Timegotofromstep1tostep2_l(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S1249>/Switch' incorporates:
         *  Gain: '<S1249>/из сек в мс'
         *  RelationalOperator: '<S1249>/Relational Operator1'
         */
        if (rtb_Subtract > (uint16_t)(1000 * rtb_LVL)) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1249>/go to next step'
           */
          rtB.Merge_c = 3;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1249>/stay at step'
           */
          rtB.Merge_c = 2;
        }

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

        /* Update for UnitDelay: '<S1264>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1256>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_d = rtDW.t_now;

        /* Update for UnitDelay: '<S1274>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1262>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_nc = rtDW.t_now;

        /* Update for UnitDelay: '<S1269>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1259>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_hs = rtDW.t_now;

        /* Update for UnitDelay: '<S1257>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_i = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S1140>/Level 0' */
        break;

       case 1:
        /* Outputs for IfAction SubSystem: '<S1140>/Level 1' incorporates:
         *  ActionPort: '<S1250>/Action Port'
         */
        /* MATLAB Function: '<S1250>/2 way valve' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read6'
         */
        uwayvalve(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1279>/step' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read8'
         */
        Dtg_rear(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1279>/time for step' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read8'
         */
        timeforstep_jn(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1279>/Switch' incorporates:
         *  Constant: '<S1279>/Constant'
         *  Constant: '<S1286>/epsilon'
         *  DataStoreRead: '<S1279>/Текущее значение blower '
         *  DataStoreRead: '<S1279>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1279>/текущее время в мс'
         *  DataStoreWrite: '<S1250>/Data Store Write10'
         *  Product: '<S1279>/Product1'
         *  Product: '<S1279>/change rate (dtg//sec)'
         *  Product: '<S1279>/скорость в мс'
         *  Product: '<S1279>/шаг изменения'
         *  RelationalOperator: '<S1286>/Relational Operator'
         *  RelationalOperator: '<S1290>/Relational Operator'
         *  Sum: '<S1279>/Add'
         *  Sum: '<S1286>/Add'
         *  Sum: '<S1287>/Subtract'
         *  Switch: '<S1290>/Switch'
         *  UnitDelay: '<S1287>/Unit Delay'
         */
        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
        } else {
          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
            /* Switch: '<S1290>/Switch' incorporates:
             *  Constant: '<S1290>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1290>/Switch' incorporates:
             *  Constant: '<S1290>/Constant1'
             */
            i = -1;
          }

          rtDW.Dtg_RR = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_g) * (double)i
            + (double)rtDW.Dtg_RR);
        }

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

        /* MATLAB Function: '<S1250>/incar filter up' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read1'
         */
        incarfilterup_i(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1250>/incar filter down' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read2'
         */
        incarfilterdown_c(rtB.Merge_b, &rtb_Merge_j);

        /* Sum: '<S1296>/Add' incorporates:
         *  DataStoreRead: '<S1285>/Текущее значение blower '
         *  DataStoreRead: '<S1285>/значение auto (в соответствии с логикой)'
         */
        rtb_Merge_e = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);

        /* RelationalOperator: '<S1296>/Relational Operator' incorporates:
         *  Constant: '<S1296>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_Merge_e <= 0.01);

        /* MATLAB Function: '<S1285>/step' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read5'
         */
        step_a(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1285>/time for step' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read5'
         */
        timeforstep_h(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1285>/Switch' incorporates:
         *  Constant: '<S1285>/Constant'
         *  DataStoreRead: '<S1285>/Текущее значение blower '
         *  DataStoreRead: '<S1285>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1285>/текущее время в мс'
         *  DataStoreWrite: '<S1250>/Data Store Write2'
         *  Product: '<S1285>/Product1'
         *  Product: '<S1285>/change rate (step//sec)'
         *  Product: '<S1285>/скорость в мс'
         *  Product: '<S1285>/шаг изменения'
         *  RelationalOperator: '<S1300>/Relational Operator'
         *  Sum: '<S1285>/Add'
         *  Sum: '<S1297>/Subtract'
         *  Switch: '<S1300>/Switch'
         *  UnitDelay: '<S1297>/Unit Delay'
         */
        if (rtb_LogicalOperator1) {
          rtDW.Mode_RR = rtDW.Mode_logic_RR;
        } else {
          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
            /* Switch: '<S1300>/Switch' incorporates:
             *  Constant: '<S1300>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1300>/Switch' incorporates:
             *  Constant: '<S1300>/Constant1'
             */
            i = -1;
          }

          rtDW.Mode_RR = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_p) * (double)i
            + (double)rtDW.Mode_RR);
        }

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

        /* MATLAB Function: '<S1282>/blower step' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read7'
         */
        blowerstep_d(rtB.Merge_b, &rtb_out_b);

        /* MATLAB Function: '<S1282>/blower time for step' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read7'
         */
        blowertimeforstep_l(rtB.Merge_b, &rtb_out_khw);

        /* Switch: '<S1282>/Switch' incorporates:
         *  Constant: '<S1282>/Constant'
         *  Constant: '<S1291>/epsilon'
         *  DataStoreRead: '<S1282>/Текущее значение blower '
         *  DataStoreRead: '<S1282>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1282>/текущее время в мс'
         *  DataStoreWrite: '<S1250>/Data Store Write5'
         *  Product: '<S1282>/Product1'
         *  Product: '<S1282>/change rate (step//sec)'
         *  Product: '<S1282>/скорость в мс'
         *  Product: '<S1282>/шаг изменения'
         *  RelationalOperator: '<S1291>/Relational Operator'
         *  RelationalOperator: '<S1295>/Relational Operator'
         *  Sum: '<S1282>/Add'
         *  Sum: '<S1291>/Add'
         *  Sum: '<S1292>/Subtract'
         *  Switch: '<S1295>/Switch'
         *  UnitDelay: '<S1292>/Unit Delay'
         */
        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
          rtDW.Blower_RR = rtDW.Blower_logic_RR;
        } else {
          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
            /* Switch: '<S1295>/Switch' incorporates:
             *  Constant: '<S1295>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1295>/Switch' incorporates:
             *  Constant: '<S1295>/Constant1'
             */
            i = -1;
          }

          rtDW.Blower_RR = (uint16_t)((double)rtb_out_b / (double)rtb_out_khw /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_j) * (double)i
            + (double)rtDW.Blower_RR);
        }

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

        /* RelationalOperator: '<S1250>/Equal' incorporates:
         *  DataStoreRead: '<S1250>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);

        /* Sum: '<S1280>/Subtract' incorporates:
         *  DataStoreRead: '<S1280>/Data Store Read4'
         *  UnitDelay: '<S1280>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_jh;

        /* Switch: '<S1280>/Switch' incorporates:
         *  DataStoreRead: '<S1280>/Data Store Read4'
         *  Logic: '<S1280>/Logical Operator3'
         *  Logic: '<S1280>/Logical Operator4'
         *  UnitDelay: '<S1280>/Cond_prev_private '
         *  UnitDelay: '<S1280>/t_start_delay_private '
         */
        if (rtb_LogicalOperator1 && (!rtDW.Cond_prev_private_DSTATE_jk)) {
          rtDW.t_start_delay_private_DSTATE_jh = rtDW.t_now;
        }

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

        /* MATLAB Function: '<S1250>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1250>/Data Store Read4'
         */
        Timegotofromstep1tostep2_l(rtB.Merge_b, &rtb_LVL);

        /* Switch: '<S1250>/Switch' incorporates:
         *  Gain: '<S1250>/из сек в мс'
         *  RelationalOperator: '<S1250>/Relational Operator1'
         */
        if (rtb_Subtract > (uint16_t)(1000 * rtb_LVL)) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1250>/go to next step'
           */
          rtB.Merge_c = 3;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1250>/stay at step'
           */
          rtB.Merge_c = 2;
        }

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

        /* Update for UnitDelay: '<S1287>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1279>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_g = rtDW.t_now;

        /* Update for UnitDelay: '<S1297>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1285>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_p = rtDW.t_now;

        /* Update for UnitDelay: '<S1292>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1282>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_j = rtDW.t_now;

        /* Update for UnitDelay: '<S1280>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_jk = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S1140>/Level 1' */
        break;

       case 2:
        /* Outputs for IfAction SubSystem: '<S1140>/Level 2' incorporates:
         *  ActionPort: '<S1251>/Action Port'
         */
        /* MATLAB Function: '<S1251>/2 way valve' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read6'
         */
        uwayvalve(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1302>/step' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read8'
         */
        Dtg_rear(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1302>/time for step' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read8'
         */
        timeforstep_jn(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1302>/Switch' incorporates:
         *  Constant: '<S1302>/Constant'
         *  Constant: '<S1309>/epsilon'
         *  DataStoreRead: '<S1302>/Текущее значение blower '
         *  DataStoreRead: '<S1302>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1302>/текущее время в мс'
         *  DataStoreWrite: '<S1251>/Data Store Write10'
         *  Product: '<S1302>/Product1'
         *  Product: '<S1302>/change rate (dtg//sec)'
         *  Product: '<S1302>/скорость в мс'
         *  Product: '<S1302>/шаг изменения'
         *  RelationalOperator: '<S1309>/Relational Operator'
         *  RelationalOperator: '<S1313>/Relational Operator'
         *  Sum: '<S1302>/Add'
         *  Sum: '<S1309>/Add'
         *  Sum: '<S1310>/Subtract'
         *  Switch: '<S1313>/Switch'
         *  UnitDelay: '<S1310>/Unit Delay'
         */
        if ((uint8_t)(rtDW.Dtg_RR - rtDW.Dtg_logic_RR) <= 0.01) {
          rtDW.Dtg_RR = rtDW.Dtg_logic_RR;
        } else {
          if (rtDW.Dtg_RR <= rtDW.Dtg_logic_RR) {
            /* Switch: '<S1313>/Switch' incorporates:
             *  Constant: '<S1313>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1313>/Switch' incorporates:
             *  Constant: '<S1313>/Constant1'
             */
            i = -1;
          }

          rtDW.Dtg_RR = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE) * (double)i +
            (double)rtDW.Dtg_RR);
        }

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

        /* MATLAB Function: '<S1251>/incar filter up' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read1'
         */
        incarfilterup_i(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1251>/incar filter down' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read2'
         */
        incarfilterdown_c(rtB.Merge_b, &rtb_Merge_j);

        /* Sum: '<S1319>/Add' incorporates:
         *  DataStoreRead: '<S1308>/Текущее значение blower '
         *  DataStoreRead: '<S1308>/значение auto (в соответствии с логикой)'
         */
        rtb_Merge_e = (uint8_t)(rtDW.Mode_RR - rtDW.Mode_logic_RR);

        /* RelationalOperator: '<S1319>/Relational Operator' incorporates:
         *  Constant: '<S1319>/epsilon'
         */
        rtb_LogicalOperator1 = (rtb_Merge_e <= 0.01);

        /* MATLAB Function: '<S1308>/step' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read5'
         */
        step_a(rtB.Merge_b, &rtb_Merge_j);

        /* MATLAB Function: '<S1308>/time for step' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read5'
         */
        timeforstep_h(rtB.Merge_b, &rtb_Merge_e);

        /* Switch: '<S1308>/Switch' incorporates:
         *  Constant: '<S1308>/Constant'
         *  DataStoreRead: '<S1308>/Текущее значение blower '
         *  DataStoreRead: '<S1308>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1308>/текущее время в мс'
         *  DataStoreWrite: '<S1251>/Data Store Write2'
         *  Product: '<S1308>/Product1'
         *  Product: '<S1308>/change rate (step//sec)'
         *  Product: '<S1308>/скорость в мс'
         *  Product: '<S1308>/шаг изменения'
         *  RelationalOperator: '<S1323>/Relational Operator'
         *  Sum: '<S1308>/Add'
         *  Sum: '<S1320>/Subtract'
         *  Switch: '<S1323>/Switch'
         *  UnitDelay: '<S1320>/Unit Delay'
         */
        if (rtb_LogicalOperator1) {
          rtDW.Mode_RR = rtDW.Mode_logic_RR;
        } else {
          if (rtDW.Mode_RR <= rtDW.Mode_logic_RR) {
            /* Switch: '<S1323>/Switch' incorporates:
             *  Constant: '<S1323>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1323>/Switch' incorporates:
             *  Constant: '<S1323>/Constant1'
             */
            i = -1;
          }

          rtDW.Mode_RR = (uint8_t)((double)rtb_Merge_j / (double)rtb_Merge_e /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_h) * (double)i
            + (double)rtDW.Mode_RR);
        }

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

        /* MATLAB Function: '<S1305>/blower step' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read7'
         */
        blowerstep_d(rtB.Merge_b, &rtb_out_b);

        /* MATLAB Function: '<S1305>/blower time for step' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read7'
         */
        blowertimeforstep_l(rtB.Merge_b, &rtb_out_khw);

        /* Switch: '<S1305>/Switch' incorporates:
         *  Constant: '<S1305>/Constant'
         *  Constant: '<S1314>/epsilon'
         *  DataStoreRead: '<S1305>/Текущее значение blower '
         *  DataStoreRead: '<S1305>/значение auto (в соответствии с логикой)'
         *  DataStoreRead: '<S1305>/текущее время в мс'
         *  DataStoreWrite: '<S1251>/Data Store Write5'
         *  Product: '<S1305>/Product1'
         *  Product: '<S1305>/change rate (step//sec)'
         *  Product: '<S1305>/скорость в мс'
         *  Product: '<S1305>/шаг изменения'
         *  RelationalOperator: '<S1314>/Relational Operator'
         *  RelationalOperator: '<S1318>/Relational Operator'
         *  Sum: '<S1305>/Add'
         *  Sum: '<S1314>/Add'
         *  Sum: '<S1315>/Subtract'
         *  Switch: '<S1318>/Switch'
         *  UnitDelay: '<S1315>/Unit Delay'
         */
        if ((uint16_t)(rtDW.Blower_RR - rtDW.Blower_logic_RR) <= 0.01) {
          rtDW.Blower_RR = rtDW.Blower_logic_RR;
        } else {
          if (rtDW.Blower_RR <= rtDW.Blower_logic_RR) {
            /* Switch: '<S1318>/Switch' incorporates:
             *  Constant: '<S1318>/Constant'
             */
            i = 1;
          } else {
            /* Switch: '<S1318>/Switch' incorporates:
             *  Constant: '<S1318>/Constant1'
             */
            i = -1;
          }

          rtDW.Blower_RR = (uint16_t)((double)rtb_out_b / (double)rtb_out_khw /
            1000.0 * (double)(rtDW.t_now - rtDW.UnitDelay_DSTATE_n) * (double)i
            + (double)rtDW.Blower_RR);
        }

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

        /* RelationalOperator: '<S1251>/Equal' incorporates:
         *  DataStoreRead: '<S1251>/current step'
         */
        rtb_LogicalOperator1 = (rtDW.step_start_controle_rear == 2);

        /* Sum: '<S1303>/Subtract' incorporates:
         *  DataStoreRead: '<S1303>/Data Store Read4'
         *  UnitDelay: '<S1303>/t_start_delay_private '
         */
        rtb_Subtract = rtDW.t_now - rtDW.t_start_delay_private_DSTATE_e;

        /* MATLAB Function: '<S1251>/Time goto from step 1 to step 2 ' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read4'
         */
        Timegotofromstep1tostep2_l(rtB.Merge_b, &rtb_LVL);

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

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

        /* Switch: '<S1251>/Switch' incorporates:
         *  DataStoreRead: '<S1251>/Data Store Read'
         *  Gain: '<S1251>/из сек в мс'
         *  Logic: '<S1251>/Logical Operator'
         *  RelationalOperator: '<S1251>/Relational Operator1'
         */
        if ((rtb_Subtract > (uint16_t)(1000 * rtb_LVL)) || rtDW.HI_logic_on) {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1251>/go to next step'
           */
          rtB.Merge_c = 3;
        } else {
          /* Merge: '<S876>/Merge' incorporates:
           *  Constant: '<S1251>/stay at step'
           */
          rtB.Merge_c = 2;
        }

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

        /* Update for UnitDelay: '<S1310>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1302>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE = rtDW.t_now;

        /* Update for UnitDelay: '<S1320>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1308>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_h = rtDW.t_now;

        /* Update for UnitDelay: '<S1315>/Unit Delay' incorporates:
         *  DataStoreRead: '<S1305>/текущее время в мс'
         */
        rtDW.UnitDelay_DSTATE_n = rtDW.t_now;

        /* Update for UnitDelay: '<S1303>/Cond_prev_private ' */
        rtDW.Cond_prev_private_DSTATE_eia = rtb_LogicalOperator1;

        /* End of Outputs for SubSystem: '<S1140>/Level 2' */
        break;

       case 3:
        /* Outputs for IfAction SubSystem: '<S1140>/Level 3' incorporates:
         *  ActionPort: '<S1252>/Action Port'
         */
        Level3_i(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR,
                 &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Merge_e,
                 &rtb_Merge_j, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                 &rtDW.Mode_logic_RR, &rtb_rate, &rtb_Merge_a,
                 &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level3_i0);

        /* End of Outputs for SubSystem: '<S1140>/Level 3' */
        break;

       case 4:
        /* Outputs for IfAction SubSystem: '<S1140>/Level 4' incorporates:
         *  ActionPort: '<S1253>/Action Port'
         */
        Level3_i(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR,
                 &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Merge_e,
                 &rtb_Merge_j, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                 &rtDW.Mode_logic_RR, &rtb_rate, &rtb_Merge_a,
                 &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level4_j);

        /* End of Outputs for SubSystem: '<S1140>/Level 4' */
        break;

       case 5:
        /* Outputs for IfAction SubSystem: '<S1140>/Level 5' incorporates:
         *  ActionPort: '<S1254>/Action Port'
         */
        Level3_i(&rtB.Merge_c, &rtb_out_b, &rtDW.Blower_RR,
                 &rtDW.Blower_logic_RR, &Dtg_FUR, &rtDW.Dtg_RR,
                 &rtDW.Dtg_logic_RR, &rtDW.HI_logic_on, &rtb_Merge_e,
                 &rtb_Merge_j, &rtB.Merge_b, &El_window_heating, &rtDW.Mode_RR,
                 &rtDW.Mode_logic_RR, &rtb_rate, &rtb_Merge_a,
                 &rtDW.step_start_controle_rear, &rtDW.t_now, &rtDW.Level5_e);

        /* End of Outputs for SubSystem: '<S1140>/Level 5' */
        break;
      }

      /* End of SwitchCase: '<S1140>/Switch Case' */
      /* End of Outputs for SubSystem: '<S876>/Step 2 R' */
      break;

     case 3:
      /* Outputs for IfAction SubSystem: '<S876>/Step 3 R' incorporates:
       *  ActionPort: '<S1141>/Action Port'
       */
      Step3F(&rtB.Merge_c, &rtDW.start_control_finished_front);

      /* End of Outputs for SubSystem: '<S876>/Step 3 R' */
      break;
    }

    /* End of SwitchCase: '<S876>/Switch Case' */

    /* DataStoreWrite: '<S876>/Data Store Write' */
    rtDW.step_start_controle_rear = rtB.Merge_c;

    /* End of Outputs for SubSystem: '<S9>/Start Control Rear' */
  }

  /* End of If: '<S9>/если SC rear не завершен1' */

  /* Update for UnitDelay: '<S388>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE = rtb_RelationalOperator2_nm;

  /* Update for UnitDelay: '<S395>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_p = rtb_Compare;

  /* Update for UnitDelay: '<S417>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_a = rtb_Compare_mk;

  /* Update for UnitDelay: '<S439>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_h = rtb_Compare_it;

  /* Update for UnitDelay: '<S440>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_c = rtb_Compare_ho;

  /* Update for UnitDelay: '<S441>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_m = rtb_FailCond_n;

  /* Update for UnitDelay: '<S442>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_j = rtb_FailCond_b;

  /* Update for UnitDelay: '<S443>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_f = rtb_FailCond_kk;

  /* Update for UnitDelay: '<S444>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_cn = rtb_FailCond_fj;

  /* Update for UnitDelay: '<S481>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_l = rtb_Compare_ne;

  /* Update for UnitDelay: '<S482>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_ja = rtb_Compare_e;

  /* Update for UnitDelay: '<S483>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_g = rtb_Compare_gh;

  /* Update for UnitDelay: '<S484>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_cd = rtb_Compare_j4;

  /* Update for UnitDelay: '<S503>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_e = rtb_Compare_gg;

  /* Update for UnitDelay: '<S504>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_mv = rtb_Compare_m4;

  /* Update for UnitDelay: '<S517>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_jl = rtb_Compare_lus;

  /* Update for UnitDelay: '<S518>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_ei = rtb_Compare_e1;
}

/* Model initialize function */
void HVAC_model_initialize(void)
{
  /* Registration code */

  /* initialize error status */
  rtmSetErrorStatus(rtM, (NULL));

  /* block I/O */
  (void) memset(((void *) &rtB), 0,
                sizeof(B));

  /* states (dwork) */
  (void) memset((void *)&rtDW, 0,
                sizeof(DW));

  /* exported global states */
  Actuator_Ch0_Status_Model = HVAC_model_rtZActuatorCmdBusInput;
  Actuator_Ch1_Status_Model = HVAC_model_rtZActuatorCmdBusInput;
  Actuator_Ch2_Status_Model = HVAC_model_rtZActuatorCmdBusInput;
  Actuator_Ch0_Command_Model = HVAC_model_rtZActuatorCmdBus;
  Actuator_Ch1_Command_Model = HVAC_model_rtZActuatorCmdBus;
  Actuator_Ch2_Command_Model = HVAC_model_rtZActuatorCmdBus;
  Status_Sensor_Model = HVAC_model_rtZCmdBusStatus;
  CCU_Errors_Model = HVAC_model_rtZCmdBusError;
  PWM_Get = HVAC_model_rtZCmdBusPWMGet;

  {
    int32_t i;
    for (i = 0; i < 9; i++) {
      /* Start for DataStoreMemory: '<S597>/Data Store Memory1' */
      rtDW.ErrorCalibration_private[i] = 1U;

      /* Start for DataStoreMemory: '<S597>/Data Store Memory13' */
      rtDW.MaxPositionCh0_private[i] = rtConstP.DataStoreMemory13_InitialValue[i];

      /* Start for DataStoreMemory: '<S598>/Data Store Memory1' */
      rtDW.ErrorCalibration_private_p[i] = 1U;

      /* Start for DataStoreMemory: '<S598>/Data Store Memory13' */
      rtDW.MaxPositionCh1_private[i] =
        rtConstP.DataStoreMemory13_InitialValue_i[i];

      /* Start for DataStoreMemory: '<S599>/Data Store Memory1' */
      rtDW.ErrorCalibration_private_b[i] = 1U;

      /* Start for DataStoreMemory: '<S599>/Data Store Memory13' */
      rtDW.MaxPositionCh2_private[i] =
        rtConstP.DataStoreMemory13_InitialValue_l[i];
    }

    /* Start for Switch: '<S16>/Switch1' incorporates:
     *  DataStoreMemory: '<S1>/Data Store Memory'
     */
    rtDW.AMB_store = -9999.0;

    /* Start for DataStoreMemory: '<S9>/Data Store Memory' */
    rtDW.step_start_controle_front = -1;

    /* Start for DataStoreMemory: '<S9>/Data Store Memory1' */
    rtDW.step_start_controle_rear = -1;

    /* Start for DataStoreMemory: '<Root>/Data Store Memory108' */
    rtDW.FIU_MODE_RL = 1U;

    /* Start for DataStoreMemory: '<Root>/Data Store Memory114' */
    rtDW.FIU_MODE_RR = 1U;

    /* 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;

    /* Start for DataStoreMemory: '<Root>/Data Store Memory78' */
    rtDW.FIU_MODE_FL = 1U;

    /* Start for DataStoreMemory: '<Root>/Data Store Memory87' */
    rtDW.FIU_MODE_FR = 1U;

    /* InitializeConditions for UnitDelay: '<S1>/Unit Delay' */
    rtDW.UnitDelay_DSTATE_d5 = -9999;

    /* SystemInitialize for Merge: '<S109>/Merge' */
    rtB.Merge_b = 0U;

    /* SystemInitialize for MATLAB Function: '<S109>/Log Ambient Lv' */
    rtDW.current_Ambient_Lv_not_empty = false;

    /* SystemInitialize for IfAction SubSystem: '<S597>/Homing' */
    /* SystemInitialize for IfAction SubSystem: '<S604>/Switch Case Action Subsystem3' */
    /* SystemInitialize for IfAction SubSystem: '<S623>/If Action Subsystem' */
    /* Start for DataStoreMemory: '<S638>/Data Store Memory' */
    rtDW.Start_timer_n = 1.0;

    /* SystemInitialize for MATLAB Function: '<S638>/MATLAB Function' */
    MATLABFunction_Init(&rtDW.sf_MATLABFunction);

    /* End of SystemInitialize for SubSystem: '<S623>/If Action Subsystem' */
    /* End of SystemInitialize for SubSystem: '<S604>/Switch Case Action Subsystem3' */

    /* SystemInitialize for Merge: '<S604>/Merge' */
    rtB.Merge_a = 0;

    /* End of SystemInitialize for SubSystem: '<S597>/Homing' */

    /* SystemInitialize for Merge: '<S597>/Merge' */
    rtB.Merge_f1 = 0;

    /* SystemInitialize for IfAction SubSystem: '<S598>/Homing' */
    /* SystemInitialize for IfAction SubSystem: '<S674>/Switch Case Action Subsystem3' */
    /* SystemInitialize for IfAction SubSystem: '<S693>/If Action Subsystem' */
    /* Start for DataStoreMemory: '<S708>/Data Store Memory' */
    rtDW.Start_timer_j = 1.0;

    /* SystemInitialize for MATLAB Function: '<S708>/MATLAB Function' */
    MATLABFunction_Init(&rtDW.sf_MATLABFunction_h);

    /* End of SystemInitialize for SubSystem: '<S693>/If Action Subsystem' */
    /* End of SystemInitialize for SubSystem: '<S674>/Switch Case Action Subsystem3' */

    /* SystemInitialize for Merge: '<S674>/Merge' */
    rtB.Merge_p = 0;

    /* End of SystemInitialize for SubSystem: '<S598>/Homing' */

    /* SystemInitialize for Merge: '<S598>/Merge' */
    rtB.Merge_e = 0;

    /* SystemInitialize for IfAction SubSystem: '<S599>/Homing' */
    /* SystemInitialize for IfAction SubSystem: '<S745>/Switch Case Action Subsystem3' */
    /* SystemInitialize for IfAction SubSystem: '<S764>/If Action Subsystem' */
    /* Start for DataStoreMemory: '<S779>/Data Store Memory' */
    rtDW.Start_timer = 1.0;

    /* SystemInitialize for MATLAB Function: '<S779>/MATLAB Function' */
    MATLABFunction_Init(&rtDW.sf_MATLABFunction_g);

    /* End of SystemInitialize for SubSystem: '<S764>/If Action Subsystem' */
    /* End of SystemInitialize for SubSystem: '<S745>/Switch Case Action Subsystem3' */

    /* SystemInitialize for Merge: '<S745>/Merge' */
    rtB.Merge_h3 = 0;

    /* End of SystemInitialize for SubSystem: '<S599>/Homing' */

    /* SystemInitialize for Merge: '<S599>/Merge' */
    rtB.Merge_b4 = 0;

    /* SystemInitialize for IfAction SubSystem: '<S9>/Start Control Front' */
    /* SystemInitialize for Merge: '<S875>/Merge' */
    rtB.Merge_h = 0;

    /* End of SystemInitialize for SubSystem: '<S9>/Start Control Front' */

    /* SystemInitialize for IfAction SubSystem: '<S9>/Start Control Rear' */
    /* SystemInitialize for Merge: '<S876>/Merge' */
    rtB.Merge_c = 0;

    /* End of SystemInitialize for SubSystem: '<S9>/Start Control Rear' */
  }
}

/* Model terminate function */
void HVAC_model_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */