/*
 * Academic License - for use in teaching, academic research, and meeting
 * course requirements at degree granting institutions only.  Not for
 * government, commercial, or other organizational use.
 *
 * File: ADM_Integrated_Logic.c
 *
 * Code generated for Simulink model 'ADM_Integrated_Logic'.
 *
 * Model version                  : 14.109
 * Simulink Coder version         : 24.2 (R2024b) 21-Jun-2024
 * C/C++ source code generated on : Tue Jan  6 11:24:27 2026
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: NXP->Cortex-M4
 * Code generation objectives:
 *    1. Execution efficiency
 *    2. RAM efficiency
 *    3. Debugging
 * Validation result: Not run
 */

#include "ADM_Integrated_Logic.h"
#include <stdint.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>

/* Named constants for Chart: '<S11>/Chart' */
#define IN_HAC_OFF                     ((uint8_t)1U)
#define IN_HAC_ON                      ((uint8_t)2U)
#define NumBitsPerChar                 8U

/* Block signals and states (default storage) */
DW_ADM_Integrated_Logic_T ADM_Integrated_Logic_DW;

/* External inputs (root inport signals with default storage) */
ExtU_ADM_Integrated_Logic_T ADM_Integrated_Logic_U;

/* External outputs (root outports fed by signals with default storage) */
ExtY_ADM_Integrated_Logic_T ADM_Integrated_Logic_Y;

/* Real-time model */
static RT_MODEL_ADM_Integrated_Logic_T ADM_Integrated_Logic_M_;
RT_MODEL_ADM_Integrated_Logic_T *const ADM_Integrated_Logic_M =
  &ADM_Integrated_Logic_M_;
static void ADM_Integrated_Lo_Calculate_F_R(double rtu_C_r, double rtu_W, double
  rtu_theta, double *rty_F_R);
static void ADM_Integrated_Lo_Calculate_F_c(double rtu_W, double rtu_theta,
  double *rty_F_c);
static void ADM_Integrated__MATLABFunction1(double rtu_u, double *rty_y);
static void ADM_Integrated__MATLABFunction2(double rtu_u, double *rty_y);

#define NOT_USING_NONFINITE_LITERALS   1

extern double rtInf;
extern double rtMinusInf;
extern double rtNaN;
extern float rtInfF;
extern float rtMinusInfF;
extern float rtNaNF;
static void rt_InitInfAndNaN(size_t realSize);
static bool rtIsInf(double value);
static bool rtIsInfF(float value);
static bool rtIsNaN(double value);
static bool rtIsNaNF(float value);
typedef struct {
  struct {
    uint32_t wordH;
    uint32_t wordL;
  } words;
} BigEndianIEEEDouble;

typedef struct {
  struct {
    uint32_t wordL;
    uint32_t wordH;
  } words;
} LittleEndianIEEEDouble;

typedef struct {
  union {
    float wordLreal;
    uint32_t wordLuint;
  } wordL;
} IEEESingle;

double rtInf;
double rtMinusInf;
double rtNaN;
float rtInfF;
float rtMinusInfF;
float rtNaNF;
static double rtGetInf(void);
static float rtGetInfF(void);
static double rtGetMinusInf(void);
static float rtGetMinusInfF(void);
static double rtGetNaN(void);
static float rtGetNaNF(void);

/*
 * Initialize the rtInf, rtMinusInf, and rtNaN needed by the
 * generated code. NaN is initialized as non-signaling. Assumes IEEE.
 */
static void rt_InitInfAndNaN(size_t realSize)
{
  (void) (realSize);
  rtNaN = rtGetNaN();
  rtNaNF = rtGetNaNF();
  rtInf = rtGetInf();
  rtInfF = rtGetInfF();
  rtMinusInf = rtGetMinusInf();
  rtMinusInfF = rtGetMinusInfF();
}

/* Test if value is infinite */
static bool rtIsInf(double value)
{
  return (bool)((value==rtInf || value==rtMinusInf) ? 1U : 0U);
}

/* Test if single-precision value is infinite */
static bool rtIsInfF(float value)
{
  return (bool)(((value)==rtInfF || (value)==rtMinusInfF) ? 1U : 0U);
}

/* Test if value is not a number */
static bool rtIsNaN(double value)
{
  bool result = (bool) 0;
  size_t bitsPerReal = sizeof(double) * (NumBitsPerChar);
  if (bitsPerReal == 32U) {
    result = rtIsNaNF((float)value);
  } else {
    union {
      LittleEndianIEEEDouble bitVal;
      double fltVal;
    } tmpVal;

    tmpVal.fltVal = value;
    result = (bool)((tmpVal.bitVal.words.wordH & 0x7FF00000) == 0x7FF00000 &&
                    ( (tmpVal.bitVal.words.wordH & 0x000FFFFF) != 0 ||
                     (tmpVal.bitVal.words.wordL != 0) ));
  }

  return result;
}

/* Test if single-precision value is not a number */
static bool rtIsNaNF(float value)
{
  IEEESingle tmp;
  tmp.wordL.wordLreal = value;
  return (bool)( (tmp.wordL.wordLuint & 0x7F800000) == 0x7F800000 &&
                (tmp.wordL.wordLuint & 0x007FFFFF) != 0 );
}

/*
 * Initialize rtInf needed by the generated code.
 * Inf is initialized as non-signaling. Assumes IEEE.
 */
static double rtGetInf(void)
{
  size_t bitsPerReal = sizeof(double) * (NumBitsPerChar);
  double inf = 0.0;
  if (bitsPerReal == 32U) {
    inf = rtGetInfF();
  } else {
    union {
      LittleEndianIEEEDouble bitVal;
      double fltVal;
    } tmpVal;

    tmpVal.bitVal.words.wordH = 0x7FF00000U;
    tmpVal.bitVal.words.wordL = 0x00000000U;
    inf = tmpVal.fltVal;
  }

  return inf;
}

/*
 * Initialize rtInfF needed by the generated code.
 * Inf is initialized as non-signaling. Assumes IEEE.
 */
static float rtGetInfF(void)
{
  IEEESingle infF;
  infF.wordL.wordLuint = 0x7F800000U;
  return infF.wordL.wordLreal;
}

/*
 * Initialize rtMinusInf needed by the generated code.
 * Inf is initialized as non-signaling. Assumes IEEE.
 */
static double rtGetMinusInf(void)
{
  size_t bitsPerReal = sizeof(double) * (NumBitsPerChar);
  double minf = 0.0;
  if (bitsPerReal == 32U) {
    minf = rtGetMinusInfF();
  } else {
    union {
      LittleEndianIEEEDouble bitVal;
      double fltVal;
    } tmpVal;

    tmpVal.bitVal.words.wordH = 0xFFF00000U;
    tmpVal.bitVal.words.wordL = 0x00000000U;
    minf = tmpVal.fltVal;
  }

  return minf;
}

/*
 * Initialize rtMinusInfF needed by the generated code.
 * Inf is initialized as non-signaling. Assumes IEEE.
 */
static float rtGetMinusInfF(void)
{
  IEEESingle minfF;
  minfF.wordL.wordLuint = 0xFF800000U;
  return minfF.wordL.wordLreal;
}

/*
 * Initialize rtNaN needed by the generated code.
 * NaN is initialized as non-signaling. Assumes IEEE.
 */
static double rtGetNaN(void)
{
  size_t bitsPerReal = sizeof(double) * (NumBitsPerChar);
  double nan = 0.0;
  if (bitsPerReal == 32U) {
    nan = rtGetNaNF();
  } else {
    union {
      LittleEndianIEEEDouble bitVal;
      double fltVal;
    } tmpVal;

    tmpVal.bitVal.words.wordH = 0xFFF80000U;
    tmpVal.bitVal.words.wordL = 0x00000000U;
    nan = tmpVal.fltVal;
  }

  return nan;
}

/*
 * Initialize rtNaNF needed by the generated code.
 * NaN is initialized as non-signaling. Assumes IEEE.
 */
static float rtGetNaNF(void)
{
  IEEESingle nanF = { { 0.0F } };

  nanF.wordL.wordLuint = 0xFFC00000U;
  return nanF.wordL.wordLreal;
}

/*
 * Output and update for atomic system:
 *    '<S41>/Calculate_F_R'
 *    '<S63>/Calculate_F_R'
 */
static void ADM_Integrated_Lo_Calculate_F_R(double rtu_C_r, double rtu_W, double
  rtu_theta, double *rty_F_R)
{
  *rty_F_R = rtu_C_r * rtu_W * cos(rtu_theta);
}

/*
 * Output and update for atomic system:
 *    '<S41>/Calculate_F_c'
 *    '<S63>/Calculate_F_c'
 *    '<S63>/Calculate_F_c1'
 */
static void ADM_Integrated_Lo_Calculate_F_c(double rtu_W, double rtu_theta,
  double *rty_F_c)
{
  *rty_F_c = rtu_W * sin(rtu_theta);
}

/*
 * Output and update for atomic system:
 *    '<S1>/MATLAB Function1'
 *    '<S1>/MATLAB Function5'
 */
static void ADM_Integrated__MATLABFunction1(double rtu_u, double *rty_y)
{
  *rty_y = rtu_u;
  if (rtu_u < 140.0) {
    *rty_y = 140.0;
  }
}

/*
 * Output and update for atomic system:
 *    '<S1>/MATLAB Function2'
 *    '<S1>/MATLAB Function6'
 */
static void ADM_Integrated__MATLABFunction2(double rtu_u, double *rty_y)
{
  *rty_y = rtu_u;
  if (rtu_u > -140.0) {
    *rty_y = -140.0;
  }
}

