/*
 * File: HVAC_model.c
 *
 * Code generated for Simulink model 'HVAC_model'.
 *
 * Model version                  : 1.604
 * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
 * C/C++ source code generated on : Fri Feb 13 13:56:38 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 "HVAC_model_private.h"
#include "HVAC_model_types.h"
#include <string.h>
#include <stdbool.h>

/* Exported block states */
ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S73>/Data Store Memory15' */
CmdBusStatus Status_Sensor_Model;      /* '<S1>/Data Store Memory' */
CmdBusError CCU_Errors_Model;          /* '<Root>/Data Store Memory3' */

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

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

/* Real-time model */
static RT_MODEL rtM_;
RT_MODEL *const rtM = &rtM_;
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;
}

/*
 * Output and update for action system:
 *    '<S82>/If Action Subsystem3'
 *    '<S81>/If Action Subsystem3'
 *    '<S80>/If Action Subsystem3'
 *    '<S75>/If Action Subsystem3'
 *    '<S77>/If Action Subsystem3'
 *    '<S79>/If Action Subsystem3'
 *    '<S74>/If Action Subsystem3'
 */
void IfActionSubsystem3(int8_t rtu_stepIn, int8_t *rty_step)
{
  int32_t i;

  /* BusCreator: '<S130>/Bus Creator' incorporates:
   *  DataStoreWrite: '<S130>/Data Store Write'
   *  SignalConversion generated from: '<S130>/Bus Creator'
   * */
  for (i = 0; i < 9; i++) {
    Actuator_Ch0_Command_Model.POS[i] = 0U;
    Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
    Actuator_Ch0_Command_Model.MODE[i] = 0U;
    Actuator_Ch0_Command_Model.COM[i] = 0U;
    Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
    Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
    Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
    Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
    Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
  }

  /* End of BusCreator: '<S130>/Bus Creator' */

  /* SignalConversion generated from: '<S130>/stepIn' */
  *rty_step = rtu_stepIn;
}

/*
 * Output and update for atomic system:
 *    '<S75>/MAX POSITION'
 *    '<S74>/MAX POSITION'
 */
void MAXPOSITION(int16_t rty_y[9])
{
  int32_t i;

  /* :  y = step; */
  /* :  fprintf('SIMULINK POSITION '); */
  printf("SIMULINK POSITION ");
  fflush(stdout);

  /* :  for i = 1:numel(step) */
  for (i = 0; i < 9; i++) {
    /* :  fprintf('%d ', int16(step(i))); */
    printf("%d ", rty_y[i]);
    fflush(stdout);
  }

  /* :  fprintf('\n'); */
  printf("\n");
  fflush(stdout);
}

/*
 * Output and update for atomic system:
 *    '<S75>/MAX POSITION1'
 *    '<S74>/MAX POSITION1'
 */
void MAXPOSITION1(int8_t rty_y[9])
{
  int32_t i;

  /* :  y = step; */
  /* :  fprintf('SIMULINK Stall_Slave '); */
  printf("SIMULINK Stall_Slave ");
  fflush(stdout);

  /* :  for i = 1:numel(step) */
  for (i = 0; i < 9; i++) {
    /* :  fprintf('%d ', int16(step(i))); */
    printf("%d ", (int16_t)rty_y[i]);
    fflush(stdout);
  }

  /* :  fprintf('\n'); */
  printf("\n");
  fflush(stdout);
}

/*
 * Output and update for atomic system:
 *    '<S97>/MAX POSITION'
 *    '<S98>/MAX POSITION'
 */
void MAXPOSITION_l(const double rtu_step[9], double rty_y[9])
{
  int32_t i;

  /* :  y = step; */
  memcpy(&rty_y[0], &rtu_step[0], 9U * sizeof(double));

  /* :  fprintf('SIMULINK MAX POSITION '); */
  printf("SIMULINK MAX POSITION ");
  fflush(stdout);

  /* :  for i = 1:numel(step) */
  for (i = 0; i < 9; i++) {
    /* :  fprintf('%f ', step(i)); */
    printf("%f ", rtu_step[i]);
    fflush(stdout);
  }

  /* :  fprintf('\n'); */
  printf("\n");
  fflush(stdout);
}

