/*
 * File: HVAC_model.c
 *
 * Code generated for Simulink model 'HVAC_model'.
 *
 * Model version                  : 1.625
 * Simulink Coder version         : 24.1 (R2024a) 19-Nov-2023
 * C/C++ source code generated on : Tue Feb 17 18:15:10 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 <stdbool.h>

/* Exported block states */
ActuatorCmdBus Actuator_Ch0_Command_Model;/* '<S133>/Data Store Memory15' */
ActuatorCmdBus Actuator_Ch1_Command_Model;/* '<S134>/Data Store Memory15' */
ActuatorCmdBus Actuator_Ch2_Command_Model;/* '<S135>/Data Store Memory15' */
CmdBusStatus Status_Sensor_Model;      /* '<S1>/Data Store Memory' */
CmdBusError CCU_Errors_Model;          /* '<Root>/Data Store Memory3' */
CmdBusPWMGet PWM_Get;                  /* '<S3>/Data Store Memory1' */

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

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

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

/* Real-time model */
static RT_MODEL rtM_;
RT_MODEL *const rtM = &rtM_;
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:
 *    '<S143>/If Action Subsystem3'
 *    '<S142>/If Action Subsystem3'
 *    '<S141>/If Action Subsystem3'
 *    '<S137>/If Action Subsystem3'
 *    '<S138>/If Action Subsystem3'
 *    '<S140>/If Action Subsystem3'
 *    '<S136>/If Action Subsystem3'
 */
void IfActionSubsystem3(int8_t rtu_stepIn, int8_t *rty_step)
{
  int32_t i;

  /* BusCreator: '<S167>/Bus Creator' incorporates:
   *  DataStoreWrite: '<S167>/Data Store Write'
   *  SignalConversion generated from: '<S167>/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: '<S167>/Bus Creator' */

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

/*
 * Output and update for atomic system:
 *    '<S154>/Initial CPOS Min'
 *    '<S186>/Initial CPOS Min'
 */
void InitialCPOSMin(double rtu_LOGGER, int8_t rtu_step, int8_t *rty_y)
{
  *rty_y = rtu_step;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  fprintf('SIMULINK Initial CPOS Min - 6000\n'); */
    printf("SIMULINK Initial CPOS Min - 6000\n");
    fflush(stdout);
  }
}

/*
 * Output and update for atomic system:
 *    '<S163>/Normal Mode'
 *    '<S195>/Normal Mode'
 */
void NormalMode(double rtu_LOGGER, int8_t rtu_step, int8_t *rty_y)
{
  *rty_y = rtu_step;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  fprintf('SIMULINK Normal Mode\n'); */
    printf("SIMULINK Normal Mode\n");
    fflush(stdout);
  }
}

/*
 * Output and update for atomic system:
 *    '<S160>/Move to position Min'
 *    '<S192>/Move to position Min'
 *    '<S226>/Move to position Min'
 */
void MovetopositionMin(double rtu_LOGGER, int8_t rtu_step, int8_t *rty_y)
{
  *rty_y = rtu_step;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  fprintf('SIMULINK Move to position Min - 1\n'); */
    printf("SIMULINK Move to position Min - 1\n");
    fflush(stdout);
  }
}

/*
 * Output and update for atomic system:
 *    '<S148>/MIN POSITION'
 *    '<S180>/MIN POSITION'
 *    '<S212>/MIN POSITION'
 */
void MINPOSITION(int16_t rty_y[9], double rtu_LOGGER)
{
  int32_t i;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  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 ", rty_y[i]);
      fflush(stdout);
    }

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

/*
 * Output and update for atomic system:
 *    '<S151>/Initial CPOS Max'
 *    '<S183>/Initial CPOS Max'
 *    '<S215>/Initial CPOS Max'
 */
void InitialCPOSMax(double rtu_LOGGER, int8_t rtu_step, int8_t *rty_y)
{
  *rty_y = rtu_step;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  fprintf('SIMULINK Initial CPOS Max - 1\n'); */
    printf("SIMULINK Initial CPOS Max - 1\n");
    fflush(stdout);
  }
}

/*
 * Output and update for atomic system:
 *    '<S157>/Move to position Max'
 *    '<S189>/Move to position Max'
 *    '<S223>/Move to position Max'
 */
void MovetopositionMax(int8_t rtu_step, double rtu_LOGGER, int8_t *rty_y)
{
  *rty_y = rtu_step;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  fprintf('SIMULINK Move to position Max - 6000\n'); */
    printf("SIMULINK Move to position Max - 6000\n");
    fflush(stdout);
  }
}

/*
 * Output and update for atomic system:
 *    '<S145>/MIN POSITION'
 *    '<S177>/MIN POSITION'
 *    '<S209>/MIN POSITION'
 */
void MINPOSITION_g(int16_t rty_y[9], double rtu_LOGGER)
{
  int32_t i;

  /* :  y = step; */
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  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 ", rty_y[i]);
      fflush(stdout);
    }

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

/*
 * Output and update for atomic system:
 *    '<S133>/Write Ignition'
 *    '<S134>/Write Ignition'
 */
void WriteIgnition(double rtu_LOGGER, int8_t rtu_step)
{
  /* :  if(LOGGER) */
  if (rtu_LOGGER != 0.0) {
    /* :  fprintf('step = %d\n',step); */
    printf("step = %d\n", rtu_step);
    fflush(stdout);
  }
}

/*
 * Output and update for action system:
 *    '<S175>/If Action Subsystem3'
 *    '<S174>/If Action Subsystem3'
 *    '<S173>/If Action Subsystem3'
 *    '<S169>/If Action Subsystem3'
 *    '<S170>/If Action Subsystem3'
 *    '<S172>/If Action Subsystem3'
 *    '<S168>/If Action Subsystem3'
 */