/* Model step function */
void ADM_Integrated_Logic_step(void)
{
  double tmp[9];
  double x_hat_pred[3];
  double tmp_0[2];
  double tmp_1[2];
  double DiscreteTransferFcn;
  double e_off;
  double rtb_AccFlag;
  double rtb_Add;
  double rtb_Add3;
  double rtb_Brake_Control;
  double rtb_Brake_Torque_Cmd;
  double rtb_Desired_Torque;
  double rtb_Error_m;
  double rtb_Gain_c;
  double rtb_Integrator_1;
  double rtb_Memory;
  double rtb_Pitch_Angle;
  double rtb_Product1;
  double rtb_Product1_h;
  double rtb_Product1_k3;
  double rtb_Product1_m;
  double rtb_Product1_pd;
  double rtb_Product2_a;
  double rtb_Product_h;
  double rtb_Saturation;
  double rtb_Sum1_aj;
  double rtb_Sum1_i2;
  double rtb_Sum1_lm;
  double rtb_Sum1_o1;
  double rtb_Sum1_p;
  double rtb_Switch2_k;
  double rtb_TSamp;
  double rtb_Target_RPM;
  double rtb_Vx_Cmd_R;
  double rtb_dVx;
  double rtb_y;
  double rtb_y_k;
  int32_t i;
  bool rtb_Compare_l;
  bool rtb_Compare_p;
  static const int8_t a[6] = { 1, 0, 0, 1, 0, 0 };

  static const double b_a[6] = { 0.2997, 0.0, -0.0842, 0.01, 0.9981, 0.0 };

  /* Product: '<S13>/Product1' incorporates:
   *  Constant: '<S13>/Constant'
   *  Gain: '<S13>/gain'
   *  Inport: '<Root>/GV_IMU_AX_Val'
   *  Product: '<S13>/Product11'
   *  Sum: '<S13>/Sum1'
   *  Sum: '<S13>/Sum2'
   *  Sum: '<S13>/Sum3'
   *  Sum: '<S13>/Sum4'
   *  UnitDelay: '<S13>/d'
   *  UnitDelay: '<S13>/d1'
   */
  rtb_Product1 = ((ADM_Integrated_Logic_U.GV_IMU_AX_Val +
                   ADM_Integrated_Logic_DW.d1_DSTATE) * 0.002 +
                  0.63461977236758138 * ADM_Integrated_Logic_DW.d_DSTATE) /
    0.63861977236758138;

  /* MATLAB Function: '<S1>/MATLAB Function' incorporates:
   *  Constant: '<S1>/Constant1'
   *  Constant: '<S1>/Constant2'
   */
  tmp[0] = 1.0;
  tmp[3] = 0.002;
  tmp[6] = -0.019620000000000002;
  tmp[1] = 0.0;
  tmp[2] = 0.0;
  tmp[4] = 1.0;
  tmp[5] = 0.0;
  tmp[7] = 0.0;
  tmp[8] = 1.0;
  rtb_Pitch_Angle = ADM_Integrated_Logic_DW.x_hat[1];
  rtb_AccFlag = ADM_Integrated_Logic_DW.x_hat[0];
  rtb_Vx_Cmd_R = ADM_Integrated_Logic_DW.x_hat[2];
  for (i = 0; i < 3; i++) {
    x_hat_pred[i] = (tmp[i + 3] * rtb_Pitch_Angle + tmp[i] * rtb_AccFlag) +
      tmp[i + 6] * rtb_Vx_Cmd_R;
  }

  /* SignalConversion generated from: '<S14>/ SFunction ' incorporates:
   *  Inport: '<Root>/GV_Vx_Fbk'
   *  MATLAB Function: '<S1>/MATLAB Function'
   */
  tmp_0[0] = ADM_Integrated_Logic_U.GV_Vx_Fbk;
  tmp_0[1] = rtb_Product1;

  /* MATLAB Function: '<S1>/MATLAB Function' */
  rtb_Pitch_Angle = x_hat_pred[1];
  rtb_AccFlag = x_hat_pred[0];
  rtb_Vx_Cmd_R = x_hat_pred[2];
  for (i = 0; i < 2; i++) {
    tmp_1[i] = tmp_0[i] - (((double)a[i + 2] * rtb_Pitch_Angle + (double)a[i] *
      rtb_AccFlag) + 0.0 * rtb_Vx_Cmd_R);
  }

  rtb_Add = tmp_1[1];
  rtb_Pitch_Angle = tmp_1[0];
  for (i = 0; i < 3; i++) {
    ADM_Integrated_Logic_DW.x_hat[i] = (b_a[i + 3] * rtb_Add + b_a[i] *
      rtb_Pitch_Angle) + x_hat_pred[i];
  }

  /* RelationalOperator: '<S5>/Compare' incorporates:
   *  Constant: '<S5>/Constant'
   *  Inport: '<Root>/GV_Drive_Mode'
   */
  rtb_Compare_l = (ADM_Integrated_Logic_U.GV_Drive_Mode == 2.0);

  /* MATLAB Function: '<S25>/Vx_OutPut_Function' incorporates:
   *  Constant: '<S78>/Constant'
   *  Inport: '<Root>/GV_BrakeTorqueCommand'
   *  Inport: '<Root>/GV_Vx_Command'
   *  Inport: '<Root>/GV_Vx_Limit'
   *  RelationalOperator: '<S78>/Compare'
   */
  if (!(ADM_Integrated_Logic_U.GV_BrakeTorqueCommand >= 50.0)) {
    if (ADM_Integrated_Logic_U.GV_Vx_Limit <=
        ADM_Integrated_Logic_U.GV_Vx_Command) {
      rtb_Add = ADM_Integrated_Logic_U.GV_Vx_Limit;
    } else {
      rtb_Add = ADM_Integrated_Logic_U.GV_Vx_Command;
    }
  } else {
    rtb_Add = 0.0;
  }

  /* Product: '<S25>/Product' incorporates:
   *  MATLAB Function: '<S25>/Vx_OutPut_Function'
   *  Switch: '<S25>/Switch'
   */
  rtb_Pitch_Angle = rtb_Add * (double)!rtb_Compare_l;

  /* RateLimiter: '<S25>/Input_Vx_RateLimiter' */
  rtb_AccFlag = rtb_Pitch_Angle - ADM_Integrated_Logic_DW.PrevY;
  if (rtb_AccFlag > 0.004) {
    rtb_Vx_Cmd_R = ADM_Integrated_Logic_DW.PrevY + 0.004;
  } else if (rtb_AccFlag < -0.008) {
    rtb_Vx_Cmd_R = ADM_Integrated_Logic_DW.PrevY - 0.008;
  } else {
    rtb_Vx_Cmd_R = rtb_Pitch_Angle;
  }

  ADM_Integrated_Logic_DW.PrevY = rtb_Vx_Cmd_R;

  /* End of RateLimiter: '<S25>/Input_Vx_RateLimiter' */

  /* Saturate: '<S11>/Pitch_Saturation' incorporates:
   *  DiscreteIntegrator: '<S11>/Integrator_2'
   */
  if (ADM_Integrated_Logic_DW.Integrator_2_DSTATE > 8.0) {
    rtb_Pitch_Angle = 8.0;
  } else if (ADM_Integrated_Logic_DW.Integrator_2_DSTATE < -8.0) {
    rtb_Pitch_Angle = -8.0;
  } else {
    rtb_Pitch_Angle = ADM_Integrated_Logic_DW.Integrator_2_DSTATE;
  }

  /* End of Saturate: '<S11>/Pitch_Saturation' */

  /* Delay: '<S70>/Delay' */
  if (ADM_Integrated_Logic_DW.icLoad) {
    ADM_Integrated_Logic_DW.Delay_DSTATE = rtb_Pitch_Angle;
  }

  /* Product: '<S70>/delta rise limit' incorporates:
   *  Constant: '<S11>/Angle_Upper'
   *  SampleTimeMath: '<S70>/sample time'
   *
   * About '<S70>/sample time':
   *  y = K where K = ( w * Ts )
   *   */
  rtb_Product2_a = 0.002;

  /* Sum: '<S70>/Difference Inputs1' incorporates:
   *  Delay: '<S70>/Delay'
   *
   * Block description for '<S70>/Difference Inputs1':
   *
   *  Add in CPU
   */
  rtb_Pitch_Angle -= ADM_Integrated_Logic_DW.Delay_DSTATE;

  /* Switch: '<S75>/Switch2' incorporates:
   *  RelationalOperator: '<S75>/LowerRelop1'
   */
  if (!(rtb_Pitch_Angle > 0.002)) {
    /* Switch: '<S75>/Switch' incorporates:
     *  RelationalOperator: '<S75>/UpperRelop'
     */
    if (rtb_Pitch_Angle < -0.002) {
      rtb_Product2_a = -0.002;
    } else {
      rtb_Product2_a = rtb_Pitch_Angle;
    }

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

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

  /* Sum: '<S70>/Difference Inputs2' incorporates:
   *  Delay: '<S70>/Delay'
   *
   * Block description for '<S70>/Difference Inputs2':
   *
   *  Add in CPU
   */
  rtb_Pitch_Angle = rtb_Product2_a + ADM_Integrated_Logic_DW.Delay_DSTATE;

  /* MATLAB Function: '<S63>/Calculate_F_c' incorporates:
   *  Gain: '<S63>/Gain'
   */
  ADM_Integrated_Lo_Calculate_F_c(ADM_Integrated_Logic_ConstB.W_value_m,
    0.017453292519943295 * rtb_Pitch_Angle, &rtb_Product2_a);

  /* MATLAB Function: '<S63>/Calculate_F_R' incorporates:
   *  Gain: '<S63>/Gain1'
   */
  ADM_Integrated_Lo_Calculate_F_R(ADM_Integrated_Logic_ConstB.Multiply1_i,
    ADM_Integrated_Logic_ConstB.Multiply2_f, 0.017453292519943295 *
    rtb_Pitch_Angle, &rtb_Integrator_1);

  /* Gain: '<S63>/Gain2' incorporates:
   *  Constant: '<S63>/Radius'
   *  Gain: '<S63>/Rolling_Gain'
   *  Product: '<S63>/Multiply3'
   *  Sum: '<S63>/Required_Brake_Cal'
   */
  rtb_Saturation = (0.0 * rtb_Integrator_1 + rtb_Product2_a) * 0.292 *
    0.083822296730930432;

  /* Saturate: '<S63>/Saturation' */
  if (rtb_Saturation > 60.0) {
    rtb_Saturation = 60.0;
  } else if (rtb_Saturation < 0.0) {
    rtb_Saturation = 0.0;
  }

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

  /* Delay: '<S69>/Delay' */
  if (ADM_Integrated_Logic_DW.icLoad_e) {
    ADM_Integrated_Logic_DW.Delay_DSTATE_i = rtb_Saturation;
  }

  /* Product: '<S69>/delta rise limit' incorporates:
   *  Constant: '<S11>/Upper_Torq'
   *  SampleTimeMath: '<S69>/sample time'
   *
   * About '<S69>/sample time':
   *  y = K where K = ( w * Ts )
   *   */
  rtb_Product2_a = 0.016;

  /* Sum: '<S69>/Difference Inputs1' incorporates:
   *  Delay: '<S69>/Delay'
   *
   * Block description for '<S69>/Difference Inputs1':
   *
   *  Add in CPU
   */
  rtb_Saturation -= ADM_Integrated_Logic_DW.Delay_DSTATE_i;

  /* Switch: '<S74>/Switch2' incorporates:
   *  RelationalOperator: '<S74>/LowerRelop1'
   */
  if (!(rtb_Saturation > 0.016)) {
    /* Switch: '<S74>/Switch' incorporates:
     *  RelationalOperator: '<S74>/UpperRelop'
     */
    if (rtb_Saturation < -0.16) {
      rtb_Product2_a = -0.16;
    } else {
      rtb_Product2_a = rtb_Saturation;
    }

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

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

  /* Sum: '<S69>/Difference Inputs2' incorporates:
   *  Delay: '<S69>/Delay'
   *
   * Block description for '<S69>/Difference Inputs2':
   *
   *  Add in CPU
   */
  rtb_Saturation = rtb_Product2_a + ADM_Integrated_Logic_DW.Delay_DSTATE_i;

  /* Gain: '<S11>/Grade_GAIN' */
  rtb_Desired_Torque = 0.8 * rtb_Saturation;

  /* RelationalOperator: '<S59>/Compare' incorporates:
   *  Constant: '<S59>/Constant'
   *  Inport: '<Root>/GV_BrakeTorqueCommand'
   */
  rtb_Compare_p = (ADM_Integrated_Logic_U.GV_BrakeTorqueCommand >= 100.0);

  /* Delay: '<S10>/Memory' */
  rtb_Memory = ADM_Integrated_Logic_DW.Memory_DSTATE;

  /* MATLAB Function: '<S10>/Gear_FUNCTION1' incorporates:
   *  Inport: '<Root>/GV_VCU_GearSelStat'
   *  Inport: '<Root>/GV_Vx_Fbk'
   */
  if (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 0.0) {
    if ((ADM_Integrated_Logic_U.GV_Vx_Fbk <= 0.0) && rtb_Compare_p) {
      rtb_Memory = 0.0;
    }
  } else {
    switch ((int32_t)rtb_Memory) {
     case 0:
      if ((ADM_Integrated_Logic_U.GV_Vx_Fbk <= 0.0) &&
          ((ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 1.0) ||
           (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 3.0) ||
           (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 2.0))) {
        rtb_Memory = 2.0;
      }
      break;

     case 1:
      if (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 2.0) {
        rtb_Memory = 2.0;
      }
      break;

     case 2:
      if ((ADM_Integrated_Logic_U.GV_Vx_Fbk <= 0.0) && rtb_Compare_p) {
        if (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 1.0) {
          rtb_Memory = 1.0;
        } else if (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 3.0) {
          rtb_Memory = 3.0;
        }
      }
      break;

     case 3:
      if (ADM_Integrated_Logic_U.GV_VCU_GearSelStat == 2.0) {
        rtb_Memory = 2.0;
      }
      break;
    }
  }

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

  /* Chart: '<S11>/Chart' incorporates:
   *  Constant: '<S11>/Constant'
   *  Constant: '<S11>/Constant1'
   *  Inport: '<Root>/GV_MCU_RPM'
   */
  if (ADM_Integrated_Logic_DW.is_active_c6_ADM_Integrated_Log == 0) {
    ADM_Integrated_Logic_DW.is_active_c6_ADM_Integrated_Log = 1U;
    ADM_Integrated_Logic_DW.is_c6_ADM_Integrated_Logic = IN_HAC_OFF;
  } else if (ADM_Integrated_Logic_DW.is_c6_ADM_Integrated_Logic == IN_HAC_OFF) {
    if (ADM_Integrated_Logic_U.GV_MCU_RPM < -50.0) {
      ADM_Integrated_Logic_DW.is_c6_ADM_Integrated_Logic = IN_HAC_ON;
    } else {
      /* Outport: '<Root>/Debug_HAC_RPM_Decision' */
      ADM_Integrated_Logic_Y.Debug_HAC_RPM_Decision = 0.0;
    }

    /* case IN_HAC_ON: */
  } else if (ADM_Integrated_Logic_U.GV_MCU_RPM > 150.0) {
    ADM_Integrated_Logic_DW.is_c6_ADM_Integrated_Logic = IN_HAC_OFF;
  } else {
    /* Outport: '<Root>/Debug_HAC_RPM_Decision' */
    ADM_Integrated_Logic_Y.Debug_HAC_RPM_Decision = 1.0;
  }

  /* End of Chart: '<S11>/Chart' */

  /* MATLAB Function: '<S11>/HAC_OFF_OK_Func' */
  rtb_Brake_Torque_Cmd = 0.0;

  /* Outport: '<Root>/Debug_HAC_FLAG' incorporates:
   *  MATLAB Function: '<S11>/HAC_OFF_OK_Func'
   */
  ADM_Integrated_Logic_Y.Debug_HAC_FLAG = 0.0;

  /* MATLAB Function: '<S11>/HAC_OFF_OK_Func' incorporates:
   *  Constant: '<S11>/Accel_Cmd '
   *  Constant: '<S11>/Brake_Cmd'
   *  Constant: '<S11>/Gear_D'
   *  Inport: '<Root>/GV_BrakeTorqueCommand'
   *  Inport: '<Root>/GV_MCU_EstTrq'
   *  Outport: '<Root>/Debug_HAC_RPM_Decision'
   *  RelationalOperator: '<S11>/Relational Operator'
   *  RelationalOperator: '<S11>/Relational Operator1'
   *  RelationalOperator: '<S11>/Relational Operator2'
   *  Sum: '<S11>/HAC_Flags_Add'
   */
  if (((double)(((ADM_Integrated_Logic_U.GV_BrakeTorqueCommand <= 20.0) +
                 (rtb_Vx_Cmd_R <= 2.0)) + (rtb_Memory == 3.0)) + 1.0) +
      ADM_Integrated_Logic_Y.Debug_HAC_RPM_Decision >= 5.0) {
    if (ADM_Integrated_Logic_DW.HAC_ON_FLAG == 0.0) {
      ADM_Integrated_Logic_DW.HAC_ON_Timer = 0.0;
    }

    ADM_Integrated_Logic_DW.HAC_ON_FLAG = 1.0;
    rtb_Brake_Torque_Cmd = 1000.0;
    ADM_Integrated_Logic_DW.Smoothed_Torque = 1000.0;
    if (ADM_Integrated_Logic_DW.HAC_ON_Timer < 3.0) {
      ADM_Integrated_Logic_DW.HAC_Desired_Torque = rtb_Desired_Torque;
      ADM_Integrated_Logic_DW.HAC_ON_Timer += 0.005;
    }

    /* Outport: '<Root>/Debug_HAC_FLAG' */
    ADM_Integrated_Logic_Y.Debug_HAC_FLAG = 1.0;
  } else if (ADM_Integrated_Logic_DW.HAC_ON_FLAG == 1.0) {
    if (ADM_Integrated_Logic_U.GV_MCU_EstTrq >=
        ADM_Integrated_Logic_DW.HAC_Desired_Torque) {
      ADM_Integrated_Logic_DW.Smoothed_Torque -= 0.05 *
        ADM_Integrated_Logic_DW.Smoothed_Torque;
      if (ADM_Integrated_Logic_DW.Smoothed_Torque < 0.01) {
        ADM_Integrated_Logic_DW.Smoothed_Torque = 0.0;
        ADM_Integrated_Logic_DW.HAC_ON_FLAG = 0.0;
        ADM_Integrated_Logic_DW.HAC_Desired_Torque = 0.0;
        ADM_Integrated_Logic_DW.HAC_ON_Timer = 0.0;
      }

      rtb_Brake_Torque_Cmd = ADM_Integrated_Logic_DW.Smoothed_Torque;
    } else {
      rtb_Brake_Torque_Cmd = 1000.0;
      ADM_Integrated_Logic_DW.Smoothed_Torque = 1000.0;

      /* Outport: '<Root>/Debug_HAC_FLAG' */
      ADM_Integrated_Logic_Y.Debug_HAC_FLAG = 1.0;
    }
  }

  /* MATLAB Function: '<S28>/MATLAB Function' incorporates:
   *  Inport: '<Root>/GV_Vx_Fbk'
   */
  if (fabs(ADM_Integrated_Logic_U.GV_Vx_Fbk) < 0.1) {
    rtb_AccFlag = 0.0;
  } else {
    rtb_AccFlag = 1.0;
  }

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

  /* Product: '<S28>/Product2' incorporates:
   *  Constant: '<S1>/Constant3'
   *  Product: '<S28>/Product'
   *  Product: '<S28>/Product1'
   *  Sum: '<S28>/Subtract'
   */
  rtb_Product2_a = (0.0 - rtb_Product1 * 1500.0) * rtb_AccFlag;

  /* SampleTimeMath: '<S31>/TSamp'
   *
   * About '<S31>/TSamp':
   *  y = u * K where K = 1 / ( w * Ts )
   *   */
  rtb_TSamp = rtb_Product2_a * 500.0;

  /* Sum: '<S28>/Subtract1' incorporates:
   *  Constant: '<S1>/Constant10'
   *  Constant: '<S1>/Constant11'
   *  Constant: '<S1>/Constant13'
   *  DiscreteIntegrator: '<S28>/Discrete-Time Integrator'
   *  Product: '<S28>/D controller'
   *  Product: '<S28>/I controller'
   *  Product: '<S28>/P controller'
   *  Sum: '<S31>/Diff'
   *  UnitDelay: '<S31>/UD'
   *
   * Block description for '<S31>/Diff':
   *
   *  Add in CPU
   *
   * Block description for '<S31>/UD':
   *
   *  Store in Global RAM
   */
  rtb_y = (0.07 * rtb_Product2_a +
           ADM_Integrated_Logic_DW.DiscreteTimeIntegrator_DSTATE * 0.2) +
    (rtb_TSamp - ADM_Integrated_Logic_DW.UD_DSTATE) * 0.0;

  /* Saturate: '<S28>/Saturation' */
  if (rtb_y > 3525.0) {
    rtb_y_k = 3525.0;
  } else if (rtb_y < -2500.0) {
    rtb_y_k = -2500.0;
  } else {
    rtb_y_k = rtb_y;
  }

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

  /* Product: '<S28>/Product3' */
  rtb_Switch2_k = rtb_AccFlag * rtb_y_k;

  /* RateLimiter: '<S3>/Rate Limiter' */
  rtb_AccFlag = rtb_Switch2_k - ADM_Integrated_Logic_DW.PrevY_b;
  if (rtb_AccFlag > 2.0) {
    rtb_Switch2_k = ADM_Integrated_Logic_DW.PrevY_b + 2.0;
  } else if (rtb_AccFlag < -2.0) {
    rtb_Switch2_k = ADM_Integrated_Logic_DW.PrevY_b - 2.0;
  }

  ADM_Integrated_Logic_DW.PrevY_b = rtb_Switch2_k;

  /* End of RateLimiter: '<S3>/Rate Limiter' */

  /* Product: '<S3>/Product' incorporates:
   *  MATLAB Function: '<S3>/MATLAB Function1'
   */
  rtb_Product_h = (double)(rtb_Memory == 3.0) * rtb_Switch2_k;

  /* MATLAB Function: '<S3>/MATLAB Function' */
  if (!(rtb_Product_h >= 0.0)) {
    rtb_Product_h = 0.0;
  }

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

  /* DiscreteTransferFcn: '<S1>/Discrete Transfer Fcn' */
  DiscreteTransferFcn = 0.0625 *
    ADM_Integrated_Logic_DW.DiscreteTransferFcn_states;

  /* MATLAB Function: '<S6>/MATLAB Function' incorporates:
   *  Inport: '<Root>/GV_Vx_Fbk'
   */
  if (!ADM_Integrated_Logic_DW.x_f_not_empty) {
    ADM_Integrated_Logic_DW.x_f_not_empty = true;
    ADM_Integrated_Logic_DW.x_f.contents = ADM_Integrated_Logic_U.GV_Vx_Fbk;
    ADM_Integrated_Logic_DW.y_prev = 0.0;
  }

  ADM_Integrated_Logic_DW.x_f.contents += (ADM_Integrated_Logic_U.GV_Vx_Fbk -
    ADM_Integrated_Logic_DW.x_f.contents) * 0.024390243902439025;
  if (!ADM_Integrated_Logic_DW.xf_p_not_empty) {
    ADM_Integrated_Logic_DW.xf_p = ADM_Integrated_Logic_DW.x_f.contents;
    ADM_Integrated_Logic_DW.xf_p_not_empty = true;
  }

  rtb_AccFlag = ADM_Integrated_Logic_DW.xf_p;
  ADM_Integrated_Logic_DW.xf_p = ADM_Integrated_Logic_DW.x_f.contents;
  rtb_dVx = (ADM_Integrated_Logic_DW.x_f.contents - rtb_AccFlag) / 0.002 +
    0.90483741803595952 * ADM_Integrated_Logic_DW.y_prev;
  ADM_Integrated_Logic_DW.y_prev = rtb_dVx;

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

  /* Gain: '<S6>/Brake_GAIN' */
  rtb_Integrator_1 = -80.0 * DiscreteTransferFcn;

  /* MATLAB Function: '<S6>/GearCondition_Brake' */
  if (rtb_Memory == 1.0) {
    i = -1;
  } else {
    i = (rtb_Memory == 3.0);
  }

  /* Saturate: '<S6>/Saturation' */
  if (rtb_Integrator_1 > 1000.0) {
    rtb_Integrator_1 = 1000.0;
  } else if (rtb_Integrator_1 < 0.0) {
    rtb_Integrator_1 = 0.0;
  }

  /* Product: '<S6>/Multiply2' incorporates:
   *  MATLAB Function: '<S6>/GearCondition_Brake'
   *  Saturate: '<S6>/Saturation'
   */
  rtb_Switch2_k = (double)i * rtb_Integrator_1;

  /* RateLimiter: '<S6>/Brake_Out_RateLimiter' */
  rtb_AccFlag = rtb_Switch2_k - ADM_Integrated_Logic_DW.PrevY_o;
  if (rtb_AccFlag > 3.0) {
    rtb_Switch2_k = ADM_Integrated_Logic_DW.PrevY_o + 3.0;
  } else if (rtb_AccFlag < -3.0) {
    rtb_Switch2_k = ADM_Integrated_Logic_DW.PrevY_o - 3.0;
  }

  ADM_Integrated_Logic_DW.PrevY_o = rtb_Switch2_k;

  /* End of RateLimiter: '<S6>/Brake_Out_RateLimiter' */

  /* Saturate: '<S6>/Brake_Saturation' */
  if (rtb_Switch2_k > 1000.0) {
    rtb_Brake_Control = 1000.0;
  } else if (rtb_Switch2_k < 0.0) {
    rtb_Brake_Control = 0.0;
  } else {
    rtb_Brake_Control = rtb_Switch2_k;
  }

  /* End of Saturate: '<S6>/Brake_Saturation' */

  /* MATLAB Function: '<S6>/Target_RPM' */
  if (rtb_Memory == 0.0) {
    i = 0;
  } else if (rtb_Memory == 2.0) {
    i = 0;
  } else if (rtb_Memory == 1.0) {
    i = -1;
  } else {
    i = (rtb_Memory == 3.0);
  }

  rtb_Target_RPM = rtb_Vx_Cmd_R * 1000.0 / 3600.0 * 11.93 * 60.0 /
    1.7013672006633955 * (double)i;

  /* End of MATLAB Function: '<S6>/Target_RPM' */

  /* RateLimiter: '<S6>/TargetSpd_RateLimiter' */
  rtb_AccFlag = rtb_Target_RPM - ADM_Integrated_Logic_DW.PrevY_a;
  if (rtb_AccFlag > 0.4) {
    rtb_AccFlag = ADM_Integrated_Logic_DW.PrevY_a + 0.4;
  } else if (rtb_AccFlag < -0.8) {
    rtb_AccFlag = ADM_Integrated_Logic_DW.PrevY_a - 0.8;
  } else {
    rtb_AccFlag = rtb_Target_RPM;
  }

  ADM_Integrated_Logic_DW.PrevY_a = rtb_AccFlag;

  /* End of RateLimiter: '<S6>/TargetSpd_RateLimiter' */

  /* Product: '<S38>/Product1' incorporates:
   *  Constant: '<S38>/Constant'
   *  Gain: '<S38>/gain'
   *  Product: '<S38>/Product11'
   *  Sum: '<S38>/Sum1'
   *  Sum: '<S38>/Sum2'
   *  Sum: '<S38>/Sum3'
   *  Sum: '<S38>/Sum4'
   *  UnitDelay: '<S38>/d'
   *  UnitDelay: '<S38>/d1'
   */
  rtb_Target_RPM = ((rtb_AccFlag + ADM_Integrated_Logic_DW.d1_DSTATE_c) * 0.002
                    + 0.1041032953945969 * ADM_Integrated_Logic_DW.d_DSTATE_l) /
    0.1081032953945969;

  /* Sum: '<S51>/Sum1' incorporates:
   *  Gain: '<S51>/gain'
   *  Sum: '<S51>/Sum2'
   *  UnitDelay: '<S51>/d'
   *  UnitDelay: '<S51>/d1'
   */
  rtb_Sum1_i2 = (rtb_Target_RPM - ADM_Integrated_Logic_DW.d_DSTATE_i) * 1000.0 -
    ADM_Integrated_Logic_DW.d1_DSTATE_p;

  /* Sum: '<S52>/Sum1' incorporates:
   *  Gain: '<S52>/gain'
   *  Sum: '<S52>/Sum2'
   *  UnitDelay: '<S52>/d'
   *  UnitDelay: '<S52>/d1'
   */
  rtb_Sum1_o1 = (rtb_Sum1_i2 - ADM_Integrated_Logic_DW.d_DSTATE_c) * 1000.0 -
    ADM_Integrated_Logic_DW.d1_DSTATE_h;

  /* Sum: '<S53>/Sum1' incorporates:
   *  Gain: '<S53>/gain'
   *  Sum: '<S53>/Sum2'
   *  UnitDelay: '<S53>/d'
   *  UnitDelay: '<S53>/d1'
   */
  rtb_Sum1_lm = (rtb_Sum1_o1 - ADM_Integrated_Logic_DW.d_DSTATE_d) * 1000.0 -
    ADM_Integrated_Logic_DW.d1_DSTATE_l;

  /* Gain: '<S49>/Gain' incorporates:
   *  Constant: '<S49>/Constant3'
   *  Constant: '<S49>/Constant4'
   *  Constant: '<S49>/Constant5'
   *  Product: '<S49>/Product'
   *  Product: '<S49>/Product1'
   *  Product: '<S49>/Product2'
   *  Sum: '<S49>/Add5'
   */
  rtb_Gain_c = (((156.8 * rtb_Target_RPM + 212.8 * rtb_Sum1_i2) + 21.8 *
                 rtb_Sum1_o1) + rtb_Sum1_lm) * 9.44822373393802E-6;

  /* Product: '<S55>/Product1' incorporates:
   *  Constant: '<S55>/Constant1'
   *  Constant: '<S55>/Constant2'
   *  Delay: '<S55>/Delay'
   *  Delay: '<S55>/Delay1'
   *  Delay: '<S55>/Delay2'
   *  Delay: '<S55>/Delay3'
   *  Gain: '<S55>/gain1'
   *  Gain: '<S55>/gain3'
   *  Product: '<S55>/x(n), x(n-1), x(n-2)'
   *  Product: '<S55>/y(n-1)'
   *  Product: '<S55>/y(n-2)'
   *  Sum: '<S55>/Sum1'
   *  Sum: '<S55>/Sum2'
   *  Sum: '<S55>/Sum3'
   *  Sum: '<S55>/Sum4'
   *  Sum: '<S55>/Sum5'
   *  Sum: '<S55>/Sum6'
   */
  rtb_Product1_pd = ((((2.0 * ADM_Integrated_Logic_DW.Delay1_DSTATE + rtb_Gain_c)
                       + ADM_Integrated_Logic_DW.Delay_DSTATE_c[0]) *
                      0.39478417604357435 - -7.2104316479128512 *
                      ADM_Integrated_Logic_DW.Delay2_DSTATE) -
                     2.6178993711731877 * ADM_Integrated_Logic_DW.Delay3_DSTATE
                     [0]) / 6.1716689809139611;

  /* Product: '<S54>/Product1' incorporates:
   *  Constant: '<S54>/Constant'
   *  Gain: '<S54>/gain'
   *  Product: '<S54>/Product11'
   *  Sum: '<S54>/Sum1'
   *  Sum: '<S54>/Sum2'
   *  Sum: '<S54>/Sum3'
   *  Sum: '<S54>/Sum4'
   *  UnitDelay: '<S54>/d'
   *  UnitDelay: '<S54>/d1'
   */
  rtb_Product1_m = ((rtb_Product1_pd + ADM_Integrated_Logic_DW.d1_DSTATE_e) *
                    0.002 + 0.00861032953945969 *
                    ADM_Integrated_Logic_DW.d_DSTATE_ij) / 0.01261032953945969;

  /* Sum: '<S6>/Subtract' incorporates:
   *  Inport: '<Root>/GV_MCU_RPM'
   *  MultiPortSwitch: '<S48>/Multiport Switch1'
   */
  rtb_Error_m = rtb_Target_RPM - ADM_Integrated_Logic_U.GV_MCU_RPM;

  /* Saturate: '<S6>/Error_Saturation' incorporates:
   *  MultiPortSwitch: '<S48>/Multiport Switch1'
   */
  if (rtb_Error_m > 2000.0) {
    rtb_Error_m = 2000.0;
  } else if (rtb_Error_m < -2000.0) {
    rtb_Error_m = -2000.0;
  }

  /* End of Saturate: '<S6>/Error_Saturation' */

  /* DeadZone: '<S35>/Dead Zone' incorporates:
   *  MultiPortSwitch: '<S48>/Multiport Switch1'
   */
  if (rtb_Error_m > 50.0) {
    rtb_Add = rtb_Error_m - 50.0;
  } else if (rtb_Error_m >= -50.0) {
    rtb_Add = 0.0;
  } else {
    rtb_Add = rtb_Error_m - -50.0;
  }

  /* Sum: '<S43>/Sum1' incorporates:
   *  Gain: '<S43>/gain'
   *  Sum: '<S43>/Sum2'
   *  UnitDelay: '<S43>/d'
   *  UnitDelay: '<S43>/d1'
   */
  rtb_Error_m = (rtb_Target_RPM - ADM_Integrated_Logic_DW.d_DSTATE_ir) * 1000.0
    - ADM_Integrated_Logic_DW.d1_DSTATE_o;

  /* Sum: '<S44>/Sum1' incorporates:
   *  Gain: '<S44>/gain'
   *  Sum: '<S44>/Sum2'
   *  UnitDelay: '<S44>/d'
   *  UnitDelay: '<S44>/d1'
   */
  rtb_Sum1_aj = (rtb_Error_m - ADM_Integrated_Logic_DW.d_DSTATE_m) * 1000.0 -
    ADM_Integrated_Logic_DW.d1_DSTATE_hm;

  /* Sum: '<S45>/Sum1' incorporates:
   *  Gain: '<S45>/gain'
   *  Sum: '<S45>/Sum2'
   *  UnitDelay: '<S45>/d'
   *  UnitDelay: '<S45>/d1'
   */
  rtb_Sum1_p = (rtb_Sum1_aj - ADM_Integrated_Logic_DW.d_DSTATE_mw) * 1000.0 -
    ADM_Integrated_Logic_DW.d1_DSTATE_g;

  /* Sum: '<S33>/Add3' incorporates:
   *  Constant: '<S33>/Constant3'
   *  Constant: '<S33>/Constant4'
   *  Constant: '<S33>/Constant5'
   *  Gain: '<S33>/Gain'
   *  Memory: '<S6>/Memory'
   *  Product: '<S33>/Product2'
   *  Product: '<S33>/Product3'
   *  Product: '<S33>/Product4'
   *  Sum: '<S33>/Add2'
   */
  rtb_Add3 = (((156.8 * rtb_Target_RPM + 212.8 * rtb_Error_m) + 21.8 *
               rtb_Sum1_aj) + rtb_Sum1_p) * 9.44822373393802E-6 -
    ADM_Integrated_Logic_DW.Memory_PreviousInput;

  /* Product: '<S46>/Product1' incorporates:
   *  Constant: '<S46>/Constant'
   *  Gain: '<S46>/gain'
   *  Product: '<S46>/Product11'
   *  Sum: '<S46>/Sum1'
   *  Sum: '<S46>/Sum2'
   *  Sum: '<S46>/Sum3'
   *  Sum: '<S46>/Sum4'
   *  UnitDelay: '<S46>/d'
   *  UnitDelay: '<S46>/d1'
   */
  rtb_Product1_k3 = ((rtb_Add3 + ADM_Integrated_Logic_DW.d1_DSTATE_ej) * 0.002 +
                     0.029830988618379066 * ADM_Integrated_Logic_DW.d_DSTATE_j) /
    0.03383098861837907;

  /* Product: '<S47>/Product1' incorporates:
   *  Constant: '<S47>/Constant1'
   *  Constant: '<S47>/Constant2'
   *  Delay: '<S47>/Delay'
   *  Delay: '<S47>/Delay1'
   *  Delay: '<S47>/Delay2'
   *  Delay: '<S47>/Delay3'
   *  Gain: '<S47>/gain1'
   *  Gain: '<S47>/gain3'
   *  Product: '<S47>/x(n), x(n-1), x(n-2)'
   *  Product: '<S47>/y(n-1)'
   *  Product: '<S47>/y(n-2)'
   *  Sum: '<S47>/Sum1'
   *  Sum: '<S47>/Sum2'
   *  Sum: '<S47>/Sum3'
   *  Sum: '<S47>/Sum4'
   *  Sum: '<S47>/Sum5'
   *  Sum: '<S47>/Sum6'
   */
  rtb_Product1_h = ((((2.0 * ADM_Integrated_Logic_DW.Delay1_DSTATE_c +
                       rtb_Product1_k3) +
                      ADM_Integrated_Logic_DW.Delay_DSTATE_p[0]) *
                     0.00035530575843921691 - -7.9992893884831213 *
                     ADM_Integrated_Logic_DW.Delay2_DSTATE_n) -
                    3.9470487616123275 *
                    ADM_Integrated_Logic_DW.Delay3_DSTATE_h[0]) /
    4.0536618499045511;

  /* MATLAB Function: '<S6>/DOB_Gain' incorporates:
   *  Inport: '<Root>/GV_Vx_Fbk'
   */
  if (ADM_Integrated_Logic_U.GV_Vx_Fbk < 5.0) {
    rtb_Switch2_k = 0.0;
  } else {
    rtb_Switch2_k = (ADM_Integrated_Logic_U.GV_Vx_Fbk - 5.0) * 0.2;
  }

  if (rtb_Switch2_k >= 1.0) {
    rtb_Switch2_k = 1.0;
  }

  /* End of MATLAB Function: '<S6>/DOB_Gain' */

  /* Product: '<S6>/Product1' incorporates:
   *  Constant: '<S6>/DOBFlag'
   *  Product: '<S6>/Product'
   */
  rtb_Integrator_1 = -(rtb_Product1_h * 0.9);

  /* Saturate: '<S6>/DOB_Saturation' */
  if (rtb_Integrator_1 > 30.0) {
    rtb_Integrator_1 = 30.0;
  } else if (rtb_Integrator_1 < -30.0) {
    rtb_Integrator_1 = -30.0;
  }

  /* Sum: '<S6>/Subtract2' incorporates:
   *  DeadZone: '<S35>/Dead Zone'
   *  MultiPortSwitch: '<S48>/Multiport Switch1'
   *  Product: '<S50>/Product'
   *  Product: '<S6>/Multiply1'
   *  Saturate: '<S6>/DOB_Saturation'
   *  Sum: '<S35>/Add'
   */
  rtb_Integrator_1 = (rtb_Add * 0.044648264844923756 + rtb_Product1_m) +
    rtb_Integrator_1 * rtb_Switch2_k;

  /* Saturate: '<S6>/Torq_Saturation' */
  if (rtb_Integrator_1 > 80.0) {
    rtb_Add = 80.0;
  } else if (rtb_Integrator_1 < -80.0) {
    rtb_Add = -80.0;
  } else {
    rtb_Add = rtb_Integrator_1;
  }

  /* End of Saturate: '<S6>/Torq_Saturation' */

  /* MATLAB Function: '<S41>/Calculate_F_c' incorporates:
   *  Gain: '<S41>/Gain'
   *  Inport: '<Root>/GV_SP_Slope'
   */
  ADM_Integrated_Lo_Calculate_F_c(ADM_Integrated_Logic_ConstB.W_value,
    0.017453292519943295 * ADM_Integrated_Logic_U.GV_SP_Slope, &rtb_Switch2_k);

  /* MATLAB Function: '<S41>/Calculate_F_R' incorporates:
   *  Gain: '<S41>/Gain1'
   *  Inport: '<Root>/GV_SP_Slope'
   */
  ADM_Integrated_Lo_Calculate_F_R(ADM_Integrated_Logic_ConstB.Multiply1,
    ADM_Integrated_Logic_ConstB.Multiply2, 0.017453292519943295 *
    ADM_Integrated_Logic_U.GV_SP_Slope, &rtb_Integrator_1);

  /* MATLAB Function: '<S6>/Mode_and_blend' incorporates:
   *  Constant: '<S6>/Constant2'
   *  Constant: '<S6>/Constant4'
   *  Constant: '<S6>/Constant5'
   *  Constant: '<S6>/Constant6'
   *  Constant: '<S6>/Constant7'
   *  Constant: '<S6>/Constant8'
   */
  ADM_Integrated_Logic_DW.t_hold += 0.002;
  switch (ADM_Integrated_Logic_DW.st) {
   case 1:
    e_off = 0.08;
    break;

   case 2:
    e_off = -0.08;
    break;

   default:
    e_off = 0.0;
    break;
  }

  rtb_dVx = (tanh((DiscreteTransferFcn + e_off) * 5.0 + 0.02 * rtb_dVx) + 1.0) *
    0.5 + 0.05;
  if (!(rtb_dVx >= 0.0)) {
    rtb_dVx = 0.0;
  }

  if (!(rtb_dVx <= 1.0)) {
    rtb_dVx = 1.0;
  }

  if ((rtb_dVx > 0.75) && (ADM_Integrated_Logic_DW.t_hold >= 0.06)) {
    ADM_Integrated_Logic_DW.st = 1;
    ADM_Integrated_Logic_DW.t_hold = 0.0;
  } else if ((rtb_dVx < 0.25) && (ADM_Integrated_Logic_DW.t_hold >= 0.06)) {
    ADM_Integrated_Logic_DW.st = 2;
    ADM_Integrated_Logic_DW.t_hold = 0.0;
  } else if (ADM_Integrated_Logic_DW.t_hold >= 0.06) {
    ADM_Integrated_Logic_DW.st = 0;
  }

  ADM_Integrated_Logic_DW.w += (rtb_dVx - ADM_Integrated_Logic_DW.w) *
    0.033333333333333333;
  rtb_dVx = fabs(DiscreteTransferFcn) / 0.4;
  if ((rtb_dVx <= 0.0) || rtIsNaN(rtb_dVx)) {
    rtb_dVx = 0.0;
  }

  if (rtb_dVx >= 1.0) {
    rtb_dVx = 1.0;
  }

  /* Gain: '<S41>/Gain2' incorporates:
   *  Constant: '<S41>/Radius'
   *  Gain: '<S41>/Rolling_Gain'
   *  Product: '<S41>/Multiply3'
   *  Sum: '<S41>/Required_Brake_Cal'
   */
  rtb_Integrator_1 = (0.0 * rtb_Integrator_1 + rtb_Switch2_k) * 0.292 *
    0.083822296730930432;

  /* MATLAB Function: '<S6>/Gear_pos_out' */
  if (rtb_Memory == 0.0) {
    i = 0;
  } else if (rtb_Memory == 2.0) {
    i = 0;
  } else if (rtb_Memory == 1.0) {
    i = -1;
  } else {
    i = (rtb_Memory == 3.0);
  }

  /* Saturate: '<S41>/Saturation' */
  if (rtb_Integrator_1 > 60.0) {
    rtb_Integrator_1 = 60.0;
  } else if (rtb_Integrator_1 < 0.0) {
    rtb_Integrator_1 = 0.0;
  }

  /* Product: '<S6>/Multiply' incorporates:
   *  Constant: '<S6>/Constant10'
   *  Inport: '<Root>/GV_SP_AngleCompensationFlag'
   *  MATLAB Function: '<S6>/Gear_pos_out'
   *  Product: '<S6>/Product3'
   *  Product: '<S6>/Product4'
   *  RelationalOperator: '<S6>/Relational Operator1'
   *  Saturate: '<S41>/Saturation'
   *  Sum: '<S6>/Add'
   */
  rtb_Integrator_1 = ((double)
                      (ADM_Integrated_Logic_U.GV_SP_AngleCompensationFlag ?
                       rtb_Vx_Cmd_R >= 1.0 : 0) * rtb_Integrator_1 + rtb_Add) *
    (double)i;

  /* MATLAB Function: '<S6>/Mode_and_blend' incorporates:
   *  Constant: '<S6>/Constant9'
   */
  if (!(rtb_Integrator_1 >= 0.0)) {
    rtb_Integrator_1 = 0.0;
  }

  DiscreteTransferFcn = rtb_Integrator_1 * ADM_Integrated_Logic_DW.w * rtb_dVx;
  if (!(rtb_Brake_Control >= 0.0)) {
    rtb_Brake_Control = 0.0;
  }

  rtb_Switch2_k = (1.0 - ADM_Integrated_Logic_DW.w) * rtb_Brake_Control *
    rtb_dVx;
  if ((DiscreteTransferFcn > 0.0) && (rtb_Switch2_k > 0.0)) {
    if (DiscreteTransferFcn > rtb_Switch2_k) {
      rtb_Switch2_k *= 0.6;
    } else {
      DiscreteTransferFcn *= 0.6;
    }
  }

  if (DiscreteTransferFcn < 0.3) {
    DiscreteTransferFcn = 0.0;
  }

  if (rtb_Switch2_k < 0.3) {
    rtb_Switch2_k = 0.0;
  }

  /* MATLAB Function: '<S1>/Emergency_Brake_Func' incorporates:
   *  Inport: '<Root>/GV_Vx_Fbk'
   *  MATLAB Function: '<S6>/Mode_and_blend'
   *  Sum: '<S1>/Add'
   */
  if (rtb_Compare_l) {
    rtb_Brake_Control = ADM_Integrated_Logic_U.GV_Vx_Fbk * 100.0;
  } else {
    rtb_Brake_Control = rtb_Brake_Torque_Cmd + rtb_Switch2_k;
  }

  /* Saturate: '<S1>/Brake_Saturation' incorporates:
   *  MATLAB Function: '<S1>/Emergency_Brake_Func'
   */
  if (rtb_Brake_Control > 2500.0) {
    rtb_Brake_Control = 2500.0;
  } else if (rtb_Brake_Control < 0.0) {
    rtb_Brake_Control = 0.0;
  }

  /* End of Saturate: '<S1>/Brake_Saturation' */

  /* Outputs for Enabled SubSystem: '<S1>/Enabled Subsystem' incorporates:
   *  EnablePort: '<S9>/Enable'
   */
  /* MATLAB Function: '<S1>/MATLAB Function4' incorporates:
   *  Inport: '<Root>/GV_Drive_ACC_Cmd'
   *  Inport: '<Root>/GV_MCU_EstTrq'
   *  Inport: '<Root>/GV_Vx_Fbk'
   *  MATLAB Function: '<S1>/IDB_Fault_Injection'
   */
  if (((rtb_Vx_Cmd_R >= 1.0) || (ADM_Integrated_Logic_U.GV_Drive_ACC_Cmd >= 0.01))
      && (ADM_Integrated_Logic_U.GV_MCU_EstTrq >= 10.0) && (rtb_Product1 >= 0.2)
      && (ADM_Integrated_Logic_U.GV_Vx_Fbk >= 1.5) && (rtb_Brake_Control <= 10.0))
  {
    /* MATLAB Function: '<S9>/MATLAB Function' incorporates:
     *  Constant: '<S1>/Constant9'
     *  Inport: '<Root>/GV_IMU_AZ_Val'
     *  MATLAB Function: '<S1>/MATLAB Function'
     */
    ADM_Integrated_Logic_DW.M = ADM_Integrated_Logic_U.GV_MCU_EstTrq / ((0.01 *
      ADM_Integrated_Logic_U.GV_IMU_AZ_Val + ADM_Integrated_Logic_DW.x_hat[1]) *
      0.022698910310142498);

    /* MATLAB Function: '<S1>/MATLAB Function3' */
    if ((ADM_Integrated_Logic_DW.M > 500.0) && (ADM_Integrated_Logic_DW.M <
         2000.0)) {
      if (fabs(ADM_Integrated_Logic_DW.M -
               ADM_Integrated_Logic_DW.currentEstMass) /
          ADM_Integrated_Logic_DW.currentEstMass < 0.2) {
        rtb_Integrator_1 = ADM_Integrated_Logic_DW.currentEstMass;
        ADM_Integrated_Logic_DW.currentEstMass = 0.98 *
          ADM_Integrated_Logic_DW.currentEstMass + 0.02 *
          ADM_Integrated_Logic_DW.M;
        ADM_Integrated_Logic_DW.isConverged = ((fabs
          (ADM_Integrated_Logic_DW.currentEstMass - rtb_Integrator_1) < 5.0) ||
          ADM_Integrated_Logic_DW.isConverged);
        if (ADM_Integrated_Logic_DW.isConverged) {
          /* Outport: '<Root>/GV_VCU_EstMassFlag' */
          ADM_Integrated_Logic_Y.GV_VCU_EstMassFlag = 2.0;
        } else {
          /* Outport: '<Root>/GV_VCU_EstMassFlag' */
          ADM_Integrated_Logic_Y.GV_VCU_EstMassFlag = 1.0;
        }
      } else {
        ADM_Integrated_Logic_DW.isConverged = false;

        /* Outport: '<Root>/GV_VCU_EstMassFlag' */
        ADM_Integrated_Logic_Y.GV_VCU_EstMassFlag = 1.0;
      }
    } else {
      ADM_Integrated_Logic_DW.isConverged = false;

      /* Outport: '<Root>/GV_VCU_EstMassFlag' */
      ADM_Integrated_Logic_Y.GV_VCU_EstMassFlag = 1.0;
    }
  } else {
    /* MATLAB Function: '<S1>/MATLAB Function3' */
    ADM_Integrated_Logic_DW.isConverged = false;

    /* Outport: '<Root>/GV_VCU_EstMassFlag' incorporates:
     *  MATLAB Function: '<S1>/MATLAB Function3'
     */
    ADM_Integrated_Logic_Y.GV_VCU_EstMassFlag = 0.0;
  }

  /* End of MATLAB Function: '<S1>/MATLAB Function4' */
  /* End of Outputs for SubSystem: '<S1>/Enabled Subsystem' */

  /* Outport: '<Root>/GV_VCU_EstMass' incorporates:
   *  MATLAB Function: '<S1>/MATLAB Function3'
   */
  ADM_Integrated_Logic_Y.GV_VCU_EstMass = ADM_Integrated_Logic_DW.currentEstMass;

  /* Outport: '<Root>/GV_Brake_Command' incorporates:
   *  MATLAB Function: '<S1>/IDB_Fault_Injection'
   */
  ADM_Integrated_Logic_Y.GV_Brake_Command = rtb_Brake_Control;

  /* Outport: '<Root>/Target_IDB_Out' incorporates:
   *  MATLAB Function: '<S1>/IDB_Fault_Injection'
   */
  ADM_Integrated_Logic_Y.Target_IDB_Out = rtb_Brake_Control;

  /* MATLAB Function: '<S1>/Emergency_Motor_Func' incorporates:
   *  Inport: '<Root>/GV_IDB_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_RCU_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_Vx_Fbk'
   *  MATLAB Function: '<S6>/Mode_and_blend'
   *  Saturate: '<S1>/Saturation'
   */
  if (rtb_Compare_l) {
    if ((ADM_Integrated_Logic_U.GV_IDB_ECU_Fault_Flag == 1.0) &&
        (ADM_Integrated_Logic_U.GV_RCU_ECU_Fault_Flag == 1.0)) {
      if (ADM_Integrated_Logic_U.GV_Vx_Fbk / 3.6 > 0.5) {
        DiscreteTransferFcn = -80.0;
      } else {
        DiscreteTransferFcn = 0.0;
      }
    } else {
      DiscreteTransferFcn = 0.0;
    }
  } else if (DiscreteTransferFcn > 80.0) {
    /* Saturate: '<S1>/Saturation' */
    DiscreteTransferFcn = 80.0;
  }

  /* End of MATLAB Function: '<S1>/Emergency_Motor_Func' */

  /* MATLAB Function: '<S1>/MCU_Fault_Injection' incorporates:
   *  Inport: '<Root>/GV_MCU_Actuator_Fault_Flag'
   */
  if (ADM_Integrated_Logic_U.GV_MCU_Actuator_Fault_Flag == 1.0) {
    /* Outport: '<Root>/GV_Motor_Torque_Cmd' */
    ADM_Integrated_Logic_Y.GV_Motor_Torque_Cmd = 0.0;
  } else {
    /* Outport: '<Root>/GV_Motor_Torque_Cmd' */
    ADM_Integrated_Logic_Y.GV_Motor_Torque_Cmd = DiscreteTransferFcn;
  }

  /* Outport: '<Root>/Target_MCU_Out' incorporates:
   *  MATLAB Function: '<S1>/MCU_Fault_Injection'
   */
  ADM_Integrated_Logic_Y.Target_MCU_Out = DiscreteTransferFcn;

  /* Outport: '<Root>/Debug_AccControl_TorqueCmd' incorporates:
   *  Constant: '<S3>/Constant'
   *  Constant: '<S3>/Constant1'
   *  Product: '<S3>/Product1'
   *  Product: '<S3>/Product2'
   */
  ADM_Integrated_Logic_Y.Debug_AccControl_TorqueCmd = rtb_Product_h * 0.270798 /
    11.93;

  /* Outport: '<Root>/Debug_CC_Brake_Output' incorporates:
   *  MATLAB Function: '<S6>/Mode_and_blend'
   */
  ADM_Integrated_Logic_Y.Debug_CC_Brake_Output = rtb_Switch2_k;

  /* Sum: '<S28>/Sum' */
  DiscreteTransferFcn = rtb_y - rtb_y_k;

  /* Outport: '<Root>/Debug_HAC_Brake_Output' */
  ADM_Integrated_Logic_Y.Debug_HAC_Brake_Output = rtb_Brake_Torque_Cmd;

  /* Outport: '<Root>/GV_Gear_Postion_Out' */
  ADM_Integrated_Logic_Y.GV_Gear_Postion_Out = rtb_Memory;

  /* Outport: '<Root>/GV_Hill_Torque_Assist' */
  ADM_Integrated_Logic_Y.GV_Hill_Torque_Assist = rtb_Desired_Torque;

  /* Outport: '<Root>/Debug_HAC_Pitch_angle' */
  ADM_Integrated_Logic_Y.Debug_HAC_Pitch_angle = rtb_Pitch_Angle;

  /* MATLAB Function: '<S63>/Calculate_F_c1' incorporates:
   *  Gain: '<S63>/Gain3'
   */
  ADM_Integrated_Lo_Calculate_F_c(ADM_Integrated_Logic_ConstB.W_Value_for_Brake,
    0.017453292519943295 * rtb_Pitch_Angle, &rtb_y_k);

  /* Product: '<S64>/Product1' incorporates:
   *  Constant: '<S64>/Constant'
   *  Gain: '<S64>/gain'
   *  Inport: '<Root>/GV_IMU_AX_Val'
   *  Product: '<S64>/Product11'
   *  Sum: '<S64>/Sum1'
   *  Sum: '<S64>/Sum2'
   *  Sum: '<S64>/Sum3'
   *  Sum: '<S64>/Sum4'
   *  UnitDelay: '<S64>/d'
   *  UnitDelay: '<S64>/d1'
   */
  rtb_Desired_Torque = ((ADM_Integrated_Logic_U.GV_IMU_AX_Val +
    ADM_Integrated_Logic_DW.d1_DSTATE_ob) * 0.002 + 0.061661977236758134 *
                        ADM_Integrated_Logic_DW.d_DSTATE_e) /
    0.065661977236758137;

  /* Product: '<S65>/Product1' incorporates:
   *  Constant: '<S65>/Constant'
   *  Gain: '<S65>/gain'
   *  Inport: '<Root>/GV_IMU_AY_Val'
   *  Product: '<S65>/Product11'
   *  Sum: '<S65>/Sum1'
   *  Sum: '<S65>/Sum2'
   *  Sum: '<S65>/Sum3'
   *  Sum: '<S65>/Sum4'
   *  UnitDelay: '<S65>/d'
   *  UnitDelay: '<S65>/d1'
   */
  rtb_Brake_Torque_Cmd = ((ADM_Integrated_Logic_U.GV_IMU_AY_Val +
    ADM_Integrated_Logic_DW.d1_DSTATE_i) * 0.002 + 0.061661977236758134 *
    ADM_Integrated_Logic_DW.d_DSTATE_p) / 0.065661977236758137;

  /* Product: '<S66>/Product1' incorporates:
   *  Constant: '<S66>/Constant'
   *  Gain: '<S66>/gain'
   *  Inport: '<Root>/GV_IMU_AZ_Val'
   *  Product: '<S66>/Product11'
   *  Sum: '<S66>/Sum1'
   *  Sum: '<S66>/Sum2'
   *  Sum: '<S66>/Sum3'
   *  Sum: '<S66>/Sum4'
   *  UnitDelay: '<S66>/d'
   *  UnitDelay: '<S66>/d1'
   */
  rtb_Product_h = ((ADM_Integrated_Logic_U.GV_IMU_AZ_Val +
                    ADM_Integrated_Logic_DW.d1_DSTATE_o1) * 0.002 +
                   0.061661977236758134 * ADM_Integrated_Logic_DW.d_DSTATE_n) /
    0.065661977236758137;

  /* MATLAB Function: '<S11>/Pitch_calculate' */
  rtb_y_k = sqrt(rtb_Brake_Torque_Cmd * rtb_Brake_Torque_Cmd + rtb_Product_h *
                 rtb_Product_h);
  if (!(rtb_y_k == 0.0)) {
    rtb_y_k = atan(rtb_Desired_Torque / rtb_y_k);
  }

  /* Sum: '<S11>/Sum' incorporates:
   *  DiscreteIntegrator: '<S11>/Integrator_2'
   *  MATLAB Function: '<S11>/Pitch_calculate'
   */
  rtb_Brake_Control = ADM_Integrated_Logic_DW.Integrator_2_DSTATE - rtb_y_k *
    57.295779513082323;

  /* Gain: '<S67>/gain1' incorporates:
   *  Constant: '<S67>/Constant1'
   *  Product: '<S67>/Product2'
   */
  rtb_Switch2_k = 0.063661977236758135;

  /* Product: '<S67>/Product1' incorporates:
   *  Constant: '<S67>/Constant'
   *  Gain: '<S67>/gain'
   *  Inport: '<Root>/GV_IMU_PitchRtVal'
   *  Product: '<S67>/Product11'
   *  Sum: '<S67>/Sum1'
   *  Sum: '<S67>/Sum2'
   *  Sum: '<S67>/Sum3'
   *  Sum: '<S67>/Sum4'
   *  UnitDelay: '<S67>/d'
   *  UnitDelay: '<S67>/d1'
   */
  rtb_Integrator_1 = ((ADM_Integrated_Logic_U.GV_IMU_PitchRtVal +
                       ADM_Integrated_Logic_DW.d1_DSTATE_a) * 0.002 +
                      0.061661977236758134 * ADM_Integrated_Logic_DW.d_DSTATE_d1)
    / 0.065661977236758137;

  /* Sum: '<S1>/Add2' incorporates:
   *  Inport: '<Root>/GV_Vx_Fbk'
   */
  rtb_Vx_Cmd_R -= ADM_Integrated_Logic_U.GV_Vx_Fbk;

  /* Sum: '<S1>/Add1' incorporates:
   *  Constant: '<S1>/Constant'
   *  Gain: '<S1>/Gain1'
   *  Inport: '<Root>/GV_Vx_Fbk'
   *  Sum: '<S1>/Add3'
   */
  e_off = 400.0 - 6.5 * ADM_Integrated_Logic_U.GV_Vx_Fbk;

  /* MATLAB Function: '<S1>/MATLAB Function1' incorporates:
   *  Sum: '<S1>/Add1'
   */
  ADM_Integrated__MATLABFunction1(e_off, &rtb_Switch2_k);

  /* Product: '<S23>/delta rise limit' incorporates:
   *  SampleTimeMath: '<S23>/sample time'
   *
   * About '<S23>/sample time':
   *  y = K where K = ( w * Ts )
   *   */
  rtb_Switch2_k *= 0.002;

  /* Delay: '<S23>/Delay' incorporates:
   *  Inport: '<Root>/GV_RWA_RackAngleCommand'
   */
  if (ADM_Integrated_Logic_DW.icLoad_l) {
    ADM_Integrated_Logic_DW.Delay_DSTATE_c4 =
      ADM_Integrated_Logic_U.GV_RWA_RackAngleCommand;
  }

  /* Sum: '<S23>/Difference Inputs1' incorporates:
   *  Delay: '<S23>/Delay'
   *  Inport: '<Root>/GV_RWA_RackAngleCommand'
   *
   * Block description for '<S23>/Difference Inputs1':
   *
   *  Add in CPU
   */
  rtb_y_k = ADM_Integrated_Logic_U.GV_RWA_RackAngleCommand -
    ADM_Integrated_Logic_DW.Delay_DSTATE_c4;

  /* MATLAB Function: '<S1>/MATLAB Function2' incorporates:
   *  Gain: '<S1>/Gain3'
   *  Sum: '<S1>/Add1'
   */
  ADM_Integrated__MATLABFunction2(-e_off, &rtb_y);

  /* Switch: '<S76>/Switch2' incorporates:
   *  RelationalOperator: '<S76>/LowerRelop1'
   */
  if (!(rtb_y_k > rtb_Switch2_k)) {
    /* Product: '<S23>/delta fall limit' incorporates:
     *  SampleTimeMath: '<S23>/sample time'
     *
     * About '<S23>/sample time':
     *  y = K where K = ( w * Ts )
     *   */
    rtb_y *= 0.002;

    /* Switch: '<S76>/Switch' incorporates:
     *  RelationalOperator: '<S76>/UpperRelop'
     */
    if (rtb_y_k < rtb_y) {
      rtb_Switch2_k = rtb_y;
    } else {
      rtb_Switch2_k = rtb_y_k;
    }

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

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

  /* Sum: '<S23>/Difference Inputs2' incorporates:
   *  Delay: '<S23>/Delay'
   *
   * Block description for '<S23>/Difference Inputs2':
   *
   *  Add in CPU
   */
  rtb_y = rtb_Switch2_k + ADM_Integrated_Logic_DW.Delay_DSTATE_c4;

  /* Outport: '<Root>/GV_Master_Rack_Angle_Cmd' incorporates:
   *  MATLAB Function: '<S1>/RWA_Actuator_Fault_Injection'
   */
  ADM_Integrated_Logic_Y.GV_Master_Rack_Angle_Cmd = rtb_y;

  /* Outport: '<Root>/Target_RWA_Out' incorporates:
   *  MATLAB Function: '<S1>/RWA_Actuator_Fault_Injection'
   */
  ADM_Integrated_Logic_Y.Target_RWA_Out = rtb_y;

  /* MATLAB Function: '<S1>/MATLAB Function5' */
  ADM_Integrated__MATLABFunction1(e_off, &rtb_Switch2_k);

  /* Product: '<S24>/delta rise limit' incorporates:
   *  SampleTimeMath: '<S24>/sample time'
   *
   * About '<S24>/sample time':
   *  y = K where K = ( w * Ts )
   *   */
  rtb_Switch2_k *= 0.002;

  /* Delay: '<S24>/Delay' incorporates:
   *  Inport: '<Root>/GV_RWS_RackAngleCommand'
   */
  if (ADM_Integrated_Logic_DW.icLoad_d) {
    ADM_Integrated_Logic_DW.Delay_DSTATE_i1 =
      ADM_Integrated_Logic_U.GV_RWS_RackAngleCommand;
  }

  /* Sum: '<S24>/Difference Inputs1' incorporates:
   *  Delay: '<S24>/Delay'
   *  Inport: '<Root>/GV_RWS_RackAngleCommand'
   *
   * Block description for '<S24>/Difference Inputs1':
   *
   *  Add in CPU
   */
  rtb_dVx = ADM_Integrated_Logic_U.GV_RWS_RackAngleCommand -
    ADM_Integrated_Logic_DW.Delay_DSTATE_i1;

  /* MATLAB Function: '<S1>/MATLAB Function6' incorporates:
   *  Gain: '<S1>/Gain5'
   */
  ADM_Integrated__MATLABFunction2(-e_off, &rtb_y_k);

  /* Switch: '<S77>/Switch2' incorporates:
   *  RelationalOperator: '<S77>/LowerRelop1'
   */
  if (!(rtb_dVx > rtb_Switch2_k)) {
    /* Product: '<S24>/delta fall limit' incorporates:
     *  SampleTimeMath: '<S24>/sample time'
     *
     * About '<S24>/sample time':
     *  y = K where K = ( w * Ts )
     *   */
    rtb_y_k *= 0.002;

    /* Switch: '<S77>/Switch' incorporates:
     *  RelationalOperator: '<S77>/UpperRelop'
     */
    if (rtb_dVx < rtb_y_k) {
      rtb_Switch2_k = rtb_y_k;
    } else {
      rtb_Switch2_k = rtb_dVx;
    }

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

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

  /* Sum: '<S24>/Difference Inputs2' incorporates:
   *  Delay: '<S24>/Delay'
   *
   * Block description for '<S24>/Difference Inputs2':
   *
   *  Add in CPU
   */
  rtb_y_k = rtb_Switch2_k + ADM_Integrated_Logic_DW.Delay_DSTATE_i1;

  /* Outport: '<Root>/GV_RWS_RackAngleCmd1' */
  ADM_Integrated_Logic_Y.GV_RWS_RackAngleCmd1 = rtb_y_k;

  /* Outport: '<Root>/Act_Fault_Exist' incorporates:
   *  MATLAB Function: '<S1>/Actuator_Fault_Decision'
   */
  ADM_Integrated_Logic_Y.Act_Fault_Exist = 0.0;

  /* MATLAB Function: '<S1>/Actuator_Fault_Decision' incorporates:
   *  Inport: '<Root>/GV_ACU_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_ACU_ECU_Fault_Flag1'
   *  Inport: '<Root>/GV_ACU_ECU_Fault_Flag2'
   *  Inport: '<Root>/GV_ACU_ECU_Fault_Flag3'
   *  Inport: '<Root>/GV_ACU_Fault_Flag'
   *  Inport: '<Root>/GV_Drive_Mode'
   *  Inport: '<Root>/GV_IDB_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_MCU_Actuator_Fault_Flag'
   *  Inport: '<Root>/GV_RCU_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_RWA1_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_RWA2_ECU_Fault_Flag'
   *  Inport: '<Root>/GV_RWA_Actuator_Fault'
   */
  if ((ADM_Integrated_Logic_U.GV_ACU_Fault_Flag == 1.0) ||
      (ADM_Integrated_Logic_U.GV_MCU_Actuator_Fault_Flag == 1.0) ||
      (ADM_Integrated_Logic_U.GV_RWA_Actuator_Fault == 1.0)) {
    /* Outport: '<Root>/Act_Fault_Exist' */
    ADM_Integrated_Logic_Y.Act_Fault_Exist = 1.0;
  }

  if (((ADM_Integrated_Logic_U.GV_ACU_ECU_Fault_Flag == 1.0) ||
       (ADM_Integrated_Logic_U.GV_ACU_ECU_Fault_Flag1 == 1.0) ||
       (ADM_Integrated_Logic_U.GV_ACU_ECU_Fault_Flag2 == 1.0) ||
       (ADM_Integrated_Logic_U.GV_ACU_ECU_Fault_Flag3 == 1.0)) &&
      ((ADM_Integrated_Logic_U.GV_Drive_Mode == 0.0) ||
       (ADM_Integrated_Logic_U.GV_Drive_Mode == 2.0))) {
    /* Outport: '<Root>/Act_Fault_Exist' */
    ADM_Integrated_Logic_Y.Act_Fault_Exist = 1.0;
  }

  if ((ADM_Integrated_Logic_U.GV_IDB_ECU_Fault_Flag == 1.0) ||
      (ADM_Integrated_Logic_U.GV_RCU_ECU_Fault_Flag == 1.0)) {
    /* Outport: '<Root>/Act_Fault_Exist' */
    ADM_Integrated_Logic_Y.Act_Fault_Exist = 1.0;
  } else if ((ADM_Integrated_Logic_U.GV_RWA1_ECU_Fault_Flag == 1.0) &&
             (ADM_Integrated_Logic_U.GV_RWA2_ECU_Fault_Flag == 1.0)) {
    /* Outport: '<Root>/Act_Fault_Exist' */
    ADM_Integrated_Logic_Y.Act_Fault_Exist = 1.0;
  }

  /* Update for UnitDelay: '<S13>/d1' incorporates:
   *  Inport: '<Root>/GV_IMU_AX_Val'
   */
  ADM_Integrated_Logic_DW.d1_DSTATE = ADM_Integrated_Logic_U.GV_IMU_AX_Val;

  /* Update for UnitDelay: '<S13>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE = rtb_Product1;

  /* Update for DiscreteIntegrator: '<S11>/Integrator_2' incorporates:
   *  Constant: '<S11>/I_gain'
   *  Constant: '<S11>/P_gain'
   *  DiscreteIntegrator: '<S11>/Integrator_1'
   *  Product: '<S11>/Product'
   *  Product: '<S11>/Product1'
   *  Sum: '<S11>/Sum1'
   *  Sum: '<S11>/Sum2'
   */
  ADM_Integrated_Logic_DW.Integrator_2_DSTATE += (rtb_Integrator_1 -
    (ADM_Integrated_Logic_DW.Integrator_1_DSTATE * 5.0 + rtb_Brake_Control *
     100.0)) * 0.002;

  /* Update for Delay: '<S70>/Delay' */
  ADM_Integrated_Logic_DW.icLoad = false;
  ADM_Integrated_Logic_DW.Delay_DSTATE = rtb_Pitch_Angle;

  /* Update for Delay: '<S69>/Delay' */
  ADM_Integrated_Logic_DW.icLoad_e = false;
  ADM_Integrated_Logic_DW.Delay_DSTATE_i = rtb_Saturation;

  /* Update for Delay: '<S10>/Memory' */
  ADM_Integrated_Logic_DW.Memory_DSTATE = rtb_Memory;

  /* Update for DiscreteIntegrator: '<S28>/Discrete-Time Integrator' incorporates:
   *  Memory: '<S28>/Memory'
   *  Sum: '<S28>/Sum1'
   */
  ADM_Integrated_Logic_DW.DiscreteTimeIntegrator_DSTATE += (rtb_Product2_a -
    ADM_Integrated_Logic_DW.Memory_PreviousInput_f) * 0.002;

  /* Update for UnitDelay: '<S31>/UD'
   *
   * Block description for '<S31>/UD':
   *
   *  Store in Global RAM
   */
  ADM_Integrated_Logic_DW.UD_DSTATE = rtb_TSamp;

  /* Update for DiscreteTransferFcn: '<S1>/Discrete Transfer Fcn' */
  ADM_Integrated_Logic_DW.DiscreteTransferFcn_states = rtb_Vx_Cmd_R - -0.9375 *
    ADM_Integrated_Logic_DW.DiscreteTransferFcn_states;

  /* Update for UnitDelay: '<S38>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_c = rtb_AccFlag;

  /* Update for UnitDelay: '<S38>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_l = rtb_Target_RPM;

  /* Update for UnitDelay: '<S51>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_i = rtb_Target_RPM;

  /* Update for UnitDelay: '<S51>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_p = rtb_Sum1_i2;

  /* Update for UnitDelay: '<S52>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_c = rtb_Sum1_i2;

  /* Update for UnitDelay: '<S52>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_h = rtb_Sum1_o1;

  /* Update for UnitDelay: '<S53>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_d = rtb_Sum1_o1;

  /* Update for UnitDelay: '<S53>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_l = rtb_Sum1_lm;

  /* Update for Delay: '<S55>/Delay1' */
  ADM_Integrated_Logic_DW.Delay1_DSTATE = rtb_Gain_c;

  /* Update for Delay: '<S55>/Delay' */
  ADM_Integrated_Logic_DW.Delay_DSTATE_c[0] =
    ADM_Integrated_Logic_DW.Delay_DSTATE_c[1];
  ADM_Integrated_Logic_DW.Delay_DSTATE_c[1] = rtb_Gain_c;

  /* Update for Delay: '<S55>/Delay2' */
  ADM_Integrated_Logic_DW.Delay2_DSTATE = rtb_Product1_pd;

  /* Update for Delay: '<S55>/Delay3' */
  ADM_Integrated_Logic_DW.Delay3_DSTATE[0] =
    ADM_Integrated_Logic_DW.Delay3_DSTATE[1];
  ADM_Integrated_Logic_DW.Delay3_DSTATE[1] = rtb_Product1_pd;

  /* Update for UnitDelay: '<S54>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_e = rtb_Product1_pd;

  /* Update for UnitDelay: '<S54>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_ij = rtb_Product1_m;

  /* Update for Memory: '<S6>/Memory' */
  ADM_Integrated_Logic_DW.Memory_PreviousInput = rtb_Add;

  /* Update for UnitDelay: '<S43>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_ir = rtb_Target_RPM;

  /* Update for UnitDelay: '<S43>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_o = rtb_Error_m;

  /* Update for UnitDelay: '<S44>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_m = rtb_Error_m;

  /* Update for UnitDelay: '<S44>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_hm = rtb_Sum1_aj;

  /* Update for UnitDelay: '<S45>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_mw = rtb_Sum1_aj;

  /* Update for UnitDelay: '<S45>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_g = rtb_Sum1_p;

  /* Update for UnitDelay: '<S46>/d1' */
  ADM_Integrated_Logic_DW.d1_DSTATE_ej = rtb_Add3;

  /* Update for UnitDelay: '<S46>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_j = rtb_Product1_k3;

  /* Update for Delay: '<S47>/Delay1' */
  ADM_Integrated_Logic_DW.Delay1_DSTATE_c = rtb_Product1_k3;

  /* Update for Delay: '<S47>/Delay' */
  ADM_Integrated_Logic_DW.Delay_DSTATE_p[0] =
    ADM_Integrated_Logic_DW.Delay_DSTATE_p[1];
  ADM_Integrated_Logic_DW.Delay_DSTATE_p[1] = rtb_Product1_k3;

  /* Update for Delay: '<S47>/Delay2' */
  ADM_Integrated_Logic_DW.Delay2_DSTATE_n = rtb_Product1_h;

  /* Update for Delay: '<S47>/Delay3' */
  ADM_Integrated_Logic_DW.Delay3_DSTATE_h[0] =
    ADM_Integrated_Logic_DW.Delay3_DSTATE_h[1];
  ADM_Integrated_Logic_DW.Delay3_DSTATE_h[1] = rtb_Product1_h;

  /* Update for Memory: '<S28>/Memory' */
  ADM_Integrated_Logic_DW.Memory_PreviousInput_f = DiscreteTransferFcn;

  /* Update for UnitDelay: '<S64>/d1' incorporates:
   *  Inport: '<Root>/GV_IMU_AX_Val'
   */
  ADM_Integrated_Logic_DW.d1_DSTATE_ob = ADM_Integrated_Logic_U.GV_IMU_AX_Val;

  /* Update for UnitDelay: '<S64>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_e = rtb_Desired_Torque;

  /* Update for UnitDelay: '<S65>/d1' incorporates:
   *  Inport: '<Root>/GV_IMU_AY_Val'
   */
  ADM_Integrated_Logic_DW.d1_DSTATE_i = ADM_Integrated_Logic_U.GV_IMU_AY_Val;

  /* Update for UnitDelay: '<S65>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_p = rtb_Brake_Torque_Cmd;

  /* Update for UnitDelay: '<S66>/d1' incorporates:
   *  Inport: '<Root>/GV_IMU_AZ_Val'
   */
  ADM_Integrated_Logic_DW.d1_DSTATE_o1 = ADM_Integrated_Logic_U.GV_IMU_AZ_Val;

  /* Update for UnitDelay: '<S66>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_n = rtb_Product_h;

  /* Update for DiscreteIntegrator: '<S11>/Integrator_1' */
  ADM_Integrated_Logic_DW.Integrator_1_DSTATE += 0.002 * rtb_Brake_Control;

  /* Update for UnitDelay: '<S67>/d1' incorporates:
   *  Inport: '<Root>/GV_IMU_PitchRtVal'
   */
  ADM_Integrated_Logic_DW.d1_DSTATE_a = ADM_Integrated_Logic_U.GV_IMU_PitchRtVal;

  /* Update for UnitDelay: '<S67>/d' */
  ADM_Integrated_Logic_DW.d_DSTATE_d1 = rtb_Integrator_1;

  /* Update for Delay: '<S23>/Delay' */
  ADM_Integrated_Logic_DW.icLoad_l = false;
  ADM_Integrated_Logic_DW.Delay_DSTATE_c4 = rtb_y;

  /* Update for Delay: '<S24>/Delay' */
  ADM_Integrated_Logic_DW.icLoad_d = false;
  ADM_Integrated_Logic_DW.Delay_DSTATE_i1 = rtb_y_k;
}

/* Model initialize function */
void ADM_Integrated_Logic_initialize(void)
{
  /* Registration code */

  /* initialize non-finites */
  rt_InitInfAndNaN(sizeof(double));

  /* InitializeConditions for Delay: '<S70>/Delay' */
  ADM_Integrated_Logic_DW.icLoad = true;

  /* InitializeConditions for Delay: '<S69>/Delay' */
  ADM_Integrated_Logic_DW.icLoad_e = true;

  /* InitializeConditions for Delay: '<S23>/Delay' */
  ADM_Integrated_Logic_DW.icLoad_l = true;

  /* InitializeConditions for Delay: '<S24>/Delay' */
  ADM_Integrated_Logic_DW.icLoad_d = true;

  /* SystemInitialize for MATLAB Function: '<S6>/Mode_and_blend' */
  ADM_Integrated_Logic_DW.t_hold = 1.0E+9;
  ADM_Integrated_Logic_DW.w = 0.5;

  /* SystemInitialize for MATLAB Function: '<S1>/MATLAB Function3' */
  ADM_Integrated_Logic_DW.currentEstMass = 1500.0;
}

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