/* Model step function */
void HVAC_model_step(void)
{
  double rtb_Divide1_j[9];
  double rtb_y_gj[9];
  double rtb_Divide1_n;
  int32_t i;
  int16_t rtb_y_ff[9];
  int16_t rtb_Switch_f;
  int8_t rtb_y_b[9];
  int8_t rtb_Switch_l4;
  bool rtb_RelationalOperator_j[9];
  bool rtb_FailCond;
  bool rtb_LogicalOperator1;
  bool rtb_LogicalOperator1_b;
  bool rtb_LogicalOperator1_f;
  bool rtb_LogicalOperator1_i;
  bool rtb_LogicalOperator1_k;
  bool rtb_LogicalOperator1_ln;
  bool rtb_LogicalOperator1_n;
  bool tmp;

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

  /* Logic: '<S3>/Logical Operator' incorporates:
   *  Constant: '<S11>/Constant'
   *  Constant: '<S12>/Constant'
   *  RelationalOperator: '<S11>/Compare'
   *  RelationalOperator: '<S12>/Compare'
   */
  rtb_FailCond = ((rtb_Divide1_n < 0.1) || (rtb_Divide1_n > 4.9));

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

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

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

  /* MATLAB Function: '<S3>/Write Ambient' */
  /* :  fprintf('Ambient = %d * 0.1 C\n',Ambient); */
  printf("Ambient = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

  /* MATLAB Function: '<S3>/Write ERROR' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read1'
   */
  /* :  if(AmbientErr) */
  if (rtb_LogicalOperator1) {
    /* :  fprintf('CCU_Body_Err.CCU_AmbienTemptSenErr_Stat = 0x1 (Failure), Sensor_Ambient_Temp = %u\n',Sensor_Ambient_Temp); */
    printf("CCU_Body_Err.CCU_AmbienTemptSenErr_Stat = 0x1 (Failure), Sensor_Ambient_Temp = %u\n",
           rtDW.ADC_Data_Model.Sensor_Ambient_Temp);
    fflush(stdout);
  }

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

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

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

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

  /* Logic: '<S4>/Logical Operator' incorporates:
   *  Constant: '<S20>/Constant'
   *  Constant: '<S21>/Constant'
   *  RelationalOperator: '<S20>/Compare'
   *  RelationalOperator: '<S21>/Compare'
   */
  rtb_LogicalOperator1 = ((rtb_Divide1_n < 0.1) || (rtb_Divide1_n > 4.9));

  /* Switch: '<S4>/Switch' incorporates:
   *  Constant: '<S22>/Constant'
   *  Constant: '<S4>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  DataStoreRead: '<S23>/Data Store Read4'
   *  Logic: '<S4>/Logical Operator1'
   *  Lookup_n-D: '<S4>/1-D Lookup Table'
   *  MATLAB Function: '<S4>/Write ERROR'
   *  RelationalOperator: '<S22>/Compare'
   *  Sum: '<S23>/Subtract'
   *  UnitDelay: '<S23>/t_start_delay_private '
   */
  /* :  if(EvapFErr) */
  if (rtb_LogicalOperator1 && (rtDW.t_now - rtDW.t_start_delay_private_DSTATE_p >=
       3000U)) {
    rtb_Switch_f = -100;

    /* :  fprintf('CCU_Body_Err.CCU_EvaTempSenErrF_Stat = 0x1 (Failure), Sensor_Evap_Temp = %u\n',Sensor_Evap_Temp); */
    printf("CCU_Body_Err.CCU_EvaTempSenErrF_Stat = 0x1 (Failure), Sensor_Evap_Temp = %u\n",
           rtDW.ADC_Data_Model.Sensor_Evap_Temp);
    fflush(stdout);
  } else {
    rtb_Switch_f = look1_iu16tdIs16_binlcs(rtDW.ADC_Data_Model.Sensor_Evap_Temp,
      rtConstP.pooled15, rtConstP.pooled1, 1023U);
  }

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

  /* MATLAB Function: '<S4>/Write Eva_F' */
  /* :  fprintf('Eva_F = %d * 0.1 C\n',Eva_F); */
  printf("Eva_F = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

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

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

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

  /* Logic: '<S5>/Logical Operator' incorporates:
   *  Constant: '<S29>/Constant'
   *  Constant: '<S30>/Constant'
   *  RelationalOperator: '<S29>/Compare'
   *  RelationalOperator: '<S30>/Compare'
   */
  rtb_LogicalOperator1_f = ((rtb_Divide1_n < 0.1) || (rtb_Divide1_n > 4.9));

  /* Switch: '<S5>/Switch' incorporates:
   *  Constant: '<S31>/Constant'
   *  Constant: '<S5>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  DataStoreRead: '<S32>/Data Store Read4'
   *  Logic: '<S5>/Logical Operator1'
   *  Lookup_n-D: '<S5>/1-D Lookup Table'
   *  MATLAB Function: '<S5>/Write ERROR'
   *  RelationalOperator: '<S31>/Compare'
   *  Sum: '<S32>/Subtract'
   *  UnitDelay: '<S32>/t_start_delay_private '
   */
  /* :  if(EvapRErr) */
  if (rtb_LogicalOperator1_f && (rtDW.t_now -
       rtDW.t_start_delay_private_DSTATE_pk >= 3000U)) {
    rtb_Switch_f = -100;

    /* :  fprintf('CCU_Body_Err.CCU_EvaTempSenErrR_Stat = 0x1 (Failure), Sensor_Rear_Evap_Temp = %u\n',Sensor_Rear_Evap_Temp); */
    printf("CCU_Body_Err.CCU_EvaTempSenErrR_Stat = 0x1 (Failure), Sensor_Rear_Evap_Temp = %u\n",
           rtDW.ADC_Data_Model.Sensor_Rear_Evap_Temp);
    fflush(stdout);
  } else {
    rtb_Switch_f = look1_iu16tdIs16_binlcs
      (rtDW.ADC_Data_Model.Sensor_Rear_Evap_Temp, rtConstP.pooled15,
       rtConstP.pooled1, 1023U);
  }

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

  /* MATLAB Function: '<S5>/Write Eva_F' */
  /* :  fprintf('Eva_R = %d * 0.1 C\n',Eva_R); */
  printf("Eva_R = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

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

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

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

  /* Logic: '<S6>/Logical Operator' incorporates:
   *  Constant: '<S38>/Constant'
   *  Constant: '<S39>/Constant'
   *  RelationalOperator: '<S38>/Compare'
   *  RelationalOperator: '<S39>/Compare'
   */
  rtb_LogicalOperator1_k = ((rtb_Divide1_n < 0.15) || (rtb_Divide1_n > 4.9));

  /* Switch: '<S6>/Switch' incorporates:
   *  Constant: '<S40>/Constant'
   *  Constant: '<S6>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  DataStoreRead: '<S41>/Data Store Read4'
   *  Logic: '<S6>/Logical Operator1'
   *  Lookup_n-D: '<S6>/1-D Lookup Table'
   *  MATLAB Function: '<S6>/Write ERROR'
   *  RelationalOperator: '<S40>/Compare'
   *  Sum: '<S41>/Subtract'
   *  UnitDelay: '<S41>/t_start_delay_private '
   */
  /* :  if(IncarFLErr) */
  if (rtb_LogicalOperator1_k && (rtDW.t_now -
       rtDW.t_start_delay_private_DSTATE_b >= 3000U)) {
    rtb_Switch_f = 200;

    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_FL = %u\n',Sensor_Incar_Temp_FL); */
    printf("CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_FL = %u\n",
           rtDW.ADC_Data_Model.Sensor_Incar_Temp_FL);
    fflush(stdout);
  } else {
    rtb_Switch_f = look1_iu16tdIs16_binlcs
      (rtDW.ADC_Data_Model.Sensor_Incar_Temp_FL, rtConstP.pooled15,
       rtConstP.pooled2, 1023U);
  }

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

  /* MATLAB Function: '<S6>/Write IncarFL' */
  /* :  fprintf('IncarFL = %d * 0.1 C\n',IncarFL); */
  printf("IncarFL = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

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

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

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

  /* Logic: '<S7>/Logical Operator' incorporates:
   *  Constant: '<S47>/Constant'
   *  Constant: '<S48>/Constant'
   *  RelationalOperator: '<S47>/Compare'
   *  RelationalOperator: '<S48>/Compare'
   */
  rtb_LogicalOperator1_b = ((rtb_Divide1_n < 0.15) || (rtb_Divide1_n > 4.9));

  /* Switch: '<S7>/Switch' incorporates:
   *  Constant: '<S49>/Constant'
   *  Constant: '<S7>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  DataStoreRead: '<S50>/Data Store Read4'
   *  Logic: '<S7>/Logical Operator1'
   *  Lookup_n-D: '<S7>/1-D Lookup Table'
   *  MATLAB Function: '<S7>/Write ERROR'
   *  RelationalOperator: '<S49>/Compare'
   *  Sum: '<S50>/Subtract'
   *  UnitDelay: '<S50>/t_start_delay_private '
   */
  /* :  if(IncarFRErr) */
  if (rtb_LogicalOperator1_b && (rtDW.t_now -
       rtDW.t_start_delay_private_DSTATE_g >= 3000U)) {
    rtb_Switch_f = 200;

    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_FR = %u\n',Sensor_Incar_Temp_FR); */
    printf("CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_FR = %u\n",
           rtDW.ADC_Data_Model.Sensor_Incar_Temp_FR);
    fflush(stdout);
  } else {
    rtb_Switch_f = look1_iu16tdIs16_binlcs
      (rtDW.ADC_Data_Model.Sensor_Incar_Temp_FR, rtConstP.pooled15,
       rtConstP.pooled2, 1023U);
  }

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

  /* MATLAB Function: '<S7>/Write IncarFR' */
  /* :  fprintf('IncarFR = %d * 0.1 C\n',IncarFR); */
  printf("IncarFR = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

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

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

  /* Product: '<S8>/Divide1' incorporates:
   *  Constant: '<S8>/Constant'
   *  Constant: '<S8>/Constant1'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  Product: '<S8>/Divide'
   */
  rtb_Divide1_n = (double)rtDW.ADC_Data_Model.Sensor_Incar_Temp_RL / 4095.0 *
    5.0;

  /* Logic: '<S8>/Logical Operator' incorporates:
   *  Constant: '<S56>/Constant'
   *  Constant: '<S57>/Constant'
   *  RelationalOperator: '<S56>/Compare'
   *  RelationalOperator: '<S57>/Compare'
   */
  rtb_LogicalOperator1_ln = ((rtb_Divide1_n < 0.15) || (rtb_Divide1_n > 4.9));

  /* Switch: '<S8>/Switch' incorporates:
   *  Constant: '<S58>/Constant'
   *  Constant: '<S8>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  DataStoreRead: '<S59>/Data Store Read4'
   *  Logic: '<S8>/Logical Operator1'
   *  Lookup_n-D: '<S8>/1-D Lookup Table'
   *  MATLAB Function: '<S8>/Write ERROR'
   *  RelationalOperator: '<S58>/Compare'
   *  Sum: '<S59>/Subtract'
   *  UnitDelay: '<S59>/t_start_delay_private '
   */
  /* :  if(IncarRLErr) */
  if (rtb_LogicalOperator1_ln && (rtDW.t_now -
       rtDW.t_start_delay_private_DSTATE_j >= 3000U)) {
    rtb_Switch_f = 200;

    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_RL = %u\n',Sensor_Incar_Temp_RL); */
    printf("CCU_Body_Err.CCU_IncarTempErrF_Stat = 0x1 (Failure), Sensor_Incar_Temp_RL = %u\n",
           rtDW.ADC_Data_Model.Sensor_Incar_Temp_RL);
    fflush(stdout);
  } else {
    rtb_Switch_f = look1_iu16tdIs16_binlcs
      (rtDW.ADC_Data_Model.Sensor_Incar_Temp_RL, rtConstP.pooled15,
       rtConstP.pooled2, 1023U);
  }

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

  /* MATLAB Function: '<S8>/Write IncarRL' */
  /* :  fprintf('IncarRL = %d * 0.1 C\n',IncarRL); */
  printf("IncarRL = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

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

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

  /* Product: '<S9>/Divide1' incorporates:
   *  Constant: '<S9>/Constant'
   *  Constant: '<S9>/Constant1'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  Product: '<S9>/Divide'
   */
  rtb_Divide1_n = (double)rtDW.ADC_Data_Model.Sensor_Incar_Temp_RR / 4095.0 *
    5.0;

  /* Logic: '<S9>/Logical Operator' incorporates:
   *  Constant: '<S65>/Constant'
   *  Constant: '<S66>/Constant'
   *  RelationalOperator: '<S65>/Compare'
   *  RelationalOperator: '<S66>/Compare'
   */
  rtb_LogicalOperator1_i = ((rtb_Divide1_n < 0.15) || (rtb_Divide1_n > 4.9));

  /* Logic: '<S9>/Logical Operator1' incorporates:
   *  Constant: '<S67>/Constant'
   *  DataStoreRead: '<S68>/Data Store Read4'
   *  RelationalOperator: '<S67>/Compare'
   *  Sum: '<S68>/Subtract'
   *  UnitDelay: '<S68>/t_start_delay_private '
   */
  rtb_LogicalOperator1_n = (rtb_LogicalOperator1_i && (rtDW.t_now -
    rtDW.t_start_delay_private_DSTATE_c >= 3000U));

  /* BusCreator: '<S64>/Bus Creator' incorporates:
   *  DataStoreWrite: '<S64>/Data Store Write'
   *  DataTypeConversion: '<S64>/Data Type Conversion'
   */
  CCU_Errors_Model.CCU_IncarTempErrF_Stat = 0U;
  CCU_Errors_Model.CCU_IncarTempErrR_Stat = rtb_LogicalOperator1_n;
  CCU_Errors_Model.CCU_DuctTempSenErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DuctTempSenErrR_Stat = 0U;
  CCU_Errors_Model.CCU_EvaTempSenErrF_Stat = 0U;
  CCU_Errors_Model.CCU_EvaTempSenErrR_Stat = 0U;
  CCU_Errors_Model.CCU_DeflectorSwErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DeflectorSwErrR_Stat = 0U;
  CCU_Errors_Model.CCU_PressSenErr_Stat = 0U;
  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 = 0U;
  CCU_Errors_Model.CCU_ActuatorErrR_Stat = 0U;
  CCU_Errors_Model.CCU_UltravioletErr_Stat = 0U;
  CCU_Errors_Model.CCU_VinRecordErr_Stat = 0U;
  CCU_Errors_Model.CCU_AirQualSenErr_Stat = 0U;
  CCU_Errors_Model.CCU_CommErr_Stat = 0U;
  CCU_Errors_Model.CCU_TWVerr_Stat = 0U;
  CCU_Errors_Model.CCU_IonizationErr_Stat = 0U;
  CCU_Errors_Model.CCU_AromaErr_Stat = 0U;

  /* Switch: '<S9>/Switch' incorporates:
   *  Constant: '<S9>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  Lookup_n-D: '<S9>/1-D Lookup Table'
   */
  if (rtb_LogicalOperator1_n) {
    rtb_Switch_f = 200;
  } else {
    rtb_Switch_f = look1_iu16tdIs16_binlcs
      (rtDW.ADC_Data_Model.Sensor_Incar_Temp_RR, rtConstP.pooled15,
       rtConstP.pooled2, 1023U);
  }

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

  /* BusCreator: '<S69>/Bus Creator' incorporates:
   *  DataStoreWrite: '<S69>/Data Store Write'
   */
  Status_Sensor_Model.Battery = 0;
  Status_Sensor_Model.AMB = 0;
  Status_Sensor_Model.Incar_FL = 0;
  Status_Sensor_Model.Incar_FR = 0;
  Status_Sensor_Model.Incar_RL = 0;
  Status_Sensor_Model.Incar_RR = rtb_Switch_f;
  Status_Sensor_Model.Eva_F = 0;
  Status_Sensor_Model.Eva_R = 0;
  Status_Sensor_Model.Pressure = 0;
  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;

  /* MATLAB Function: '<S9>/Write ERROR' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read1'
   */
  /* :  if(IncarRRErr) */
  if (rtb_LogicalOperator1_n) {
    /* :  fprintf('CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_RR = %u\n',Sensor_Incar_Temp_RR); */
    printf("CCU_Body_Err.CCU_IncarTempErrR_Stat = 0x1 (Failure), Sensor_Incar_Temp_RR = %u\n",
           rtDW.ADC_Data_Model.Sensor_Incar_Temp_RR);
    fflush(stdout);
  }

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

  /* MATLAB Function: '<S9>/Write IncarFL' */
  /* :  fprintf('IncarRR = %d * 0.1 C\n',IncarRR); */
  printf("IncarRR = %d * 0.1 C\n", rtb_Switch_f);
  fflush(stdout);

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

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

  /* Switch: '<S73>/Switch' incorporates:
   *  Constant: '<S73>/Constant1'
   *  DataStoreRead: '<S73>/Data Store Read'
   *  DataStoreRead: '<S73>/Data Store Read2'
   */
  if (rtDW.stepSig_private > 0) {
    rtb_Switch_l4 = rtDW.stepSig_private;
  } else {
    rtb_Switch_l4 = 1;
  }

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

  /* SwitchCase: '<S73>/Switch Case' */
  switch (rtb_Switch_l4) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S73>/Stop Mode' incorporates:
     *  ActionPort: '<S82>/Action Port'
     */
    /* If: '<S82>/If1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S82>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S129>/Action Port'
       */
      /* BusCreator: '<S129>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S129>/Data Store Write'
       *  SignalConversion generated from: '<S129>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 0U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 2U;
        Actuator_Ch0_Command_Model.COM[i] = 1U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S129>/Bus Creator' */

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S129>/Constant'
       *  Sum: '<S129>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* End of Outputs for SubSystem: '<S82>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S82>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S130>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S82>/If1' */
    /* End of Outputs for SubSystem: '<S73>/Stop Mode' */
    break;

   case 2:
    /* Outputs for IfAction SubSystem: '<S73>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S78>/Action Port'
     */
    /* If: '<S78>/If' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S78>/If Action Subsystem' incorporates:
       *  ActionPort: '<S115>/Action Port'
       */
      /* BusCreator: '<S115>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S115>/Data Store Write2'
       *  SignalConversion generated from: '<S115>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 6000U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 0U;
        Actuator_Ch0_Command_Model.COM[i] = 2U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S115>/Bus Creator' */

      /* MATLAB Function: '<S115>/Initial CPOS Min' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Initial CPOS Min - 6000\n'); */
      printf("SIMULINK Initial CPOS Min - 6000\n");
      fflush(stdout);

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S115>/Constant'
       *  Merge: '<S78>/Merge'
       *  SignalConversion generated from: '<S115>/step'
       *  Sum: '<S115>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* End of Outputs for SubSystem: '<S78>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S78>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S116>/Action Port'
       */
      /* BusCreator: '<S116>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S116>/Data Store Write'
       *  SignalConversion generated from: '<S116>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 0U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 0U;
        Actuator_Ch0_Command_Model.COM[i] = 0U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S116>/Bus Creator' */

      /* Merge: '<S73>/Merge' incorporates:
       *  Merge: '<S78>/Merge'
       *  SignalConversion generated from: '<S116>/stepIn1'
       */
      rtB.Merge = rtb_Switch_l4;

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

    /* End of If: '<S78>/If' */
    /* End of Outputs for SubSystem: '<S73>/Initial CPOS Min' */
    break;

   case 3:
    /* Outputs for IfAction SubSystem: '<S73>/Normal Mode' incorporates:
     *  ActionPort: '<S81>/Action Port'
     */
    /* MATLAB Function: '<S81>/MAX POSITION1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     */
    /* :  fprintf('Busy_Ch0_private '); */
    printf("Busy_Ch0_private ");
    fflush(stdout);

    /* :  for i = 1:numel(Busy_Ch0_private) */
    /* :  fprintf('%d ', int16(Busy_Ch0_private(i))); */
    printf("%d ", (int16_t)rtDW.Actuator_Ch0_Status_Model.Busy_Ch0);
    fflush(stdout);

    /* :  fprintf('\n'); */
    printf("\n");
    fflush(stdout);

    /* MATLAB Function: '<S81>/MAX POSITION2' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    /* :  fprintf('Error_Connect_Ch0_private '); */
    printf("Error_Connect_Ch0_private ");
    fflush(stdout);

    /* :  for i = 1:numel(Busy_Ch0_private) */
    /* :  fprintf('%d ', int16(Busy_Ch0_private(i))); */
    printf("%d ", (int16_t)rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0);
    fflush(stdout);

    /* :  fprintf('\n'); */
    printf("\n");
    fflush(stdout);

    /* If: '<S81>/If1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S81>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S124>/Action Port'
       */
      /* BusCreator: '<S124>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S124>/Data Store Write1'
       *  SignalConversion generated from: '<S124>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 0U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 0U;
        Actuator_Ch0_Command_Model.COM[i] = 1U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S124>/Bus Creator' */

      /* MATLAB Function: '<S124>/Normal Mode' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Normal Mode\n'); */
      printf("SIMULINK Normal Mode\n");
      fflush(stdout);

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S124>/Constant'
       *  SignalConversion generated from: '<S124>/step'
       *  Sum: '<S124>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* End of Outputs for SubSystem: '<S81>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S81>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S125>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S81>/If1' */
    /* End of Outputs for SubSystem: '<S73>/Normal Mode' */
    break;

   case 4:
    /* Outputs for IfAction SubSystem: '<S73>/Move to position Min' incorporates:
     *  ActionPort: '<S80>/Action Port'
     */
    /* If: '<S80>/If1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S80>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S121>/Action Port'
       */
      /* BusCreator: '<S121>/Bus Creator' incorporates:
       *  Constant: '<S121>/Constant1'
       *  Constant: '<S121>/Constant10'
       *  Constant: '<S121>/Constant11'
       *  Constant: '<S121>/Constant14'
       *  Constant: '<S121>/Constant2'
       *  Constant: '<S121>/Constant9'
       *  DataStoreWrite: '<S121>/Data Store Write7'
       *  SignalConversion generated from: '<S121>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 1U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 0U;
        Actuator_Ch0_Command_Model.COM[i] = 3U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 1U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 1U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 3U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S121>/Bus Creator' */

      /* MATLAB Function: '<S121>/Move to position Min' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Move to position Min - 1\n'); */
      printf("SIMULINK Move to position Min - 1\n");
      fflush(stdout);

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S121>/Constant'
       *  SignalConversion generated from: '<S121>/step'
       *  Sum: '<S121>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* End of Outputs for SubSystem: '<S80>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S80>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S122>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S80>/If1' */
    /* End of Outputs for SubSystem: '<S73>/Move to position Min' */
    break;

   case 5:
    /* Outputs for IfAction SubSystem: '<S73>/Check Stall Min' incorporates:
     *  ActionPort: '<S75>/Action Port'
     */
    /* RelationalOperator: '<S75>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  RelationalOperator: '<S75>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_Act_Stall_Slave_Ch0[i] == 1);
    }

    /* End of RelationalOperator: '<S75>/Relational Operator1' */

    /* Logic: '<S75>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S75>/Relational Operator'
     */
    rtb_LogicalOperator1_n = rtb_RelationalOperator_j[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_n = (rtb_LogicalOperator1_n ||
        rtb_RelationalOperator_j[i + 1]);
    }

    /* RelationalOperator: '<S75>/Relational Operator' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i] == 1);
    }

    /* End of RelationalOperator: '<S75>/Relational Operator' */

    /* Logic: '<S75>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S75>/Relational Operator'
     */
    tmp = rtb_RelationalOperator_j[0];
    for (i = 0; i < 8; i++) {
      tmp = (tmp || rtb_RelationalOperator_j[i + 1]);
    }

    /* If: '<S75>/If2' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     *  DataTypeConversion: '<S75>/Data Type Conversion'
     *  DataTypeConversion: '<S75>/Data Type Conversion1'
     *  Logic: '<S75>/Logical Operator'
     *  Logic: '<S75>/Logical Operator1'
     *  Logic: '<S75>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0) &&
        (rtb_LogicalOperator1_n || tmp)) {
      /* Outputs for IfAction SubSystem: '<S75>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S89>/Action Port'
       */
      /* DataStoreWrite: '<S89>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        rtDW.MinPositionCh0_private[i] =
          rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i];
      }

      /* End of DataStoreWrite: '<S89>/Data Store Write1' */

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S89>/Constant'
       *  Sum: '<S89>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* MATLAB Function: '<S89>/MIN POSITION' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Min_position_Ch0 '); */
      printf("SIMULINK Min_position_Ch0 ");
      fflush(stdout);

      /* :  for i = 1:numel(step) */
      for (i = 0; i < 9; i++) {
        /* :  fprintf('%d ', int16(step(i))); */
        printf("%d ", rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i]);
        fflush(stdout);
      }

      /* :  fprintf('\n'); */
      printf("\n");
      fflush(stdout);

      /* End of MATLAB Function: '<S89>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S75>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S75>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S90>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S75>/If2' */
    /* End of Outputs for SubSystem: '<S73>/Check Stall Min' */
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S73>/Check Stall Min' incorporates:
       *  ActionPort: '<S75>/Action Port'
       */
      rtb_y_ff[i] = rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i];

      /* End of Outputs for SubSystem: '<S73>/Check Stall Min' */
    }

    /* Outputs for IfAction SubSystem: '<S73>/Check Stall Min' incorporates:
     *  ActionPort: '<S75>/Action Port'
     */
    /* MATLAB Function: '<S75>/MAX POSITION' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     */
    MAXPOSITION(rtb_y_ff);

    /* End of Outputs for SubSystem: '<S73>/Check Stall Min' */
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S73>/Check Stall Min' incorporates:
       *  ActionPort: '<S75>/Action Port'
       */
      rtb_y_b[i] = rtDW.Actuator_Ch0_Status_Model.in_Act_Stall_Slave_Ch0[i];

      /* End of Outputs for SubSystem: '<S73>/Check Stall Min' */
    }

    /* Outputs for IfAction SubSystem: '<S73>/Check Stall Min' incorporates:
     *  ActionPort: '<S75>/Action Port'
     */
    /* MATLAB Function: '<S75>/MAX POSITION1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     */
    MAXPOSITION1(rtb_y_b);

    /* End of Outputs for SubSystem: '<S73>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S73>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S77>/Action Port'
     */
    /* If: '<S77>/If1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S77>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S112>/Action Port'
       */
      /* BusCreator: '<S112>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S112>/Data Store Write2'
       *  SignalConversion generated from: '<S112>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 1U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 0U;
        Actuator_Ch0_Command_Model.COM[i] = 2U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S112>/Bus Creator' */

      /* MATLAB Function: '<S112>/Initial CPOS Max' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Initial CPOS Max - 1\n'); */
      printf("SIMULINK Initial CPOS Max - 1\n");
      fflush(stdout);

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S112>/Constant'
       *  SignalConversion generated from: '<S112>/step'
       *  Sum: '<S112>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* End of Outputs for SubSystem: '<S77>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S77>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S113>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S77>/If1' */
    /* End of Outputs for SubSystem: '<S73>/Initial CPOS Max' */
    break;

   case 7:
    /* Outputs for IfAction SubSystem: '<S73>/Move to position Max' incorporates:
     *  ActionPort: '<S79>/Action Port'
     */
    /* If: '<S79>/If1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0)) {
      /* Outputs for IfAction SubSystem: '<S79>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S118>/Action Port'
       */
      /* BusCreator: '<S118>/Bus Creator' incorporates:
       *  Constant: '<S118>/Constant1'
       *  Constant: '<S118>/Constant10'
       *  Constant: '<S118>/Constant11'
       *  Constant: '<S118>/Constant14'
       *  Constant: '<S118>/Constant2'
       *  Constant: '<S118>/Constant9'
       *  DataStoreWrite: '<S118>/Data Store Write7'
       *  SignalConversion generated from: '<S118>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch0_Command_Model.POS[i] = 6000U;
        Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch0_Command_Model.MODE[i] = 0U;
        Actuator_Ch0_Command_Model.COM[i] = 3U;
        Actuator_Ch0_Command_Model.Stall_SET[i] = 1U;
        Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch0_Command_Model.Autos_SET[i] = 1U;
        Actuator_Ch0_Command_Model.Speed_SET[i] = 3U;
        Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;
      }

      /* End of BusCreator: '<S118>/Bus Creator' */

      /* MATLAB Function: '<S118>/Move to position Max' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Move to position Max - 6000\n'); */
      printf("SIMULINK Move to position Max - 6000\n");
      fflush(stdout);

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S118>/Constant'
       *  SignalConversion generated from: '<S118>/step'
       *  Sum: '<S118>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* End of Outputs for SubSystem: '<S79>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S79>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S119>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S79>/If1' */
    /* End of Outputs for SubSystem: '<S73>/Move to position Max' */
    break;

   case 8:
    /* Outputs for IfAction SubSystem: '<S73>/Check Stall Max' incorporates:
     *  ActionPort: '<S74>/Action Port'
     */
    /* RelationalOperator: '<S74>/Relational Operator1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  RelationalOperator: '<S74>/Relational Operator'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_Act_Stall_Slave_Ch0[i] == 1);
    }

    /* End of RelationalOperator: '<S74>/Relational Operator1' */

    /* Logic: '<S74>/Logical Operator2' incorporates:
     *  RelationalOperator: '<S74>/Relational Operator'
     */
    rtb_LogicalOperator1_n = rtb_RelationalOperator_j[0];
    for (i = 0; i < 8; i++) {
      rtb_LogicalOperator1_n = (rtb_LogicalOperator1_n ||
        rtb_RelationalOperator_j[i + 1]);
    }

    /* RelationalOperator: '<S74>/Relational Operator' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i] == 6000);
    }

    /* End of RelationalOperator: '<S74>/Relational Operator' */

    /* Logic: '<S74>/Logical Operator1' incorporates:
     *  RelationalOperator: '<S74>/Relational Operator'
     */
    tmp = rtb_RelationalOperator_j[0];
    for (i = 0; i < 8; i++) {
      tmp = (tmp || rtb_RelationalOperator_j[i + 1]);
    }

    /* If: '<S74>/If2' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     *  DataStoreWrite: '<S73>/Data Store Write'
     *  DataStoreWrite: '<S73>/Data Store Write1'
     *  DataTypeConversion: '<S74>/Data Type Conversion'
     *  DataTypeConversion: '<S74>/Data Type Conversion1'
     *  Logic: '<S74>/Logical Operator'
     *  Logic: '<S74>/Logical Operator1'
     *  Logic: '<S74>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy_Ch0 == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect_Ch0 == 0) &&
        (rtb_LogicalOperator1_n || tmp)) {
      /* Outputs for IfAction SubSystem: '<S74>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S84>/Action Port'
       */
      /* DataStoreWrite: '<S84>/Data Store Write1' */
      for (i = 0; i < 9; i++) {
        rtDW.MinPositionCh0_private[i] =
          rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i];
      }

      /* End of DataStoreWrite: '<S84>/Data Store Write1' */

      /* Merge: '<S73>/Merge' incorporates:
       *  Constant: '<S84>/Constant'
       *  Sum: '<S84>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l4 + 1);

      /* MATLAB Function: '<S84>/MIN POSITION' */
      /* :  y = step; */
      /* :  fprintf('SIMULINK Max_position_Ch0 '); */
      printf("SIMULINK Max_position_Ch0 ");
      fflush(stdout);

      /* :  for i = 1:numel(step) */
      for (i = 0; i < 9; i++) {
        /* :  fprintf('%d ', int16(step(i))); */
        printf("%d ", rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i]);
        fflush(stdout);
      }

      /* :  fprintf('\n'); */
      printf("\n");
      fflush(stdout);

      /* End of MATLAB Function: '<S84>/MIN POSITION' */
      /* End of Outputs for SubSystem: '<S74>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S74>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S85>/Action Port'
       */
      IfActionSubsystem3(rtb_Switch_l4, &rtB.Merge);

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

    /* End of If: '<S74>/If2' */
    /* End of Outputs for SubSystem: '<S73>/Check Stall Max' */
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S73>/Check Stall Max' incorporates:
       *  ActionPort: '<S74>/Action Port'
       */
      rtb_y_ff[i] = rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL_Ch0[i];

      /* End of Outputs for SubSystem: '<S73>/Check Stall Max' */
    }

    /* Outputs for IfAction SubSystem: '<S73>/Check Stall Max' incorporates:
     *  ActionPort: '<S74>/Action Port'
     */
    /* MATLAB Function: '<S74>/MAX POSITION' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     */
    MAXPOSITION(rtb_y_ff);

    /* End of Outputs for SubSystem: '<S73>/Check Stall Max' */
    for (i = 0; i < 9; i++) {
      /* Outputs for IfAction SubSystem: '<S73>/Check Stall Max' incorporates:
       *  ActionPort: '<S74>/Action Port'
       */
      rtb_y_b[i] = rtDW.Actuator_Ch0_Status_Model.in_Act_Stall_Slave_Ch0[i];

      /* End of Outputs for SubSystem: '<S73>/Check Stall Max' */
    }

    /* Outputs for IfAction SubSystem: '<S73>/Check Stall Max' incorporates:
     *  ActionPort: '<S74>/Action Port'
     */
    /* MATLAB Function: '<S74>/MAX POSITION1' incorporates:
     *  DataStoreRead: '<S73>/Data Store Read1'
     */
    MAXPOSITION1(rtb_y_b);

    /* End of Outputs for SubSystem: '<S73>/Check Stall Max' */
    break;

   case 9:
    /* Outputs for IfAction SubSystem: '<S73>/Homing' incorporates:
     *  ActionPort: '<S76>/Action Port'
     */
    /* Merge: '<S73>/Merge' incorporates:
     *  SignalConversion generated from: '<S76>/stepIn'
     */
    rtB.Merge = rtb_Switch_l4;

    /* Outputs for IfAction SubSystem: '<S76>/Switch Case Action Subsystem2' incorporates:
     *  ActionPort: '<S98>/Action Port'
     */
    /* SwitchCase: '<S76>/Switch Case' incorporates:
     *  BusCreator: '<S106>/Bus Creator'
     *  DataStoreWrite: '<S106>/Data Store Write1'
     *  MATLAB Function: '<S98>/MAX POSITION'
     */
    CCU_Errors_Model.CCU_IncarTempErrF_Stat = 0U;
    CCU_Errors_Model.CCU_IncarTempErrR_Stat = 0U;
    CCU_Errors_Model.CCU_DuctTempSenErrF_Stat = 0U;
    CCU_Errors_Model.CCU_DuctTempSenErrR_Stat = 0U;
    CCU_Errors_Model.CCU_EvaTempSenErrF_Stat = 0U;
    CCU_Errors_Model.CCU_EvaTempSenErrR_Stat = 0U;
    CCU_Errors_Model.CCU_DeflectorSwErrF_Stat = 0U;
    CCU_Errors_Model.CCU_DeflectorSwErrR_Stat = 0U;
    CCU_Errors_Model.CCU_PressSenErr_Stat = 0U;
    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 = 0U;
    CCU_Errors_Model.CCU_ActuatorErrR_Stat = 0U;
    CCU_Errors_Model.CCU_UltravioletErr_Stat = 0U;
    CCU_Errors_Model.CCU_VinRecordErr_Stat = 0U;
    CCU_Errors_Model.CCU_AirQualSenErr_Stat = 0U;
    CCU_Errors_Model.CCU_CommErr_Stat = 0U;
    CCU_Errors_Model.CCU_TWVerr_Stat = 0U;
    CCU_Errors_Model.CCU_IonizationErr_Stat = 0U;
    CCU_Errors_Model.CCU_AromaErr_Stat = 0U;

    /* :  for i = 1:numel(ErrCallibration) */
    for (i = 0; i < 9; i++) {
      /* BusCreator: '<S106>/Bus Creator1' incorporates:
       *  DataStoreWrite: '<S106>/Data Store Write'
       *  SignalConversion generated from: '<S106>/Bus Creator1'
       * */
      Actuator_Ch0_Command_Model.POS[i] = 0U;
      Actuator_Ch0_Command_Model.BUS_ADR[i] = 0U;
      Actuator_Ch0_Command_Model.MODE[i] = 2U;
      Actuator_Ch0_Command_Model.COM[i] = 0U;
      Actuator_Ch0_Command_Model.Stall_SET[i] = 0U;
      Actuator_Ch0_Command_Model.Lnoise_SET[i] = 0U;
      Actuator_Ch0_Command_Model.Autos_SET[i] = 0U;
      Actuator_Ch0_Command_Model.Speed_SET[i] = 0U;
      Actuator_Ch0_Command_Model.Coils_Stop_SET[i] = 0U;

      /* DataStoreWrite: '<S98>/Data Store Write' incorporates:
       *  Logic: '<S97>/Logical Operator'
       */
      rtDW.ErrorCalibrationCh0_private[i] = false;

      /* Product: '<S98>/Divide1' incorporates:
       *  Constant: '<S98>/ACT1'
       *  DataStoreRead: '<S98>/MAX ACT1T '
       *  DataStoreRead: '<S98>/MIN ACT1T '
       *  Sum: '<S98>/ACT1T'
       */
      rtb_Divide1_j[i] = (double)(int16_t)(rtDW.MaxPositionCh0_private[i] -
        rtDW.MinPositionCh0_private[i]) / (double)rtConstP.pooled18[i];
    }

    MAXPOSITION_l(rtb_Divide1_j, rtb_y_gj);

    /* End of SwitchCase: '<S76>/Switch Case' */
    /* End of Outputs for SubSystem: '<S76>/Switch Case Action Subsystem2' */

    /* MATLAB Function: '<S76>/MAX POSITION' incorporates:
     *  DataStoreRead: '<S76>/Data Store Read2'
     */
    /* :  y = step; */
    /* :  fprintf('SIMULINK MAX POSITION '); */
    printf("SIMULINK MAX POSITION ");
    fflush(stdout);

    /* :  for i = 1:numel(step) */
    for (i = 0; i < 9; i++) {
      /* :  fprintf('%d ', int16(step(i))); */
      printf("%d ", rtDW.MaxPositionCh0_private[i]);
      fflush(stdout);
    }

    /* :  fprintf('\n'); */
    printf("\n");
    fflush(stdout);

    /* End of MATLAB Function: '<S76>/MAX POSITION' */

    /* MATLAB Function: '<S76>/MIN POSITION' incorporates:
     *  DataStoreRead: '<S76>/Data Store Read3'
     */
    /* :  y = step; */
    /* :  fprintf('SIMULINK MIN POSITION '); */
    printf("SIMULINK MIN POSITION ");
    fflush(stdout);

    /* :  for i = 1:numel(step) */
    for (i = 0; i < 9; i++) {
      /* :  fprintf('%d ', int16(step(i))); */
      printf("%d ", rtDW.MinPositionCh0_private[i]);
      fflush(stdout);
    }

    /* :  fprintf('\n'); */
    printf("\n");
    fflush(stdout);

    /* End of MATLAB Function: '<S76>/MIN POSITION' */
    /* End of Outputs for SubSystem: '<S73>/Homing' */
    break;
  }

  /* End of SwitchCase: '<S73>/Switch Case' */

  /* DataStoreWrite: '<S73>/Finish write stepSig' */
  rtDW.stepSig_private = rtB.Merge;

  /* MATLAB Function: '<S73>/Write Ignition' */
  /* :  fprintf('step = %d\n',step); */
  printf("step = %d\n", rtb_Switch_l4);
  fflush(stdout);

  /* Update for UnitDelay: '<S14>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE = rtb_FailCond;

  /* Update for UnitDelay: '<S23>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_h = rtb_LogicalOperator1;

  /* Update for UnitDelay: '<S32>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_i = rtb_LogicalOperator1_f;

  /* Update for UnitDelay: '<S41>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_c = rtb_LogicalOperator1_k;

  /* Update for UnitDelay: '<S50>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_hm = rtb_LogicalOperator1_b;

  /* Update for UnitDelay: '<S59>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_b = rtb_LogicalOperator1_ln;

  /* Update for UnitDelay: '<S68>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_g = rtb_LogicalOperator1_i;
}

/* Model initialize function */
void HVAC_model_initialize(void)
{
  /* (no initialization code required) */
}

/* Model terminate function */
void HVAC_model_terminate(void)
{
  /* (no terminate code required) */
}

/*
 * File trailer for generated code.
 *
 * [EOF]
 */