void IfActionSubsystem3_m(int8_t rtu_stepIn, int8_t *rty_step)
{
  int32_t i;

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

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

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

/*
 * Output and update for action system:
 *    '<S207>/If Action Subsystem3'
 *    '<S206>/If Action Subsystem3'
 *    '<S205>/If Action Subsystem3'
 *    '<S201>/If Action Subsystem3'
 *    '<S202>/If Action Subsystem3'
 *    '<S204>/If Action Subsystem3'
 *    '<S200>/If Action Subsystem3'
 */
void IfActionSubsystem3_n(int8_t rtu_stepIn, int8_t *rty_step)
{
  int32_t i;

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

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

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

/* Model step function */
void HVAC_model_step(void)
{
  double rtb_Divide1;
  double rtb_Divide3;
  int32_t i;
  int16_t rtb_y_ey[9];
  int16_t rtb_Switch1;
  int16_t rtb_Switch1_d;
  int16_t rtb_Switch_d;
  int16_t rtb_Switch_f;
  int16_t rtb_Switch_jd;
  int16_t rtb_Switch_jv;
  int16_t rtb_Switch_ku;
  int16_t rtb_Switch_m;
  int8_t rtb_Switch_l5;
  int8_t rtb_y_fb;
  bool rtb_RelationalOperator_j[9];
  bool rtb_FailCond;
  bool rtb_FailCond_a;
  bool rtb_FailCond_b;
  bool rtb_FailCond_e;
  bool rtb_FailCond_f;
  bool rtb_FailCond_g;
  bool rtb_FailCond_l;
  bool rtb_FailCond_mg;
  bool rtb_LogicalOperator1;
  bool rtb_LogicalOperator1_ca;
  bool rtb_LogicalOperator1_f;
  bool rtb_LogicalOperator1_k;
  bool rtb_LogicalOperator1_lc;
  bool rtb_LogicalOperator1_lk;
  bool rtb_LogicalOperator3_f3;
  bool rtb_LogicalOperator3_oi;

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

  /* Logic: '<S4>/Logical Operator' incorporates:
   *  Constant: '<S46>/Constant'
   *  Constant: '<S47>/Constant'
   *  RelationalOperator: '<S46>/Compare'
   *  RelationalOperator: '<S47>/Compare'
   */
  rtb_FailCond = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

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

  /* Switch: '<S4>/Switch' incorporates:
   *  Constant: '<S4>/Constant2'
   *  DataStoreRead: '<S1>/Data Store Read1'
   *  Lookup_n-D: '<S4>/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.pooled23,
       rtConstP.uDLookupTable_tableData, 1023U);
  }

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

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

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

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

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

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

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

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

  /* Logic: '<S5>/Logical Operator' incorporates:
   *  Constant: '<S53>/Constant'
   *  Constant: '<S54>/Constant'
   *  RelationalOperator: '<S53>/Compare'
   *  RelationalOperator: '<S54>/Compare'
   */
  rtb_FailCond_f = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

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

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

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

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

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

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

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

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

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

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

  /* Logic: '<S6>/Logical Operator' incorporates:
   *  Constant: '<S60>/Constant'
   *  Constant: '<S61>/Constant'
   *  RelationalOperator: '<S60>/Compare'
   *  RelationalOperator: '<S61>/Compare'
   */
  rtb_FailCond_g = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

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

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

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

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

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

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

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

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

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

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

  /* Logic: '<S22>/Logical Operator' incorporates:
   *  Constant: '<S82>/Constant'
   *  Constant: '<S83>/Constant'
   *  RelationalOperator: '<S82>/Compare'
   *  RelationalOperator: '<S83>/Compare'
   */
  rtb_FailCond_mg = ((rtb_Divide1 < 0.1) || (rtb_Divide1 > 4.9));

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

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

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

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

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

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

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

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

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

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

  /* Logic: '<S39>/Logical Operator' incorporates:
   *  Constant: '<S105>/Constant'
   *  Constant: '<S106>/Constant'
   *  RelationalOperator: '<S105>/Compare'
   *  RelationalOperator: '<S106>/Compare'
   */
  rtb_FailCond_e = ((rtb_Divide1 < 0.15) || (rtb_Divide1 > 4.9));

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

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

  /* Logic: '<S39>/Logical Operator2' incorporates:
   *  Constant: '<S108>/Constant'
   *  Constant: '<S109>/Constant'
   *  RelationalOperator: '<S108>/Compare'
   *  RelationalOperator: '<S109>/Compare'
   */
  rtb_FailCond_a = ((rtb_Divide3 < 0.15) || (rtb_Divide3 > 4.9));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /* Logic: '<S40>/Logical Operator' incorporates:
   *  Constant: '<S119>/Constant'
   *  Constant: '<S120>/Constant'
   *  RelationalOperator: '<S119>/Compare'
   *  RelationalOperator: '<S120>/Compare'
   */
  rtb_FailCond_l = ((rtb_Divide1 < 0.15) || (rtb_Divide1 > 4.9));

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

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

  /* Logic: '<S40>/Logical Operator2' incorporates:
   *  Constant: '<S122>/Constant'
   *  Constant: '<S123>/Constant'
   *  RelationalOperator: '<S122>/Compare'
   *  RelationalOperator: '<S123>/Compare'
   */
  rtb_FailCond_b = ((rtb_Divide3 < 0.15) || (rtb_Divide3 > 4.9));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /* BusCreator: '<S1>/Bus Creator' incorporates:
   *  DataStoreWrite: '<S1>/Data Store Write2'
   */
  Status_Sensor_Model.Battery = 0;
  Status_Sensor_Model.AMB = rtb_Switch_f;
  Status_Sensor_Model.Incar_FL = rtb_Switch_d;
  Status_Sensor_Model.Incar_FR = rtb_Switch_m;
  Status_Sensor_Model.Incar_RL = rtb_Switch1;
  Status_Sensor_Model.Incar_RR = rtb_Switch1_d;
  Status_Sensor_Model.Eva_F = rtb_Switch_ku;
  Status_Sensor_Model.Eva_R = rtb_Switch_jd;
  Status_Sensor_Model.Pressure = rtb_Switch_jv;
  Status_Sensor_Model.Duct_FL_Upper = 0;
  Status_Sensor_Model.Duct_FL_Lower = 0;
  Status_Sensor_Model.Duct_FR_Upper = 0;
  Status_Sensor_Model.Duct_FR_Lower = 0;
  Status_Sensor_Model.Duct_RL = 0;
  Status_Sensor_Model.Duct_RR = 0;
  Status_Sensor_Model.Duct_Side_FL = 0;
  Status_Sensor_Model.Duct_Side_FR = 0;
  Status_Sensor_Model.Duct_Side_RL = 0;
  Status_Sensor_Model.Duct_Side_RR = 0;
  Status_Sensor_Model.AQS = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /* MATLAB Function: '<S1>/Write' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read2'
   *  DataStoreRead: '<S1>/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: '<S1>/Write' */

  /* MATLAB Function: '<S1>/Write1' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read2'
   *  DataStoreRead: '<S1>/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: '<S1>/Write1' */

  /* MATLAB Function: '<S1>/Write2' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read2'
   *  DataStoreRead: '<S1>/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: '<S1>/Write2' */

  /* MATLAB Function: '<S1>/Write3' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read2'
   *  DataStoreRead: '<S1>/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: '<S1>/Write3' */

  /* MATLAB Function: '<S1>/Write4' incorporates:
   *  DataStoreRead: '<S1>/Data Store Read2'
   *  DataStoreRead: '<S1>/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: '<S1>/Write4' */

  /* BusCreator: '<Root>/Bus Creator' incorporates:
   *  DataStoreWrite: '<Root>/Data Store Write'
   *  DataTypeConversion: '<S22>/Data Type Conversion'
   *  DataTypeConversion: '<S39>/Data Type Conversion'
   *  DataTypeConversion: '<S40>/Data Type Conversion'
   *  DataTypeConversion: '<S4>/Data Type Conversion'
   *  DataTypeConversion: '<S5>/Data Type Conversion'
   *  DataTypeConversion: '<S6>/Data Type Conversion'
   *  Logic: '<S39>/Logical Operator4'
   *  Logic: '<S40>/Logical Operator4'
   */
  CCU_Errors_Model.CCU_IncarTempErrF_Stat = (uint8_t)(rtb_LogicalOperator1_ca ||
    rtb_LogicalOperator3_f3);
  CCU_Errors_Model.CCU_IncarTempErrR_Stat = (uint8_t)(rtb_LogicalOperator1_lc ||
    rtb_LogicalOperator3_oi);
  CCU_Errors_Model.CCU_DuctTempSenErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DuctTempSenErrR_Stat = 0U;
  CCU_Errors_Model.CCU_EvaTempSenErrF_Stat = rtb_LogicalOperator1_f;
  CCU_Errors_Model.CCU_EvaTempSenErrR_Stat = rtb_LogicalOperator1_k;
  CCU_Errors_Model.CCU_DeflectorSwErrF_Stat = 0U;
  CCU_Errors_Model.CCU_DeflectorSwErrR_Stat = 0U;
  CCU_Errors_Model.CCU_PressSenErr_Stat = rtb_LogicalOperator1_lk;
  CCU_Errors_Model.CCU_AmbienTemptSenErr_Stat = rtb_LogicalOperator1;
  CCU_Errors_Model.CCU_SealingValveErr_Stat = 0U;
  CCU_Errors_Model.CCU_ETXVerr_Stat = 0U;
  CCU_Errors_Model.CCU_HVACfanOrTXVerrF_Stat = 0U;
  CCU_Errors_Model.CCU_HVACfanOrTXVerrR_Stat = 0U;
  CCU_Errors_Model.CCU_ActuatorErrF_Stat = 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;

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

  /* MATLAB Function: '<S3>/Write' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentFront = %u \n',data); */
  printf("pwmPercentFront = %u \n", rtDW.PWM_Set_Model.pwmPercentFront);
  fflush(stdout);

  /* MATLAB Function: '<S3>/Write1' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentRear = %u \n',data); */
  printf("pwmPercentRear = %u \n", rtDW.PWM_Set_Model.pwmPercentRear);
  fflush(stdout);

  /* MATLAB Function: '<S3>/Write2' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentFrontReserved = %u \n',data); */
  printf("pwmPercentFrontReserved = %u \n",
         rtDW.PWM_Set_Model.pwmPercentFrontReserved);
  fflush(stdout);

  /* MATLAB Function: '<S3>/Write3' incorporates:
   *  DataStoreRead: '<S3>/Data Store Read'
   */
  /* :  if(LOGGER) */
  /* :  fprintf('pwmPercentRearReserved = %u \n',data); */
  printf("pwmPercentRearReserved = %u \n",
         rtDW.PWM_Set_Model.pwmPercentRearReserved);
  fflush(stdout);

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

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

  /* SwitchCase: '<S133>/Switch Case' */
  switch (rtb_Switch_l5) {
   case 1:
    /* Outputs for IfAction SubSystem: '<S133>/Stop Mode' incorporates:
     *  ActionPort: '<S143>/Action Port'
     */
    /* If: '<S143>/If1' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S143>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S166>/Action Port'
       */
      /* BusCreator: '<S166>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S166>/Data Store Write'
       *  SignalConversion generated from: '<S166>/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: '<S166>/Bus Creator' */

      /* Merge: '<S133>/Merge' incorporates:
       *  Constant: '<S166>/Constant'
       *  Sum: '<S166>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l5 + 1);

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

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

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

   case 2:
    /* Outputs for IfAction SubSystem: '<S133>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S139>/Action Port'
     */
    /* If: '<S139>/If' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S139>/If Action Subsystem' incorporates:
       *  ActionPort: '<S154>/Action Port'
       */
      /* BusCreator: '<S154>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S154>/Data Store Write2'
       *  SignalConversion generated from: '<S154>/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: '<S154>/Bus Creator' */

      /* MATLAB Function: '<S154>/Initial CPOS Min' incorporates:
       *  Constant: '<S154>/Constant'
       *  DataStoreRead: '<S154>/Data Store Read3'
       *  Sum: '<S154>/step inc'
       */
      InitialCPOSMin(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S133>/Merge' incorporates:
       *  Constant: '<S154>/Constant'
       *  Merge: '<S139>/Merge'
       *  SignalConversion generated from: '<S154>/step'
       *  Sum: '<S154>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S139>/If Action Subsystem' */
    } else {
      /* Outputs for IfAction SubSystem: '<S139>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S155>/Action Port'
       */
      /* BusCreator: '<S155>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S155>/Data Store Write'
       *  SignalConversion generated from: '<S155>/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: '<S155>/Bus Creator' */

      /* Merge: '<S133>/Merge' incorporates:
       *  Merge: '<S139>/Merge'
       *  SignalConversion generated from: '<S155>/stepIn1'
       */
      rtB.Merge = rtb_Switch_l5;

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

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

   case 3:
    /* Outputs for IfAction SubSystem: '<S133>/Normal Mode' incorporates:
     *  ActionPort: '<S142>/Action Port'
     */
    /* If: '<S142>/If1' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S142>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S163>/Action Port'
       */
      /* BusCreator: '<S163>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S163>/Data Store Write1'
       *  SignalConversion generated from: '<S163>/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: '<S163>/Bus Creator' */

      /* MATLAB Function: '<S163>/Normal Mode' incorporates:
       *  Constant: '<S163>/Constant'
       *  DataStoreRead: '<S163>/Data Store Read3'
       *  Sum: '<S163>/step inc'
       */
      NormalMode(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

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

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

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

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

   case 4:
    /* Outputs for IfAction SubSystem: '<S133>/Move to position Min' incorporates:
     *  ActionPort: '<S141>/Action Port'
     */
    /* If: '<S141>/If1' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S141>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S160>/Action Port'
       */
      /* BusCreator: '<S160>/Bus Creator' incorporates:
       *  Constant: '<S160>/Constant1'
       *  Constant: '<S160>/Constant10'
       *  Constant: '<S160>/Constant11'
       *  Constant: '<S160>/Constant14'
       *  Constant: '<S160>/Constant2'
       *  Constant: '<S160>/Constant9'
       *  DataStoreWrite: '<S160>/Data Store Write7'
       *  SignalConversion generated from: '<S160>/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: '<S160>/Bus Creator' */

      /* MATLAB Function: '<S160>/Move to position Min' incorporates:
       *  Constant: '<S160>/Constant'
       *  DataStoreRead: '<S160>/Data Store Read3'
       *  Sum: '<S160>/step inc'
       */
      MovetopositionMin(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

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

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

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

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

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

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

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

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

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

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

    /* If: '<S137>/If2' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     *  DataTypeConversion: '<S137>/Data Type Conversion'
     *  DataTypeConversion: '<S137>/Data Type Conversion1'
     *  Logic: '<S137>/Logical Operator'
     *  Logic: '<S137>/Logical Operator1'
     *  Logic: '<S137>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S137>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S148>/Action Port'
       */
      /* Merge: '<S133>/Merge' incorporates:
       *  Constant: '<S148>/Constant'
       *  Sum: '<S148>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S137>/If Action Subsystem2' */
      for (i = 0; i < 9; i++) {
        /* Outputs for IfAction SubSystem: '<S137>/If Action Subsystem2' incorporates:
         *  ActionPort: '<S148>/Action Port'
         */
        rtb_y_ey[i] = rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i];

        /* End of Outputs for SubSystem: '<S137>/If Action Subsystem2' */
      }

      /* Outputs for IfAction SubSystem: '<S137>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S148>/Action Port'
       */
      /* MATLAB Function: '<S148>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S148>/Data Store Read3'
       */
      MINPOSITION(rtb_y_ey, rtDW.LOGGER_LIN);

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

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

    /* End of If: '<S137>/If2' */
    /* End of Outputs for SubSystem: '<S133>/Check Stall Min' */
    break;

   case 6:
    /* Outputs for IfAction SubSystem: '<S133>/Initial CPOS Max' incorporates:
     *  ActionPort: '<S138>/Action Port'
     */
    /* If: '<S138>/If1' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S138>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S151>/Action Port'
       */
      /* BusCreator: '<S151>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S151>/Data Store Write2'
       *  SignalConversion generated from: '<S151>/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: '<S151>/Bus Creator' */

      /* MATLAB Function: '<S151>/Initial CPOS Max' incorporates:
       *  Constant: '<S151>/Constant'
       *  DataStoreRead: '<S151>/Data Store Read3'
       *  Sum: '<S151>/step inc'
       */
      InitialCPOSMax(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

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

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

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

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

   case 7:
    /* Outputs for IfAction SubSystem: '<S133>/Move to position Max' incorporates:
     *  ActionPort: '<S140>/Action Port'
     */
    /* If: '<S140>/If1' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S140>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S157>/Action Port'
       */
      /* BusCreator: '<S157>/Bus Creator' incorporates:
       *  Constant: '<S157>/Constant1'
       *  Constant: '<S157>/Constant10'
       *  Constant: '<S157>/Constant11'
       *  Constant: '<S157>/Constant14'
       *  Constant: '<S157>/Constant2'
       *  Constant: '<S157>/Constant9'
       *  DataStoreWrite: '<S157>/Data Store Write7'
       *  SignalConversion generated from: '<S157>/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: '<S157>/Bus Creator' */

      /* MATLAB Function: '<S157>/Move to position Max' incorporates:
       *  Constant: '<S157>/Constant'
       *  DataStoreRead: '<S157>/Data Store Read3'
       *  Sum: '<S157>/step inc'
       */
      MovetopositionMax((int8_t)(rtb_Switch_l5 + 1), rtDW.LOGGER_LIN, &rtb_y_fb);

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

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

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

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

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

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

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

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

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

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

    /* If: '<S136>/If2' incorporates:
     *  DataStoreRead: '<S133>/Data Store Read1'
     *  DataStoreWrite: '<S133>/Data Store Write'
     *  DataStoreWrite: '<S133>/Data Store Write1'
     *  DataTypeConversion: '<S136>/Data Type Conversion'
     *  DataTypeConversion: '<S136>/Data Type Conversion1'
     *  Logic: '<S136>/Logical Operator'
     *  Logic: '<S136>/Logical Operator1'
     *  Logic: '<S136>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch0_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch0_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S136>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S145>/Action Port'
       */
      /* Merge: '<S133>/Merge' incorporates:
       *  Constant: '<S145>/Constant'
       *  Sum: '<S145>/step inc'
       */
      rtB.Merge = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S136>/If Action Subsystem2' */
      for (i = 0; i < 9; i++) {
        /* Outputs for IfAction SubSystem: '<S136>/If Action Subsystem2' incorporates:
         *  ActionPort: '<S145>/Action Port'
         */
        rtb_y_ey[i] = rtDW.Actuator_Ch0_Status_Model.in_CPOS_ALL[i];

        /* End of Outputs for SubSystem: '<S136>/If Action Subsystem2' */
      }

      /* Outputs for IfAction SubSystem: '<S136>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S145>/Action Port'
       */
      /* MATLAB Function: '<S145>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S145>/Data Store Read3'
       */
      MINPOSITION_g(rtb_y_ey, rtDW.LOGGER_LIN);

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

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

    /* End of If: '<S136>/If2' */
    /* End of Outputs for SubSystem: '<S133>/Check Stall Max' */
    break;

   case 9:
    break;
  }

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

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

  /* MATLAB Function: '<S133>/Write Ignition' incorporates:
   *  DataStoreRead: '<S133>/Data Store Read3'
   */
  WriteIgnition(rtDW.LOGGER_LIN, rtb_Switch_l5);

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

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

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

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

      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S198>/Constant'
       *  Sum: '<S198>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S175>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S175>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S199>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

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

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

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

      /* MATLAB Function: '<S186>/Initial CPOS Min' incorporates:
       *  Constant: '<S186>/Constant'
       *  DataStoreRead: '<S186>/Data Store Read3'
       *  Sum: '<S186>/step inc'
       */
      InitialCPOSMin(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S186>/Constant'
       *  Merge: '<S171>/Merge'
       *  SignalConversion generated from: '<S186>/step'
       *  Sum: '<S186>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

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

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

      /* Merge: '<S134>/Merge' incorporates:
       *  Merge: '<S171>/Merge'
       *  SignalConversion generated from: '<S187>/stepIn1'
       */
      rtB.Merge_c = rtb_Switch_l5;

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

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

   case 3:
    /* Outputs for IfAction SubSystem: '<S134>/Normal Mode' incorporates:
     *  ActionPort: '<S174>/Action Port'
     */
    /* If: '<S174>/If1' incorporates:
     *  DataStoreRead: '<S134>/Data Store Read1'
     *  DataStoreWrite: '<S134>/Data Store Write'
     *  DataStoreWrite: '<S134>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S174>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S195>/Action Port'
       */
      /* BusCreator: '<S195>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S195>/Data Store Write1'
       *  SignalConversion generated from: '<S195>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch1_Command_Model.POS[i] = 0U;
        Actuator_Ch1_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch1_Command_Model.MODE[i] = 0U;
        Actuator_Ch1_Command_Model.COM[i] = 1U;
        Actuator_Ch1_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch1_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch1_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch1_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch1_Command_Model.Coils_Stop_SET[i] = 0U;
      }

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

      /* MATLAB Function: '<S195>/Normal Mode' incorporates:
       *  Constant: '<S195>/Constant'
       *  DataStoreRead: '<S195>/Data Store Read3'
       *  Sum: '<S195>/step inc'
       */
      NormalMode(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S195>/Constant'
       *  SignalConversion generated from: '<S195>/step'
       *  Sum: '<S195>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S174>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S174>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S196>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

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

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

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

      /* MATLAB Function: '<S192>/Move to position Min' incorporates:
       *  Constant: '<S192>/Constant'
       *  DataStoreRead: '<S192>/Data Store Read3'
       *  Sum: '<S192>/step inc'
       */
      MovetopositionMin(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S192>/Constant'
       *  SignalConversion generated from: '<S192>/step'
       *  Sum: '<S192>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S173>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S173>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S193>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

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

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

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

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

    /* RelationalOperator: '<S169>/Relational Operator' incorporates:
     *  DataStoreRead: '<S134>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 1);
    }

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

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

    /* If: '<S169>/If2' incorporates:
     *  DataStoreRead: '<S134>/Data Store Read1'
     *  DataStoreWrite: '<S134>/Data Store Write'
     *  DataStoreWrite: '<S134>/Data Store Write1'
     *  DataTypeConversion: '<S169>/Data Type Conversion'
     *  DataTypeConversion: '<S169>/Data Type Conversion1'
     *  Logic: '<S169>/Logical Operator'
     *  Logic: '<S169>/Logical Operator1'
     *  Logic: '<S169>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S169>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S180>/Action Port'
       */
      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S180>/Constant'
       *  Sum: '<S180>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S169>/If Action Subsystem2' */
      for (i = 0; i < 9; i++) {
        /* Outputs for IfAction SubSystem: '<S169>/If Action Subsystem2' incorporates:
         *  ActionPort: '<S180>/Action Port'
         */
        rtb_y_ey[i] = rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i];

        /* End of Outputs for SubSystem: '<S169>/If Action Subsystem2' */
      }

      /* Outputs for IfAction SubSystem: '<S169>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S180>/Action Port'
       */
      /* MATLAB Function: '<S180>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S180>/Data Store Read3'
       */
      MINPOSITION(rtb_y_ey, rtDW.LOGGER_LIN);

      /* End of Outputs for SubSystem: '<S169>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S169>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S181>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

    /* End of If: '<S169>/If2' */
    /* End of Outputs for SubSystem: '<S134>/Check Stall Min' */
    break;

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

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

      /* MATLAB Function: '<S183>/Initial CPOS Max' incorporates:
       *  Constant: '<S183>/Constant'
       *  DataStoreRead: '<S183>/Data Store Read3'
       *  Sum: '<S183>/step inc'
       */
      InitialCPOSMax(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S183>/Constant'
       *  SignalConversion generated from: '<S183>/step'
       *  Sum: '<S183>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S170>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S170>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S184>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

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

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

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

      /* MATLAB Function: '<S189>/Move to position Max' incorporates:
       *  Constant: '<S189>/Constant'
       *  DataStoreRead: '<S189>/Data Store Read3'
       *  Sum: '<S189>/step inc'
       */
      MovetopositionMax((int8_t)(rtb_Switch_l5 + 1), rtDW.LOGGER_LIN, &rtb_y_fb);

      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S189>/Constant'
       *  SignalConversion generated from: '<S189>/step'
       *  Sum: '<S189>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S172>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S172>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S190>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

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

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

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

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

    /* RelationalOperator: '<S168>/Relational Operator' incorporates:
     *  DataStoreRead: '<S134>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i] == 6000);
    }

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

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

    /* If: '<S168>/If2' incorporates:
     *  DataStoreRead: '<S134>/Data Store Read1'
     *  DataStoreWrite: '<S134>/Data Store Write'
     *  DataStoreWrite: '<S134>/Data Store Write1'
     *  DataTypeConversion: '<S168>/Data Type Conversion'
     *  DataTypeConversion: '<S168>/Data Type Conversion1'
     *  Logic: '<S168>/Logical Operator'
     *  Logic: '<S168>/Logical Operator1'
     *  Logic: '<S168>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch1_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch1_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S168>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S177>/Action Port'
       */
      /* Merge: '<S134>/Merge' incorporates:
       *  Constant: '<S177>/Constant'
       *  Sum: '<S177>/step inc'
       */
      rtB.Merge_c = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S168>/If Action Subsystem2' */
      for (i = 0; i < 9; i++) {
        /* Outputs for IfAction SubSystem: '<S168>/If Action Subsystem2' incorporates:
         *  ActionPort: '<S177>/Action Port'
         */
        rtb_y_ey[i] = rtDW.Actuator_Ch1_Status_Model.in_CPOS_ALL[i];

        /* End of Outputs for SubSystem: '<S168>/If Action Subsystem2' */
      }

      /* Outputs for IfAction SubSystem: '<S168>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S177>/Action Port'
       */
      /* MATLAB Function: '<S177>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S177>/Data Store Read3'
       */
      MINPOSITION_g(rtb_y_ey, rtDW.LOGGER_LIN);

      /* End of Outputs for SubSystem: '<S168>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S168>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S178>/Action Port'
       */
      IfActionSubsystem3_m(rtb_Switch_l5, &rtB.Merge_c);

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

    /* End of If: '<S168>/If2' */
    /* End of Outputs for SubSystem: '<S134>/Check Stall Max' */
    break;

   case 9:
    break;
  }

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

  /* DataStoreWrite: '<S134>/Finish write stepSig' */
  rtDW.stepSig_private_c = rtB.Merge_c;

  /* MATLAB Function: '<S134>/Write Ignition' incorporates:
   *  DataStoreRead: '<S134>/Data Store Read3'
   */
  WriteIgnition(rtDW.LOGGER_LIN, rtb_Switch_l5);

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

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

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

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

      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S232>/Constant'
       *  Sum: '<S232>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S207>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S207>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S233>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

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

   case 2:
    /* Outputs for IfAction SubSystem: '<S135>/Initial CPOS Min' incorporates:
     *  ActionPort: '<S203>/Action Port'
     */
    /* MATLAB Function: '<S203>/Write Ignition' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     *  DataStoreRead: '<S203>/Data Store Read3'
     *  DataStoreWrite: '<S135>/Data Store Write'
     */
    /* :  if(LOGGER) */
    if (rtDW.LOGGER_LIN != 0.0) {
      /* :  fprintf('LIN 3 busy = %u\n',step); */
      printf("LIN 3 busy = %u\n", rtDW.Actuator_Ch2_Status_Model.Busy);
      fflush(stdout);
    }

    /* End of MATLAB Function: '<S203>/Write Ignition' */

    /* MATLAB Function: '<S203>/Write Ignition1' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     *  DataStoreRead: '<S203>/Data Store Read2'
     *  DataStoreWrite: '<S135>/Data Store Write1'
     */
    /* :  if(LOGGER) */
    if (rtDW.LOGGER_LIN != 0.0) {
      /* :  fprintf('LIN 3 Error_Connect = %u\n',step); */
      printf("LIN 3 Error_Connect = %u\n",
             rtDW.Actuator_Ch2_Status_Model.Error_Connect);
      fflush(stdout);
    }

    /* End of MATLAB Function: '<S203>/Write Ignition1' */

    /* If: '<S203>/If' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     *  DataStoreWrite: '<S135>/Data Store Write'
     *  DataStoreWrite: '<S135>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S203>/If Action Subsystem' incorporates:
       *  ActionPort: '<S218>/Action Port'
       */
      /* BusCreator: '<S218>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S218>/Data Store Write2'
       *  SignalConversion generated from: '<S218>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch2_Command_Model.POS[i] = 6000U;
        Actuator_Ch2_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch2_Command_Model.MODE[i] = 0U;
        Actuator_Ch2_Command_Model.COM[i] = 2U;
        Actuator_Ch2_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Coils_Stop_SET[i] = 0U;
      }

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

      /* MATLAB Function: '<S218>/Initial CPOS Min' incorporates:
       *  DataStoreRead: '<S218>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER) */
      if (rtDW.LOGGER_LIN != 0.0) {
        /* :  fprintf('LIN 3 SIMULINK Initial CPOS Min - 6000\n'); */
        printf("LIN 3 SIMULINK Initial CPOS Min - 6000\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S218>/Initial CPOS Min' */

      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S218>/Constant'
       *  Merge: '<S203>/Merge'
       *  SignalConversion generated from: '<S218>/step'
       *  Sum: '<S218>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

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

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

      /* Merge: '<S135>/Merge' incorporates:
       *  Merge: '<S203>/Merge'
       *  SignalConversion generated from: '<S219>/stepIn1'
       */
      rtB.Merge_cs = rtb_Switch_l5;

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

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

   case 3:
    /* Outputs for IfAction SubSystem: '<S135>/Normal Mode' incorporates:
     *  ActionPort: '<S206>/Action Port'
     */
    /* If: '<S206>/If1' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     *  DataStoreWrite: '<S135>/Data Store Write'
     *  DataStoreWrite: '<S135>/Data Store Write1'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0)) {
      /* Outputs for IfAction SubSystem: '<S206>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S229>/Action Port'
       */
      /* BusCreator: '<S229>/Bus Creator' incorporates:
       *  DataStoreWrite: '<S229>/Data Store Write1'
       *  SignalConversion generated from: '<S229>/Bus Creator'
       * */
      for (i = 0; i < 9; i++) {
        Actuator_Ch2_Command_Model.POS[i] = 0U;
        Actuator_Ch2_Command_Model.BUS_ADR[i] = 0U;
        Actuator_Ch2_Command_Model.MODE[i] = 0U;
        Actuator_Ch2_Command_Model.COM[i] = 1U;
        Actuator_Ch2_Command_Model.Stall_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Lnoise_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Autos_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Speed_SET[i] = 0U;
        Actuator_Ch2_Command_Model.Coils_Stop_SET[i] = 0U;
      }

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

      /* MATLAB Function: '<S229>/Normal Mode' incorporates:
       *  DataStoreRead: '<S229>/Data Store Read3'
       */
      /* :  y = step; */
      /* :  if(LOGGER) */
      if (rtDW.LOGGER_LIN != 0.0) {
        /* :  fprintf('LIN 3 SIMULINK Normal Mode\n'); */
        printf("LIN 3 SIMULINK Normal Mode\n");
        fflush(stdout);
      }

      /* End of MATLAB Function: '<S229>/Normal Mode' */

      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S229>/Constant'
       *  SignalConversion generated from: '<S229>/step'
       *  Sum: '<S229>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S206>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S206>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S230>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

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

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

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

      /* MATLAB Function: '<S226>/Move to position Min' incorporates:
       *  Constant: '<S226>/Constant'
       *  DataStoreRead: '<S226>/Data Store Read3'
       *  Sum: '<S226>/step inc'
       */
      MovetopositionMin(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S226>/Constant'
       *  SignalConversion generated from: '<S226>/step'
       *  Sum: '<S226>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S205>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S205>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S227>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

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

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

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

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

    /* RelationalOperator: '<S201>/Relational Operator' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 1);
    }

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

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

    /* If: '<S201>/If2' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     *  DataStoreWrite: '<S135>/Data Store Write'
     *  DataStoreWrite: '<S135>/Data Store Write1'
     *  DataTypeConversion: '<S201>/Data Type Conversion'
     *  DataTypeConversion: '<S201>/Data Type Conversion1'
     *  Logic: '<S201>/Logical Operator'
     *  Logic: '<S201>/Logical Operator1'
     *  Logic: '<S201>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S201>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S212>/Action Port'
       */
      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S212>/Constant'
       *  Sum: '<S212>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S201>/If Action Subsystem2' */
      for (i = 0; i < 9; i++) {
        /* Outputs for IfAction SubSystem: '<S201>/If Action Subsystem2' incorporates:
         *  ActionPort: '<S212>/Action Port'
         */
        rtb_y_ey[i] = rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i];

        /* End of Outputs for SubSystem: '<S201>/If Action Subsystem2' */
      }

      /* Outputs for IfAction SubSystem: '<S201>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S212>/Action Port'
       */
      /* MATLAB Function: '<S212>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S212>/Data Store Read3'
       */
      MINPOSITION(rtb_y_ey, rtDW.LOGGER_LIN);

      /* End of Outputs for SubSystem: '<S201>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S201>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S213>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

    /* End of If: '<S201>/If2' */
    /* End of Outputs for SubSystem: '<S135>/Check Stall Min' */
    break;

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

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

      /* MATLAB Function: '<S215>/Initial CPOS Max' incorporates:
       *  Constant: '<S215>/Constant'
       *  DataStoreRead: '<S215>/Data Store Read3'
       *  Sum: '<S215>/step inc'
       */
      InitialCPOSMax(rtDW.LOGGER_LIN, (int8_t)(rtb_Switch_l5 + 1), &rtb_y_fb);

      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S215>/Constant'
       *  SignalConversion generated from: '<S215>/step'
       *  Sum: '<S215>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S202>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S202>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S216>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

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

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

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

      /* MATLAB Function: '<S223>/Move to position Max' incorporates:
       *  Constant: '<S223>/Constant'
       *  DataStoreRead: '<S223>/Data Store Read3'
       *  Sum: '<S223>/step inc'
       */
      MovetopositionMax((int8_t)(rtb_Switch_l5 + 1), rtDW.LOGGER_LIN, &rtb_y_fb);

      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S223>/Constant'
       *  SignalConversion generated from: '<S223>/step'
       *  Sum: '<S223>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S204>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S204>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S224>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

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

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

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

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

    /* RelationalOperator: '<S200>/Relational Operator' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     */
    for (i = 0; i < 9; i++) {
      rtb_RelationalOperator_j[i] =
        (rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i] == 6000);
    }

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

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

    /* If: '<S200>/If2' incorporates:
     *  DataStoreRead: '<S135>/Data Store Read1'
     *  DataStoreWrite: '<S135>/Data Store Write'
     *  DataStoreWrite: '<S135>/Data Store Write1'
     *  DataTypeConversion: '<S200>/Data Type Conversion'
     *  DataTypeConversion: '<S200>/Data Type Conversion1'
     *  Logic: '<S200>/Logical Operator'
     *  Logic: '<S200>/Logical Operator1'
     *  Logic: '<S200>/Logical Operator2'
     */
    if ((rtDW.Actuator_Ch2_Status_Model.Busy == 0) &&
        (rtDW.Actuator_Ch2_Status_Model.Error_Connect == 0) &&
        (rtb_LogicalOperator1 || rtb_LogicalOperator1_f)) {
      /* Outputs for IfAction SubSystem: '<S200>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S209>/Action Port'
       */
      /* Merge: '<S135>/Merge' incorporates:
       *  Constant: '<S209>/Constant'
       *  Sum: '<S209>/step inc'
       */
      rtB.Merge_cs = (int8_t)(rtb_Switch_l5 + 1);

      /* End of Outputs for SubSystem: '<S200>/If Action Subsystem2' */
      for (i = 0; i < 9; i++) {
        /* Outputs for IfAction SubSystem: '<S200>/If Action Subsystem2' incorporates:
         *  ActionPort: '<S209>/Action Port'
         */
        rtb_y_ey[i] = rtDW.Actuator_Ch2_Status_Model.in_CPOS_ALL[i];

        /* End of Outputs for SubSystem: '<S200>/If Action Subsystem2' */
      }

      /* Outputs for IfAction SubSystem: '<S200>/If Action Subsystem2' incorporates:
       *  ActionPort: '<S209>/Action Port'
       */
      /* MATLAB Function: '<S209>/MIN POSITION' incorporates:
       *  DataStoreRead: '<S209>/Data Store Read3'
       */
      MINPOSITION_g(rtb_y_ey, rtDW.LOGGER_LIN);

      /* End of Outputs for SubSystem: '<S200>/If Action Subsystem2' */
    } else {
      /* Outputs for IfAction SubSystem: '<S200>/If Action Subsystem3' incorporates:
       *  ActionPort: '<S210>/Action Port'
       */
      IfActionSubsystem3_n(rtb_Switch_l5, &rtB.Merge_cs);

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

    /* End of If: '<S200>/If2' */
    /* End of Outputs for SubSystem: '<S135>/Check Stall Max' */
    break;

   case 9:
    break;
  }

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

  /* Outport: '<Root>/Out1' incorporates:
   *  DataStoreRead: '<Root>/Data Store Read10'
   */
  rtY.Out1 = CCU_Errors_Model;

  /* DataStoreWrite: '<S135>/Finish write stepSig' */
  rtDW.stepSig_private_p = rtB.Merge_cs;

  /* MATLAB Function: '<S135>/Write Ignition' incorporates:
   *  DataStoreRead: '<S135>/Data Store Read3'
   */
  /* :  if(LOGGER) */
  if (rtDW.LOGGER_LIN != 0.0) {
    /* :  fprintf('LIN 3 step = %d\n',step); */
    printf("LIN 3 step = %d\n", rtb_Switch_l5);
    fflush(stdout);
  }

  /* End of MATLAB Function: '<S135>/Write Ignition' */

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

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

  /* Update for UnitDelay: '<S56>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_h = rtb_FailCond_f;

  /* Update for UnitDelay: '<S63>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_i = rtb_FailCond_g;

  /* Update for UnitDelay: '<S85>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_e = rtb_FailCond_mg;

  /* Update for UnitDelay: '<S111>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_c = rtb_FailCond_e;

  /* Update for UnitDelay: '<S112>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_b = rtb_FailCond_a;

  /* Update for UnitDelay: '<S125>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_j = rtb_FailCond_l;

  /* Update for UnitDelay: '<S126>/Cond_prev_private ' */
  rtDW.Cond_prev_private_DSTATE_f = rtb_FailCond_b;
}

/* 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]
 */