/*
 * File: IOS_INP.c
 *
 * Code generated for Simulink model 'IOS_INP'.
 *
 * Model version                  : 1.1
 * Simulink Coder version         : 8.13 (R2017b) 24-Jul-2017
 * C/C++ source code generated on : Tue Jun 16 14:22:00 2020
 *
 * Target selection: ert.tlc
 * Embedded hardware selection: Generic->Unspecified (assume 32-bit Generic)
 * Code generation objectives: Unspecified
 * Validation result: Not run
 */

#include "IOS_INP.h"
#include "IOS_INP_private.h"

/* Exported data definition */

/* ConstVolatile memory section */
#define ASW1_OEM_START_SEC_DEFAULT_CALIB_16
#include "Asw1_OEM_MemMap.h"

/* Definition for custom storage class: ConstVolatile_16 */
const volatile real32_T KeINP_VehSpdVal = 0.0F;
const volatile uint16_T KeINP_YearSetVal = 2018U;
const volatile real32_T KeINP_dcCrashPwmDutyOutDetVal = 0.0F;
const volatile real32_T KeINP_dcCrashPwmDutyVal = 0.0F;
const volatile real32_T KeINP_dcHvilPwmDutyInpVal = 0.0F;
const volatile real32_T KeINP_dcHvilPwmDutyOutDetVal = 0.0F;
const volatile real32_T KeINP_eOutpEnrgCsdVal = 0.0F;
const volatile real32_T KeINP_effObcChrgVal = 0.0F;
const volatile real32_T KeINP_fCrashPwmFrqOutDetVal = 714.0F;
const volatile real32_T KeINP_fCrashPwmFrqVal = 714.0F;
const volatile real32_T KeINP_fHvilPwmFrqOutDetVal = 1000.0F;
const volatile real32_T KeINP_fHvilPwmFrqVal = 1000.0F;
const volatile real32_T KeINP_iBattCurr_mAVal = -2.14748365E+9F;
const volatile real32_T KeINP_iCurrObcChrgVal = -50.0F;
const volatile real32_T KeINP_iDcChrgMaxCurrOutputPmtdCmlVal = -400.0F;
const volatile real32_T KeINP_iDcChrgMinCurrOutputPmtdCmlVal = -400.0F;
const volatile real32_T KeINP_iDcChrgOutputCurrCcsVal = -400.0F;
const volatile real32_T KeINP_iMaxAChrgCurrVal = 0.0F;
const volatile real32_T KeINP_iMaxCurrObcChrgVal = 0.0F;
const volatile real32_T KeINP_pCompOptPwrReqVal = 0.0F;
const volatile real32_T KeINP_pPTCOptPwrReqVal = 0.0F;
const volatile real32_T KeINP_phiAPPVal = 0.0F;
const volatile real32_T KeINP_pwrChrgLdReqVal = 0.0F;
const volatile real32_T KeINP_pwrEvseMaxPwrLmtVal = 0.0F;
const volatile real32_T KeINP_tEnvTVal = -80.0F;
const volatile real32_T KeINP_tiChrgTimeCsdVal = 0.0F;
const volatile real32_T KeINP_tiDcChrgTimeActualCcsVal = 0.0F;
const volatile real32_T KeINP_uAdCurrVal = 0.0F;
const volatile real32_T KeINP_uBattVoltVal = 0.0F;
const volatile real32_T KeINP_uCC2VoltVal = 0.0F;
const volatile real32_T KeINP_uCCVoltVal = 0.0F;
const volatile real32_T KeINP_uCabCurrVal = 0.0F;
const volatile real32_T KeINP_uClntDsTVal = 0.0F;
const volatile real32_T KeINP_uClntUsTVal = 0.0F;
const volatile real32_T KeINP_uDCWkUpVal = 0.0F;
const volatile real32_T KeINP_uDChrgNegTempVal = 0.0F;
const volatile real32_T KeINP_uDChrgPosTempVal = 0.0F;
const volatile real32_T KeINP_uDChrgVoltVal = 0.0F;
const volatile real32_T KeINP_uDcChNegCtrHsdCurrVal = 0.0F;
const volatile real32_T KeINP_uDcChNegCtrLsdVoltVal = 0.0F;
const volatile real32_T KeINP_uDcChPosCtrHsdCurrVal = 0.0F;
const volatile real32_T KeINP_uDcChPosCtrLsdVoltVal = 0.0F;
const volatile real32_T KeINP_uDcChrgMaxVoltOutputPmtdCmlVal = 0.0F;
const volatile real32_T KeINP_uDcChrgMinVoltOutputPmtdCmlVal = 0.0F;
const volatile real32_T KeINP_uDchrgNegVoltVal = 0.0F;
const volatile real32_T KeINP_uEvseOutputVoltVal = 0.0F;
const volatile real32_T KeINP_uHwSplyVoltVal = 0.0F;
const volatile real32_T KeINP_uIsoPosVoltVal = 0.0F;
const volatile real32_T KeINP_uKl30Val = 0.0F;
const volatile real32_T KeINP_uKl30cVal = 0.0F;
const volatile real32_T KeINP_uMNegCtrHsdCurrVal = 0.0F;
const volatile real32_T KeINP_uMNegCtrHsdVoltVal = 0.0F;
const volatile real32_T KeINP_uMPosCtrHsdCurrVal = 0.0F;
const volatile real32_T KeINP_uMPosCtrHsdVoltVal = 0.0F;
const volatile real32_T KeINP_uMaxVoltObcChrgVal = 0.0F;
const volatile real32_T KeINP_uMcuVoltVal = 0.0F;
const volatile real32_T KeINP_uNegVoltVal = 0.0F;
const volatile real32_T KeINP_uPackVoltVal = 0.0F;
const volatile real32_T KeINP_uReservedSig1Val = 0.0F;
const volatile real32_T KeINP_uReservedSig2Val = 0.0F;
const volatile real32_T KeINP_uReservedSig3Val = 0.0F;
const volatile real32_T KeINP_uReservedSig4Val = 0.0F;
const volatile real32_T KeINP_uReservedSig5Val = 0.0F;
const volatile real32_T KeINP_uReservedSig6Val = 0.0F;
const volatile real32_T KeINP_uReservedSig7Val = 0.0F;
const volatile real32_T KeINP_uReservedSig8Val = 0.0F;
const volatile real32_T KeINP_uVoltObcChrgVal = 0.0F;
const volatile real32_T KeINP_vDcChrgOutputVoltCcsVal = 0.0F;
const volatile real32_T KeINP_valAcmDistVal = 0.0F;

#define ASW1_OEM_STOP_SEC_DEFAULT_CALIB_16
#include "Asw1_OEM_MemMap.h"

/* ConstVolatile memory section */
#define ASW1_OEM_START_SEC_DEFAULT_CALIB_32
#include "Asw1_OEM_MemMap.h"

/* Definition for custom storage class: ConstVolatile_32 */
const volatile uint32_T KeINP_Reserved1Val = 1U;
const volatile uint32_T KeINP_Reserved2Val = 0U;
const volatile uint32_T KeINP_numChrgerNumCsdVal = 1U;
const volatile uint32_T KeINP_numComVerVal = 0U;

#define ASW1_OEM_STOP_SEC_DEFAULT_CALIB_32
#include "Asw1_OEM_MemMap.h"

/* ConstVolatile memory section */
#define ASW1_OEM_START_SEC_DEFAULT_CALIB_8
#include "Asw1_OEM_MemMap.h"

/* Definition for custom storage class: ConstVolatile_8 */
const volatile boolean_T KeINP_ABM050DataAvailableVal = 0;
const volatile boolean_T KeINP_ACCharger0x2E1MessageAvailableVal = 0;
const volatile boolean_T KeINP_ACCharger0x2E6MessageAvailableVal = 0;
const volatile boolean_T KeINP_DFC_DcCanBusOffVal = 0;
const volatile boolean_T KeINP_DFC_VeCanBusOffVal = 0;
const volatile uint8_T KeINP_DaySetVal = 1U;
const volatile boolean_T KeINP_GW2ADDataAvailableVal = 0;
const volatile boolean_T KeINP_GW2BBDataAvailableVal = 0;
const volatile uint8_T KeINP_HourSetVal = 0U;
const volatile uint8_T KeINP_MinSetVal = 0U;
const volatile uint8_T KeINP_MonthSetVal = 1U;
const volatile boolean_T KeINP_NMActwakeVal = 0;
const volatile boolean_T KeINP_NMRepeatReqVal = 0;
const volatile uint8_T KeINP_SecondSetVal = 0U;
const volatile boolean_T KeINP_VCU2A3DataAvailableVal = 0;
const volatile boolean_T KeINP_VCU2A5DataAvailableVal = 0;
const volatile boolean_T KeINP_VCU2A7DataAvailableVal = 0;
const volatile boolean_T KeINP_VehSpdVldVal = 0;
const volatile boolean_T KeINP_bACWkUpFlg = 0;
const volatile uint8_T KeINP_bACWkUpVal = 0U;
const volatile boolean_T KeINP_bAdCurrFlg = 0;
const volatile boolean_T KeINP_bBM050DataAvailableFlg = 0;
const volatile boolean_T KeINP_bBattCurr_mAFlg = 0;
const volatile boolean_T KeINP_bBattVoltFlg = 0;
const volatile boolean_T KeINP_bCC2VoltFlg = 0;
const volatile boolean_T KeINP_bCCVoltFlg = 0;
const volatile boolean_T KeINP_bCCharger0x2E1MessageAvailableFlg = 0;
const volatile boolean_T KeINP_bCCharger0x2E6MessageAvailableFlg = 0;
const volatile boolean_T KeINP_bCU2A3DataAvailableFlg = 0;
const volatile boolean_T KeINP_bCU2A5DataAvailableFlg = 0;
const volatile boolean_T KeINP_bCU2A7DataAvailableFlg = 0;
const volatile boolean_T KeINP_bCabCurrFlg = 0;
const volatile boolean_T KeINP_bCabErrStatusFlg = 0;
const volatile boolean_T KeINP_bCabErrStatusVal = 0;
const volatile boolean_T KeINP_bChrgStopActiveFlg = 0;
const volatile boolean_T KeINP_bChrgStopActiveVal = 0;
const volatile boolean_T KeINP_bClntDsTFlg = 0;
const volatile boolean_T KeINP_bClntUsTFlg = 0;
const volatile boolean_T KeINP_bCompOptPwrReqFlg = 0;
const volatile boolean_T KeINP_bCrashPwmFrqFlg = 0;
const volatile boolean_T KeINP_bCrashPwmFrqOutDetFlg = 0;
const volatile boolean_T KeINP_bCurrObcChrgFlg = 0;
const volatile boolean_T KeINP_bDCWkUpFlg = 0;
const volatile boolean_T KeINP_bDChrgNegTempFlg = 0;
const volatile boolean_T KeINP_bDChrgPosTempFlg = 0;
const volatile boolean_T KeINP_bDChrgVoltFlg = 0;
const volatile boolean_T KeINP_bDcChNegCtrHsdCurrFlg = 0;
const volatile boolean_T KeINP_bDcChNegCtrLsdVoltFlg = 0;
const volatile boolean_T KeINP_bDcChPosCtrHsdCurrFlg = 0;
const volatile boolean_T KeINP_bDcChPosCtrLsdVoltFlg = 0;
const volatile boolean_T KeINP_bDcChrgMaxCurrOutputPmtdCmlFlg = 0;
const volatile boolean_T KeINP_bDcChrgMaxVoltOutputPmtdCmlFlg = 0;
const volatile boolean_T KeINP_bDcChrgMinCurrOutputPmtdCmlFlg = 0;
const volatile boolean_T KeINP_bDcChrgMinVoltOutputPmtdCmlFlg = 0;
const volatile boolean_T KeINP_bDcChrgOutputCurrCcsFlg = 0;
const volatile boolean_T KeINP_bDcChrgOutputVoltCcsFlg = 0;
const volatile boolean_T KeINP_bDchrgNegVoltFlg = 0;
const volatile boolean_T KeINP_bEnvTFlg = 0;
const volatile boolean_T KeINP_bEvseOutputVoltFlg = 0;
const volatile boolean_T KeINP_bFC_DcCanBusOffFlg = 0;
const volatile boolean_T KeINP_bFC_VeCanBusOffFlg = 0;
const volatile boolean_T KeINP_bHvilPwmFrqFlg = 0;
const volatile boolean_T KeINP_bHvilPwmFrqOutDetFlg = 0;
const volatile boolean_T KeINP_bHwSplyVoltFlg = 0;
const volatile boolean_T KeINP_bIsoPosVoltFlg = 0;
const volatile boolean_T KeINP_bIviDischgOrdFlg = 0;
const volatile boolean_T KeINP_bIviDischgOrdVal = 0;
const volatile boolean_T KeINP_bKl15WkUpFlg = 0;
const volatile uint8_T KeINP_bKl15WkUpVal = 0U;
const volatile boolean_T KeINP_bKl30Flg = 0;
const volatile boolean_T KeINP_bKl30cFlg = 0;
const volatile boolean_T KeINP_bLeadAcidChgHvOnFlg = 0;
const volatile boolean_T KeINP_bLeadAcidChgHvOnVal = 0;
const volatile boolean_T KeINP_bMActwakeFlg = 0;
const volatile boolean_T KeINP_bMNegCtrHsdCurrFlg = 0;
const volatile boolean_T KeINP_bMNegCtrHsdVoltFlg = 0;
const volatile boolean_T KeINP_bMPosCtrHsdCurrFlg = 0;
const volatile boolean_T KeINP_bMPosCtrHsdVoltFlg = 0;
const volatile boolean_T KeINP_bMRepeatReqFlg = 0;
const volatile boolean_T KeINP_bMaxAChrgCurrFlg = 0;
const volatile boolean_T KeINP_bMaxCurrObcChrgFlg = 0;
const volatile boolean_T KeINP_bMaxVoltObcChrgFlg = 0;
const volatile boolean_T KeINP_bMcuVoltFlg = 0;
const volatile boolean_T KeINP_bNegVoltFlg = 0;
const volatile boolean_T KeINP_bOutpEnrgCsdFlg = 0;
const volatile boolean_T KeINP_bPTCOptPwrReqFlg = 0;
const volatile boolean_T KeINP_bPackVoltFlg = 0;
const volatile boolean_T KeINP_bReservedSig1Flg = 0;
const volatile boolean_T KeINP_bReservedSig2Flg = 0;
const volatile boolean_T KeINP_bReservedSig3Flg = 0;
const volatile boolean_T KeINP_bReservedSig4Flg = 0;
const volatile boolean_T KeINP_bReservedSig5Flg = 0;
const volatile boolean_T KeINP_bReservedSig6Flg = 0;
const volatile boolean_T KeINP_bReservedSig7Flg = 0;
const volatile boolean_T KeINP_bReservedSig8Flg = 0;
const volatile boolean_T KeINP_bVcuChrgDisableFlg = 0;
const volatile boolean_T KeINP_bVcuChrgDisableVal = 0;
const volatile boolean_T KeINP_bVoltObcChrgFlg = 0;
const volatile boolean_T KeINP_bW2ADDataAvailableFlg = 0;
const volatile boolean_T KeINP_bW2BBDataAvailableFlg = 0;
const volatile boolean_T KeINP_balAcmDistFlg = 0;
const volatile boolean_T KeINP_balChkSumMsg050Flg = 0;
const volatile boolean_T KeINP_balChkSumMsg2A3Flg = 0;
const volatile boolean_T KeINP_balChkSumMsg2A5Flg = 0;
const volatile boolean_T KeINP_balChkSumMsg2A7Flg = 0;
const volatile boolean_T KeINP_balChkSumMsg2E1Flg = 0;
const volatile boolean_T KeINP_balChkSumMsg2E6Flg = 0;
const volatile boolean_T KeINP_balChkSumMsg2EBFlg = 0;
const volatile boolean_T KeINP_balVinCode_AFlg = 0;
const volatile boolean_T KeINP_balVinCode_BFlg = 0;
const volatile boolean_T KeINP_balVinCode_CFlg = 0;
const volatile boolean_T KeINP_balVinCode_DFlg = 0;
const volatile boolean_T KeINP_balVinCode_EFlg = 0;
const volatile boolean_T KeINP_balVinCode_FFlg = 0;
const volatile boolean_T KeINP_balVinCode_GFlg = 0;
const volatile boolean_T KeINP_baySetFlg = 0;
const volatile boolean_T KeINP_bcCrashPwmDutyFlg = 0;
const volatile boolean_T KeINP_bcCrashPwmDutyOutDetFlg = 0;
const volatile boolean_T KeINP_bcHvilPwmDutyInpFlg = 0;
const volatile boolean_T KeINP_bcHvilPwmDutyOutDetFlg = 0;
const volatile boolean_T KeINP_bcObcCPFlg = 0;
const volatile boolean_T KeINP_bearSetFlg = 0;
const volatile boolean_T KeINP_becondSetFlg = 0;
const volatile boolean_T KeINP_behSpdFlg = 0;
const volatile boolean_T KeINP_behSpdVldFlg = 0;
const volatile boolean_T KeINP_beserved1Flg = 0;
const volatile boolean_T KeINP_beserved2Flg = 0;
const volatile boolean_T KeINP_bffObcChrgFlg = 0;
const volatile boolean_T KeINP_bhiAPPFlg = 0;
const volatile boolean_T KeINP_biChrgTimeCsdFlg = 0;
const volatile boolean_T KeINP_biDcChrgTimeActualCcsFlg = 0;
const volatile boolean_T KeINP_binSetFlg = 0;
const volatile boolean_T KeINP_blgAPPInvldFlg = 0;
const volatile boolean_T KeINP_blgAcmDistVldFlg = 0;
const volatile boolean_T KeINP_blgBrkPedInvldFlg = 0;
const volatile boolean_T KeINP_blgVcuActSrce_AFlg = 0;
const volatile boolean_T KeINP_blgVcuActSrce_BFlg = 0;
const volatile boolean_T KeINP_blgVcuActSrce_CFlg = 0;
const volatile boolean_T KeINP_blgVcuActSrce_DFlg = 0;
const volatile boolean_T KeINP_blgVcuActSrce_EFlg = 0;
const volatile boolean_T KeINP_blgVcuNormFromRdyFlg = 0;
const volatile boolean_T KeINP_blgVcuNormFromRptFlg = 0;
const volatile boolean_T KeINP_blgVcuRptFromNormFlg = 0;
const volatile boolean_T KeINP_blgVcuRptFromPreprFlg = 0;
const volatile boolean_T KeINP_blgVcuRptFromRdyFlg = 0;
const volatile boolean_T KeINP_blgVcuRptFromSlpFlg = 0;
const volatile boolean_T KeINP_blgVcuSrceIDFlg = 0;
const volatile boolean_T KeINP_blgVcuWkSrceFlg = 0;
const volatile boolean_T KeINP_bntRCMsg050Flg = 0;
const volatile boolean_T KeINP_bntRCMsg2A3Flg = 0;
const volatile boolean_T KeINP_bntRCMsg2A5Flg = 0;
const volatile boolean_T KeINP_bntRCMsg2A7Flg = 0;
const volatile boolean_T KeINP_bntRCMsg2E1Flg = 0;
const volatile boolean_T KeINP_bntRCMsg2E6Flg = 0;
const volatile boolean_T KeINP_bntRCMsg2EBFlg = 0;
const volatile boolean_T KeINP_bntVinCodeNumFlg = 0;
const volatile boolean_T KeINP_bonthSetFlg = 0;
const volatile boolean_T KeINP_bourSetFlg = 0;
const volatile boolean_T KeINP_btAppChrgOrdCmdFlg = 0;
const volatile boolean_T KeINP_btAppChrgOrdStartFlg = 0;
const volatile boolean_T KeINP_btBmsStopActCstFlg = 0;
const volatile boolean_T KeINP_btCabErrInfoFlg = 0;
const volatile boolean_T KeINP_btChrgCurrAbnrmCstFlg = 0;
const volatile boolean_T KeINP_btChrgErrStopCstFlg = 0;
const volatile boolean_T KeINP_btChrgRdyCroFlg = 0;
const volatile boolean_T KeINP_btChrgVoltAbnrmCstFlg = 0;
const volatile boolean_T KeINP_btChrgerCnntErrCstFlg = 0;
const volatile boolean_T KeINP_btChrgerInrOvrTempErrCstFlg = 0;
const volatile boolean_T KeINP_btChrgerOvrTempErrCstFlg = 0;
const volatile boolean_T KeINP_btChrgerSrmErrCstFlg = 0;
const volatile boolean_T KeINP_btCpStateFlg = 0;
const volatile boolean_T KeINP_btCrashInptFlg = 0;
const volatile boolean_T KeINP_btCrashOutpFdbkFlg = 0;
const volatile boolean_T KeINP_btCrashSglFlg = 0;
const volatile boolean_T KeINP_btDcAcChgModeFlg = 0;
const volatile boolean_T KeINP_btDcChrgCmdCcsFlg = 0;
const volatile boolean_T KeINP_btElecModFlg = 0;
const volatile boolean_T KeINP_btEnrgTxAbnrmErrCstFlg = 0;
const volatile boolean_T KeINP_btHVILInpFlg = 0;
const volatile boolean_T KeINP_btHVILOutpFdbkFlg = 0;
const volatile boolean_T KeINP_btIdtfRstCrmFlg = 0;
const volatile boolean_T KeINP_btInletLockFlg = 0;
const volatile boolean_T KeINP_btLockAlarmFlg = 0;
const volatile boolean_T KeINP_btMnlStopCstFlg = 0;
const volatile boolean_T KeINP_btOTAModeFlg = 0;
const volatile boolean_T KeINP_btObcCCFlg = 0;
const volatile boolean_T KeINP_btObcCPFlg = 0;
const volatile boolean_T KeINP_btObcChrgFlg = 0;
const volatile boolean_T KeINP_btObcElecLckFlg = 0;
const volatile boolean_T KeINP_btObcFaultLvlFlg = 0;
const volatile boolean_T KeINP_btOtherErrCstFlg = 0;
const volatile boolean_T KeINP_btPdStateFlg = 0;
const volatile boolean_T KeINP_btPreCoolWkFlg = 0;
const volatile boolean_T KeINP_btPreHeatlWkFlg = 0;
const volatile boolean_T KeINP_btPreThmEnaFlg = 0;
const volatile boolean_T KeINP_btPreThmVcuPmtFlg = 0;
const volatile boolean_T KeINP_btPwrUpDwnVcuReqFlg = 0;
const volatile boolean_T KeINP_btRchSetCondCstFlg = 0;
const volatile boolean_T KeINP_btRcvBclTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btRcvBcpTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btRcvBcsTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btRcvBrmTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btRcvBroOkTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btRcvBsdTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btRcvBstTimeOutCemFlg = 0;
const volatile boolean_T KeINP_btS2Flg = 0;
const volatile boolean_T KeINP_btS2OnFlg = 0;
const volatile boolean_T KeINP_btSysModeMagFlg = 0;
const volatile boolean_T KeINP_btSysNetWkUpFlg = 0;
const volatile boolean_T KeINP_btSysWkUpSrcFlg = 0;
const volatile boolean_T KeINP_btVcuFalutLvlFlg = 0;
const volatile boolean_T KeINP_btVcuWrkFlg = 0;
const volatile boolean_T KeINP_bumChrgerNumCsdFlg = 0;
const volatile boolean_T KeINP_bumComVerFlg = 0;
const volatile boolean_T KeINP_bwrChrgLdReqFlg = 0;
const volatile boolean_T KeINP_bwrEvseMaxPwrLmtFlg = 0;
const volatile boolean_T KeINP_bwtBrkPedFlg = 0;
const volatile uint8_T KeINP_cntRCMsg050Val = 0U;
const volatile uint8_T KeINP_cntRCMsg2A3Val = 0U;
const volatile uint8_T KeINP_cntRCMsg2A5Val = 0U;
const volatile uint8_T KeINP_cntRCMsg2A7Val = 0U;
const volatile uint8_T KeINP_cntRCMsg2E1Val = 0U;
const volatile uint8_T KeINP_cntRCMsg2E6Val = 0U;
const volatile uint8_T KeINP_cntRCMsg2EBVal = 0U;
const volatile uint8_T KeINP_cntVinCodeNumVal = 0U;
const volatile uint8_T KeINP_dcObcCPVal = 0U;
const volatile uint8_T KeINP_flgAPPInvldVal = 0U;
const volatile boolean_T KeINP_flgAcmDistVldVal = 0;
const volatile boolean_T KeINP_flgBrkPedInvldVal = 0;
const volatile boolean_T KeINP_flgVcuActSrce_AVal = 0;
const volatile boolean_T KeINP_flgVcuActSrce_BVal = 0;
const volatile boolean_T KeINP_flgVcuActSrce_CVal = 0;
const volatile boolean_T KeINP_flgVcuActSrce_DVal = 0;
const volatile boolean_T KeINP_flgVcuActSrce_EVal = 0;
const volatile boolean_T KeINP_flgVcuNormFromRdyVal = 0;
const volatile boolean_T KeINP_flgVcuNormFromRptVal = 0;
const volatile boolean_T KeINP_flgVcuRptFromNormVal = 0;
const volatile boolean_T KeINP_flgVcuRptFromPreprVal = 0;
const volatile boolean_T KeINP_flgVcuRptFromRdyVal = 0;
const volatile boolean_T KeINP_flgVcuRptFromSlpVal = 0;
const volatile uint8_T KeINP_flgVcuSrceIDVal = 0U;
const volatile boolean_T KeINP_flgVcuWkSrceVal = 0;
const volatile uint8_T KeINP_stAppChrgOrdCmdVal = 0U;
const volatile uint8_T KeINP_stAppChrgOrdStartVal = 0U;
const volatile uint8_T KeINP_stBmsStopActCstVal = 0U;
const volatile uint8_T KeINP_stCabErrInfoVal = 0U;
const volatile uint8_T KeINP_stChrgCurrAbnrmCstVal = 0U;
const volatile uint8_T KeINP_stChrgErrStopCstVal = 0U;
const volatile uint8_T KeINP_stChrgRdyCroVal = 0U;
const volatile uint8_T KeINP_stChrgVoltAbnrmCstVal = 0U;
const volatile uint8_T KeINP_stChrgerCnntErrCstVal = 0U;
const volatile uint8_T KeINP_stChrgerInrOvrTempErrCstVal = 0U;
const volatile uint8_T KeINP_stChrgerOvrTempErrCstVal = 0U;
const volatile uint8_T KeINP_stChrgerSrmErrCstVal = 0U;
const volatile uint8_T KeINP_stCpStateVal = 0U;
const volatile uint8_T KeINP_stCrashInptVal = 0U;
const volatile uint8_T KeINP_stCrashOutpFdbkVal = 0U;
const volatile uint8_T KeINP_stCrashSglVal = 0U;
const volatile uint8_T KeINP_stDcAcChgModeVal = 0U;
const volatile uint8_T KeINP_stDcChrgCmdCcsVal = 0U;
const volatile uint8_T KeINP_stElecModVal = 0U;
const volatile uint8_T KeINP_stEnrgTxAbnrmErrCstVal = 0U;
const volatile uint8_T KeINP_stHVILInpVal = 0U;
const volatile uint8_T KeINP_stHVILOutpFdbkVal = 0U;
const volatile uint8_T KeINP_stIdtfRstCrmVal = 0U;
const volatile uint8_T KeINP_stInletLockVal = 0U;
const volatile uint8_T KeINP_stLockAlarmVal = 0U;
const volatile uint8_T KeINP_stMnlStopCstVal = 0U;
const volatile boolean_T KeINP_stOTAModeVal = 0;
const volatile uint8_T KeINP_stObcCCVal = 0U;
const volatile uint8_T KeINP_stObcCPVal = 0U;
const volatile uint8_T KeINP_stObcChrgVal = 0U;
const volatile uint8_T KeINP_stObcElecLckVal = 0U;
const volatile uint8_T KeINP_stObcFaultLvlVal = 0U;
const volatile uint8_T KeINP_stOtherErrCstVal = 0U;
const volatile uint8_T KeINP_stPdStateVal = 0U;
const volatile boolean_T KeINP_stPreCoolWkVal = 0;
const volatile boolean_T KeINP_stPreHeatlWkVal = 0;
const volatile uint8_T KeINP_stPreThmEnaVal = 0U;
const volatile uint8_T KeINP_stPreThmVcuPmtVal = 0U;
const volatile uint8_T KeINP_stPwrUpDwnVcuReqVal = 0U;
const volatile uint8_T KeINP_stRchSetCondCstVal = 0U;
const volatile uint8_T KeINP_stRcvBclTimeOutCemVal = 0U;
const volatile uint8_T KeINP_stRcvBcpTimeOutCemVal = 0U;
const volatile uint8_T KeINP_stRcvBcsTimeOutCemVal = 0U;
const volatile uint8_T KeINP_stRcvBrmTimeOutCemVal = 0U;
const volatile uint8_T KeINP_stRcvBroOkTimeOutCemVal = 0U;
const volatile uint8_T KeINP_stRcvBsdTimeOutCemVal = 0U;
const volatile uint8_T KeINP_stRcvBstTimeOutCemVal = 0U;
const volatile boolean_T KeINP_stS2OnVal = 0;
const volatile boolean_T KeINP_stS2Val = 0;
const volatile uint8_T KeINP_stSysModeMagVal = 0U;
const volatile uint8_T KeINP_stSysNetWkUpVal = 0U;
const volatile uint8_T KeINP_stSysWkUpSrcVal = 0U;
const volatile uint8_T KeINP_stVcuFalutLvlVal = 0U;
const volatile uint8_T KeINP_stVcuWrkVal = 0U;
const volatile boolean_T KeINP_swtBrkPedVal = 0;
const volatile uint8_T KeINP_valChkSumMsg050Val = 0U;
const volatile uint8_T KeINP_valChkSumMsg2A3Val = 0U;
const volatile uint8_T KeINP_valChkSumMsg2A5Val = 0U;
const volatile uint8_T KeINP_valChkSumMsg2A7Val = 0U;
const volatile uint8_T KeINP_valChkSumMsg2E1Val = 0U;
const volatile uint8_T KeINP_valChkSumMsg2E6Val = 0U;
const volatile uint8_T KeINP_valChkSumMsg2EBVal = 0U;
const volatile uint8_T KeINP_valVinCode_AVal = 0U;
const volatile uint8_T KeINP_valVinCode_BVal = 0U;
const volatile uint8_T KeINP_valVinCode_CVal = 0U;
const volatile uint8_T KeINP_valVinCode_DVal = 0U;
const volatile uint8_T KeINP_valVinCode_EVal = 0U;
const volatile uint8_T KeINP_valVinCode_FVal = 0U;
const volatile uint8_T KeINP_valVinCode_GVal = 0U;

#define ASW1_OEM_STOP_SEC_DEFAULT_CALIB_8
#include "Asw1_OEM_MemMap.h"

/* Block signals (auto storage) */
BlockIO_IOS_INP IOS_INP_B;

/* Block states (auto storage) */
D_Work_IOS_INP IOS_INP_DWork;

/* Real-time model */
RT_MODEL_IOS_INP IOS_INP_M_;
RT_MODEL_IOS_INP *const IOS_INP_M = &IOS_INP_M_;

/*
 * Output and update for atomic system:
 *    '<S2>/Sws_Io_Adc_Get_I_A_CC2()_Conv1'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()_Conv10'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()_Conv11'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()_Conv12'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()_Conv13'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()_Conv14'
 *    '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()_Conv15'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()_Conv16'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HV4()_Conv17'
 *    '<S2>/Sws_Io_Adc_Get_I_A_HV2()_Conv18'
 *    ...
 * Common block description:
 *   notes:
 *   R1:��ѹ��·������������
 *   R2:��ѹ��·������������
 *   R1+R2:��ѹ��·�ܵ���
 *   refVolt:��׼��ѹ
 *   maxAdcVal:������adcֵ
 *   voltOffSet:��������ʵ�ʵ�ѹƫ��
 */
real32_T IOS_INP_adc2Volt_UAES(uint32_T rtu_adcVal, uint32_T rtp_P, uint32_T
  rtp_D)
{
  /* DataTypeConversion: '<S56>/Data Type Conversion' incorporates:
   *  Constant: '<S56>/Constant1'
   *  Constant: '<S56>/Constant2'
   *  Product: '<S56>/Product1'
   *  Product: '<S56>/Product2'
   */
  return (real32_T)rtu_adcVal / (real32_T)rtp_D * (real32_T)rtp_P;
}

/*
 * Outputs for atomic system:
 *    '<S2>/Sws_Io_Adc_Get_I_A_AD3()25'
 *    '<S2>/Sws_Io_Adc_Get_I_A_AD4()24'
 *    '<S2>/Sws_Io_Adc_Get_I_A_AD5()23'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Aplus()26'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CC2()1'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CC2()2'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()10'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()21'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()22'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()27'
 *    ...
 */
uint32_T AI_Filter(rtDW_AI_Filter *localDW)
{
  uint16_T maxV;
  uint16_T minV;
  int32_T i;
  uint32_T rty_Out1_0;

  /* Sum: '<S42>/Sum of Elements' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  rty_Out1_0 = localDW->TappedDelay_X[0];
  for (i = 0; i < 4; i++) {
    rty_Out1_0 += localDW->TappedDelay_X[i + 1];
  }

  /* End of Sum: '<S42>/Sum of Elements' */

  /* MinMax: '<S42>/MinMax' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (localDW->TappedDelay_X[0] > localDW->TappedDelay_X[1]) {
    maxV = localDW->TappedDelay_X[0];
  } else {
    maxV = localDW->TappedDelay_X[1];
  }

  /* MinMax: '<S42>/MinMax1' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (localDW->TappedDelay_X[0] < localDW->TappedDelay_X[1]) {
    minV = localDW->TappedDelay_X[0];
  } else {
    minV = localDW->TappedDelay_X[1];
  }

  /* MinMax: '<S42>/MinMax' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (!(maxV > localDW->TappedDelay_X[2])) {
    maxV = localDW->TappedDelay_X[2];
  }

  /* MinMax: '<S42>/MinMax1' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (!(minV < localDW->TappedDelay_X[2])) {
    minV = localDW->TappedDelay_X[2];
  }

  /* MinMax: '<S42>/MinMax' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (!(maxV > localDW->TappedDelay_X[3])) {
    maxV = localDW->TappedDelay_X[3];
  }

  /* MinMax: '<S42>/MinMax1' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (!(minV < localDW->TappedDelay_X[3])) {
    minV = localDW->TappedDelay_X[3];
  }

  /* MinMax: '<S42>/MinMax' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (!(maxV > localDW->TappedDelay_X[4])) {
    maxV = localDW->TappedDelay_X[4];
  }

  /* MinMax: '<S42>/MinMax1' incorporates:
   *  S-Function (sfix_udelay): '<S42>/Tapped Delay'
   */
  if (!(minV < localDW->TappedDelay_X[4])) {
    minV = localDW->TappedDelay_X[4];
  }

  /* Sum: '<S42>/Add1' incorporates:
   *  MinMax: '<S42>/MinMax'
   *  MinMax: '<S42>/MinMax1'
   *  Sum: '<S42>/Add'
   */
  rty_Out1_0 = (rty_Out1_0 - maxV) - minV;

  /* Switch: '<S144>/Switch1' incorporates:
   *  RelationalOperator: '<S144>/Relational Operator1'
   */
  if (rty_Out1_0 != 0U) {
    /* Switch: '<S144>/Switch' incorporates:
     *  Product: '<S144>/Divide'
     */
    rty_Out1_0 /= 3U;
  }

  /* End of Switch: '<S144>/Switch1' */
  return rty_Out1_0;
}

/*
 * Update for atomic system:
 *    '<S2>/Sws_Io_Adc_Get_I_A_AD3()25'
 *    '<S2>/Sws_Io_Adc_Get_I_A_AD4()24'
 *    '<S2>/Sws_Io_Adc_Get_I_A_AD5()23'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Aplus()26'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CC2()1'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CC2()2'
 *    '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()10'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()21'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()22'
 *    '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()27'
 *    ...
 */
void AI_Filter_Update(uint16_T rtu_In1, rtDW_AI_Filter *localDW)
{
  /* Update for S-Function (sfix_udelay): '<S42>/Tapped Delay' */
  localDW->TappedDelay_X[0] = localDW->TappedDelay_X[1];
  localDW->TappedDelay_X[1] = localDW->TappedDelay_X[2];
  localDW->TappedDelay_X[2] = localDW->TappedDelay_X[3];
  localDW->TappedDelay_X[3] = localDW->TappedDelay_X[4];
  localDW->TappedDelay_X[4] = rtu_In1;
}

/*
 * System initialize for atomic system:
 *    '<S468>/filter by times'
 *    '<S470>/filter by times'
 */
void IOS_INP_filterbytimes_Init(real32_T *rty_output)
{
  *rty_output = 0.0F;
}

/*
 * Output and update for atomic system:
 *    '<S468>/filter by times'
 *    '<S470>/filter by times'
 */
void IOS_INP_filterbytimes(uint8_T rtu_input, uint16_T rtu_setTime, real32_T
  *rty_output, rtDW_filterbytimes_IOS_INP *localDW)
{
  /* Chart: '<S468>/filter by times' */
  /* Gateway: Interface/DI_Filter/filter by times */
  /* During: Interface/DI_Filter/filter by times */
  /* Entry Internal: Interface/DI_Filter/filter by times */
  /* Transition: '<S471>:8' */
  if (rtu_input != *rty_output) {
    /* Transition: '<S471>:13' */
    localDW->cnt++;
    if (localDW->cnt >= rtu_setTime + 1) {
      /* Transition: '<S471>:18' */
      *rty_output = rtu_input;
      localDW->cnt = 0U;

      /* Transition: '<S471>:20' */
    } else {
      /* Transition: '<S471>:15' */
      /* Transition: '<S471>:21' */
    }
  } else {
    /* Transition: '<S471>:11' */
    localDW->cnt = 0U;

    /* Transition: '<S471>:21' */
  }

  /* End of Chart: '<S468>/filter by times' */
}

/*
 * System initialize for atomic system:
 *    '<S5>/Sws_Io_Dio_Get_I_S_Key()2'
 *    '<S5>/Sws_Io_Dio_Get_I_S_Wake()1'
 */
void DI_Filter_Init(real32_T *rty_Out1)
{
  /* SystemInitialize for Chart: '<S468>/filter by times' */
  IOS_INP_filterbytimes_Init(rty_Out1);
}

/*
 * Output and update for atomic system:
 *    '<S5>/Sws_Io_Dio_Get_I_S_Key()2'
 *    '<S5>/Sws_Io_Dio_Get_I_S_Wake()1'
 */
void DI_Filter(uint8_T rtu_In1, real32_T *rty_Out1, rtDW_DI_Filter *localDW,
               uint16_T rtp_filter_times)
{
  /* Chart: '<S468>/filter by times' incorporates:
   *  Constant: '<S468>/Constant2'
   */
  IOS_INP_filterbytimes(rtu_In1, rtp_filter_times, rty_Out1,
                        &localDW->sf_filterbytimes);
}

/*
 * Output and update for atomic system:
 *    '<S7>/DT1'
 *    '<S7>/DT10'
 *    '<S7>/DT11'
 *    '<S7>/DT2'
 *    '<S7>/DT4'
 *    '<S7>/DT5'
 *    '<S7>/DT7'
 *    '<S7>/DT8'
 * Common block description:
 *   notes:
 *   R1:��ѹ��·������������
 *   R2:��ѹ��·������������
 *   R1+R2:��ѹ��·�ܵ���
 *   refVolt:��׼��ѹ
 *   maxAdcVal:������adcֵ
 *   voltOffSet:��������ʵ�ʵ�ѹƫ��
 */
real32_T IOS_INP_DT1(uint16_T rtu_adcVal, uint32_T rtp_P, uint32_T rtp_D)
{
  /* DataTypeConversion: '<S605>/Data Type Conversion' incorporates:
   *  Constant: '<S605>/Constant1'
   *  Constant: '<S605>/Constant2'
   *  Product: '<S605>/Product1'
   *  Product: '<S605>/Product2'
   */
  return (real32_T)rtu_adcVal / (real32_T)rtp_D * (real32_T)rtp_P;
}

/*
 * Output and update for atomic system:
 *    '<S7>/DT12'
 *    '<S7>/DT3'
 *    '<S7>/DT6'
 *    '<S7>/DT9'
 * Common block description:
 *   notes:
 *   R1:��ѹ��·������������
 *   R2:��ѹ��·������������
 *   R1+R2:��ѹ��·�ܵ���
 *   refVolt:��׼��ѹ
 *   maxAdcVal:������adcֵ
 *   voltOffSet:��������ʵ�ʵ�ѹƫ��
 */
uint8_T IOS_INP_DT12(uint8_T rtu_adcVal, uint32_T rtp_P, uint32_T rtp_D)
{
  real32_T tmp;

  /* DataTypeConversion: '<S608>/Data Type Conversion' incorporates:
   *  Constant: '<S608>/Constant1'
   *  Constant: '<S608>/Constant2'
   *  Product: '<S608>/Product1'
   *  Product: '<S608>/Product2'
   */
  tmp = fmodf(floorf((real32_T)rtu_adcVal / (real32_T)rtp_D * (real32_T)rtp_P),
              256.0F);
  return (uint8_T)(tmp < 0.0F ? (int32_T)(uint8_T)-(int8_T)(uint8_T)-tmp :
                   (int32_T)(uint8_T)tmp);
}

/* Model step function */
void IOS_INP_step(void)
{
  real32_T rtb_DataTypeConversion_iik;
  uint8_T rtb_DataTypeConversion_jo;
  uint32_T rtb_DataTypeConversion1_ku;
  real32_T tmp;

  Sws_Io_Pwm_SetPeriodAndDuty_O_F_HVIL2_OUT(16384,20000);

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()1' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_CC21);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()1' */

  /* Switch: '<S8>/Switch' incorporates:
   *  Constant: '<S8>/Constant'
   *  Constant: '<S8>/Constant1'
   */
  if (KeINP_bCC2VoltFlg) {
    BSW_uCC2Volt = KeINP_uCC2VoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()_Conv1' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()_Conv1' */
    BSW_uCC2Volt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()2' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_CC22);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()2' */

  /* Switch: '<S19>/Switch' incorporates:
   *  Constant: '<S19>/Constant'
   *  Constant: '<S19>/Constant1'
   */
  if (KeINP_bCCVoltFlg) {
    BSW_uCCVolt = KeINP_uCCVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()_Conv2' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()_Conv2' */
    BSW_uCCVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_IsoDet()3' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV_IsoDet3);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_IsoDet()3' */

  /* Switch: '<S30>/Switch' incorporates:
   *  Constant: '<S30>/Constant'
   *  Constant: '<S30>/Constant1'
   */
  if (KeINP_bIsoPosVoltFlg) {
    BSW_uIsoPosVolt = KeINP_uIsoPosVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_IsoDet()_Conv3' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_IsoDet()_Conv3' */
    BSW_uIsoPosVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Rly_Volt()4' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_UBR_Rly_Vo_e);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Rly_Volt()4' */

  /* Switch: '<S36>/Switch' incorporates:
   *  Constant: '<S36>/Constant'
   *  Constant: '<S36>/Constant1'
   */
  if (KeINP_bKl30cFlg) {
    BSW_uKl30c = KeINP_uKl30cVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Rly_Volt()_Conv4' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 1U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Rly_Volt()_Conv4' */
    BSW_uKl30c = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()5' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_UBR_Volt5);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()5' */

  /* Switch: '<S37>/Switch' incorporates:
   *  Constant: '<S37>/Constant'
   *  Constant: '<S37>/Constant1'
   */
  if (KeINP_bKl30Flg) {
    BSW_uKl30 = KeINP_uKl30Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()_Conv5' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 1U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()_Conv5' */
    BSW_uKl30 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr()6' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Plus);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr()6' */

  /* Switch: '<S38>/Switch' incorporates:
   *  Constant: '<S38>/Constant'
   *  Constant: '<S38>/Constant1'
   */
  if (KeINP_bMPosCtrHsdCurrFlg) {
    BSW_uMPosCtrHsdCurr = KeINP_uMPosCtrHsdCurrVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr()_Conv6' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr()_Conv6' */
    BSW_uMPosCtrHsdCurr = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr()7' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr()7' */

  /* Switch: '<S39>/Switch' incorporates:
   *  Constant: '<S39>/Constant'
   *  Constant: '<S39>/Constant1'
   */
  if (KeINP_bDcChPosCtrHsdCurrFlg) {
    BSW_uDcChPosCtrHsdCurr = KeINP_uDcChPosCtrHsdCurrVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr()_Conv7' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr()_Conv7' */
    BSW_uDcChPosCtrHsdCurr = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr()8' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Minu);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr()8' */

  /* Switch: '<S40>/Switch' incorporates:
   *  Constant: '<S40>/Constant'
   *  Constant: '<S40>/Constant1'
   */
  if (KeINP_bMNegCtrHsdCurrFlg) {
    BSW_uMNegCtrHsdCurr = KeINP_uMNegCtrHsdCurrVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr()_Conv8' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr()_Conv8' */
    BSW_uMNegCtrHsdCurr = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr()9' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr()9' */

  /* Switch: '<S41>/Switch' incorporates:
   *  Constant: '<S41>/Constant'
   *  Constant: '<S41>/Constant1'
   */
  if (KeINP_bDcChNegCtrHsdCurrFlg) {
    BSW_uDcChNegCtrHsdCurr = KeINP_uDcChNegCtrHsdCurrVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr()_Conv9' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr()_Conv9' */
    BSW_uDcChNegCtrHsdCurr = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()10' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_CMC_Fbk_Vo_b);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()10' */

  /* Switch: '<S9>/Switch' incorporates:
   *  Constant: '<S9>/Constant'
   *  Constant: '<S9>/Constant1'
   */
  if (KeINP_bCabCurrFlg) {
    BSW_uCabCurr = KeINP_uCabCurrVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()_Conv10' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 5U, 10U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()_Conv10' */
    BSW_uCabCurr = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()11' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT1_F_i);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()11' */

  /* Switch: '<S10>/Switch' incorporates:
   *  Constant: '<S10>/Constant'
   *  Constant: '<S10>/Constant1'
   */
  if (KeINP_bDcChPosCtrLsdVoltFlg) {
    BSW_uDcChPosCtrLsdVolt = KeINP_uDcChPosCtrLsdVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()_Conv11' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()_Conv11' */
    BSW_uDcChPosCtrLsdVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()12' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT2_F_g);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()12' */

  /* Switch: '<S11>/Switch' incorporates:
   *  Constant: '<S11>/Constant'
   *  Constant: '<S11>/Constant1'
   */
  if (KeINP_bDcChNegCtrLsdVoltFlg) {
    BSW_uDcChNegCtrLsdVolt = KeINP_uDcChNegCtrLsdVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()_Conv12' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()_Conv12' */
    BSW_uDcChNegCtrLsdVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()13' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Pl_e);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()13' */

  /* Switch: '<S12>/Switch' incorporates:
   *  Constant: '<S12>/Constant'
   *  Constant: '<S12>/Constant1'
   */
  if (KeINP_bMPosCtrHsdVoltFlg) {
    BSW_uMPosCtrHsdVolt = KeINP_uMPosCtrHsdVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()_Conv13' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()_Conv13' */
    BSW_uMPosCtrHsdVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()14' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Mi_m);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()14' */

  /* Switch: '<S13>/Switch' incorporates:
   *  Constant: '<S13>/Constant'
   *  Constant: '<S13>/Constant1'
   */
  if (KeINP_bMNegCtrHsdVoltFlg) {
    BSW_uMNegCtrHsdVolt = KeINP_uMNegCtrHsdVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()_Conv14' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()_Conv14' */
    BSW_uMNegCtrHsdVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()15' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_UBR_Volt15);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()15' */

  /* Switch: '<S14>/Switch' incorporates:
   *  Constant: '<S14>/Constant'
   *  Constant: '<S14>/Constant1'
   */
  if (KeINP_bHwSplyVoltFlg) {
    BSW_uHwSplyVolt = KeINP_uHwSplyVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()_Conv15' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 1U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()_Conv15' */
    BSW_uHwSplyVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()16' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV_Plus16);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()16' */

  /* Switch: '<S15>/Switch' incorporates:
   *  Constant: '<S15>/Constant'
   *  Constant: '<S15>/Constant1'
   */
  if (KeINP_bBattVoltFlg) {
    BSW_uBattVolt = KeINP_uBattVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()_Conv16' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()_Conv16' */
    BSW_uBattVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV4()17' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV417);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV4()17' */

  /* Switch: '<S16>/Switch' incorporates:
   *  Constant: '<S16>/Constant'
   *  Constant: '<S16>/Constant1'
   */
  if (KeINP_bDChrgVoltFlg) {
    BSW_uDChrgVolt = KeINP_uDChrgVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV4()_Conv17' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV4()_Conv17' */
    BSW_uDChrgVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV2()18' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV218);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV2()18' */

  /* Switch: '<S17>/Switch' incorporates:
   *  Constant: '<S17>/Constant'
   *  Constant: '<S17>/Constant1'
   */
  if (KeINP_bPackVoltFlg) {
    BSW_uPackVolt = KeINP_uPackVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV2()_Conv18' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV2()_Conv18' */
    BSW_uPackVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV6()19' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV619);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV6()19' */

  /* Switch: '<S18>/Switch' incorporates:
   *  Constant: '<S18>/Constant'
   *  Constant: '<S18>/Constant1'
   */
  if (KeINP_bNegVoltFlg) {
    BSW_uNegVolt = KeINP_uNegVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV6()_Conv19' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV6()_Conv19' */
    BSW_uNegVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV5()20' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV520);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV5()20' */

  /* Switch: '<S20>/Switch' incorporates:
   *  Constant: '<S20>/Constant'
   *  Constant: '<S20>/Constant1'
   */
  if (KeINP_bDchrgNegVoltFlg) {
    BSW_uDchrgNegVolt = KeINP_uDchrgNegVoltVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV5()_Conv20' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV5()_Conv20' */
    BSW_uDchrgNegVolt = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()21' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Coolt_In_Tem);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()21' */

  /* Switch: '<S21>/Switch' incorporates:
   *  Constant: '<S21>/Constant'
   *  Constant: '<S21>/Constant1'
   */
  if (KeINP_bClntUsTFlg) {
    BSW_uClntUsT = KeINP_uClntUsTVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()_Conv21' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()_Conv21' */
    BSW_uClntUsT = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()22' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Coolt_Out_Te);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()22' */

  /* Switch: '<S22>/Switch' incorporates:
   *  Constant: '<S22>/Constant'
   *  Constant: '<S22>/Constant1'
   */
  if (KeINP_bClntDsTFlg) {
    BSW_uClntDsT = KeINP_uClntDsTVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()_Conv22' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()_Conv22' */
    BSW_uClntDsT = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD5()23' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_AD523);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD5()23' */

  /* Switch: '<S23>/Switch' incorporates:
   *  Constant: '<S23>/Constant'
   *  Constant: '<S23>/Constant1'
   */
  if (KeINP_bDChrgNegTempFlg) {
    BSW_uDChrgNegTemp = KeINP_uDChrgNegTempVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD5()_Conv23' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD5()_Conv23' */
    BSW_uDChrgNegTemp = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD4()24' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_AD424);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD4()24' */

  /* Switch: '<S24>/Switch' incorporates:
   *  Constant: '<S24>/Constant'
   *  Constant: '<S24>/Constant1'
   */
  if (KeINP_bDChrgPosTempFlg) {
    BSW_uDChrgPosTemp = KeINP_uDChrgPosTempVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD4()_Conv24' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD4()_Conv24' */
    BSW_uDChrgPosTemp = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD3()25' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_AD325);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD3()25' */

  /* Switch: '<S25>/Switch' incorporates:
   *  Constant: '<S25>/Constant'
   *  Constant: '<S25>/Constant1'
   */
  if (KeINP_bReservedSig1Flg) {
    BSW_uReservedSig1 = KeINP_uReservedSig1Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD3()_Conv25' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD3()_Conv25' */
    BSW_uReservedSig1 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Aplus()26' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Aplus26);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Aplus()26' */

  /* Switch: '<S26>/Switch' incorporates:
   *  Constant: '<S26>/Constant'
   *  Constant: '<S26>/Constant1'
   */
  if (KeINP_bDCWkUpFlg) {
    BSW_uDCWkUp = KeINP_uDCWkUpVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Aplus()_Conv26' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 1U, 1U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Aplus()_Conv26' */
    BSW_uDCWkUp = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()27' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Curr_Sens_Ha);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()27' */

  /* Switch: '<S27>/Switch' incorporates:
   *  Constant: '<S27>/Constant'
   *  Constant: '<S27>/Constant1'
   */
  if (KeINP_bAdCurrFlg) {
    BSW_uAdCurr = KeINP_uAdCurrVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()_Conv27' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()_Conv27' */
    BSW_uAdCurr = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_Current()28' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HSD_Current2);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_Current()28' */

  /* Switch: '<S28>/Switch' incorporates:
   *  Constant: '<S28>/Constant'
   *  Constant: '<S28>/Constant1'
   */
  if (KeINP_bReservedSig2Flg) {
    BSW_uReservedSig2 = KeINP_uReservedSig2Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_Current()_Conv28' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_Current()_Conv28' */
    BSW_uReservedSig2 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_HS()29' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HSD_HS29);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_HS()29' */

  /* Switch: '<S29>/Switch' incorporates:
   *  Constant: '<S29>/Constant'
   *  Constant: '<S29>/Constant1'
   */
  if (KeINP_bReservedSig3Flg) {
    BSW_uReservedSig3 = KeINP_uReservedSig3Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_HS()_Conv29' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_HS()_Conv29' */
    BSW_uReservedSig3 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV3()30' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV330);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV3()30' */

  /* Switch: '<S31>/Switch' incorporates:
   *  Constant: '<S31>/Constant'
   *  Constant: '<S31>/Constant1'
   */
  if (KeINP_bReservedSig4Flg) {
    BSW_uReservedSig4 = KeINP_uReservedSig4Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV3()_Conv30' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 20U, 1000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV3()_Conv30' */
    BSW_uReservedSig4 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Heat_Temp()31' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Heat_Temp31);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Heat_Temp()31' */

  /* Switch: '<S32>/Switch' incorporates:
   *  Constant: '<S32>/Constant'
   *  Constant: '<S32>/Constant1'
   */
  if (KeINP_bReservedSig5Flg) {
    BSW_uReservedSig5 = KeINP_uReservedSig5Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Heat_Temp()_Conv31' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Heat_Temp()_Conv31' */
    BSW_uReservedSig5 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt()32' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_VDD5Ref2_Vol);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt()32' */

  /* Switch: '<S33>/Switch' incorporates:
   *  Constant: '<S33>/Constant'
   *  Constant: '<S33>/Constant1'
   */
  if (KeINP_bReservedSig6Flg) {
    BSW_uReservedSig6 = KeINP_uReservedSig6Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt()_Conv32' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt()_Conv32' */
    BSW_uReservedSig6 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref_Volt()33' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_VDD5Ref_Vo_f);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref_Volt()33' */

  /* Switch: '<S34>/Switch' incorporates:
   *  Constant: '<S34>/Constant'
   *  Constant: '<S34>/Constant1'
   */
  if (KeINP_bReservedSig7Flg) {
    BSW_uReservedSig7 = KeINP_uReservedSig7Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref_Volt()_Conv33' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref_Volt()_Conv33' */
    BSW_uReservedSig7 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Trc_Volt()34' */
  rtb_DataTypeConversion1_ku = (uint32_T) AI_Filter
    (&IOS_INP_DWork.Sws_Io_Adc_Get_I_A_VDD5Trc_Vo_e);

  /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Trc_Volt()34' */

  /* Switch: '<S35>/Switch' incorporates:
   *  Constant: '<S35>/Constant'
   *  Constant: '<S35>/Constant1'
   */
  if (KeINP_bReservedSig8Flg) {
    BSW_uReservedSig8 = KeINP_uReservedSig8Val;
  } else {
    /* Outputs for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Trc_Volt()_Conv34' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_adc2Volt_UAES
      (rtb_DataTypeConversion1_ku, 200U, 1000000U);

    /* End of Outputs for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Trc_Volt()_Conv34' */
    BSW_uReservedSig8 = rtb_DataTypeConversion_iik;
  }

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

  /* Outputs for Atomic SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Wake()1' */

  /* Constant: '<S469>/Conversion' */
  DI_Filter(Sws_Io_Dio_Get_I_S_Wake(), &IOS_INP_B.output,
            &IOS_INP_DWork.Sws_Io_Dio_Get_I_S_Wake1, 5U);

  /* End of Outputs for SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Wake()1' */

  /* Switch: '<S465>/Switch' incorporates:
   *  Constant: '<S465>/Constant'
   *  Constant: '<S465>/Constant1'
   */
  if (KeINP_bACWkUpFlg) {
    BSPR_bACWkUp = KeINP_bACWkUpVal;
  } else {
    tmp = fmodf(floorf(IOS_INP_B.output), 256.0F);
    BSPR_bACWkUp = (uint8_T)(tmp < 0.0F ? (int32_T)(uint8_T)-(int8_T)(uint8_T)
      -tmp : (int32_T)(uint8_T)tmp);
  }

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

  /* Outputs for Atomic SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Key()2' */

  /* Constant: '<S467>/Conversion' */
  DI_Filter(Sws_Io_Dio_Get_I_S_Key(), &IOS_INP_B.output_f,
            &IOS_INP_DWork.Sws_Io_Dio_Get_I_S_Key2, 5U);

  /* End of Outputs for SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Key()2' */

  /* Switch: '<S466>/Switch' incorporates:
   *  Constant: '<S466>/Constant'
   *  Constant: '<S466>/Constant1'
   */
  if (KeINP_bKl15WkUpFlg) {
    BSPR_bKl15WkUp = (KeINP_bKl15WkUpVal != 0);
  } else {
    BSPR_bKl15WkUp = (IOS_INP_B.output_f != 0.0F);
  }

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

  /* Switch: '<S180>/Switch' incorporates:
   *  Constant: '<S180>/Constant'
   *  Constant: '<S180>/Constant1'
   *  Constant: '<S194>/Conversion'
   */
  if (KeINP_btSysModeMagFlg) {
    BSW_stSysModeMag = KeINP_stSysModeMagVal;
  } else {
    BSW_stSysModeMag = Sws_Syc_GetCurrentState();
  }

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

  /* Switch: '<S185>/Switch' incorporates:
   *  Constant: '<S185>/Constant'
   *  Constant: '<S185>/Constant1'
   *  Constant: '<S195>/Conversion'
   */
  if (KeINP_btSysWkUpSrcFlg) {
    BSW_stSysWkUpSrc = KeINP_stSysWkUpSrcVal;
  } else {
    BSW_stSysWkUpSrc = Sws_Syc_GetWakeUpSources();
  }

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

  /* Switch: '<S186>/Switch' incorporates:
   *  Constant: '<S186>/Constant'
   *  Constant: '<S186>/Constant1'
   *  Constant: '<S193>/Conversion'
   */
  if (KeINP_btSysNetWkUpFlg) {
    BSW_stSysNetWkUp = KeINP_stSysNetWkUpVal;
  } else {
    BSW_stSysNetWkUp = Sws_Com_Get_CANNM_NetworkState();
  }

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

  /* Switch: '<S187>/Switch' incorporates:
   *  Constant: '<S187>/Constant'
   *  Constant: '<S187>/Constant1'
   *  Constant: '<S197>/Conversion'
   */
  // if (KeINP_bCU2A3DataAvailableFlg) {
  //   BSW_VCU2A3DataAvailable = KeINP_VCU2A3DataAvailableVal;
  // } else {
  //   BSW_VCU2A3DataAvailable = hld_PrivateCAN_0x2A3_Received;
  // }

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

  /* Switch: '<S188>/Switch' incorporates:
   *  Constant: '<S188>/Constant'
   *  Constant: '<S188>/Constant1'
   *  Constant: '<S199>/Conversion'
   */
  // if (KeINP_bCU2A7DataAvailableFlg) {
  //   BSW_VCU2A7DataAvailable = KeINP_VCU2A7DataAvailableVal;
  // } else {
  //   BSW_VCU2A7DataAvailable = hld_PrivateCAN_0x2A7_Received;
  // }

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

  /* Switch: '<S189>/Switch' incorporates:
   *  Constant: '<S189>/Constant'
   *  Constant: '<S189>/Constant1'
   *  Constant: '<S198>/Conversion'
   */
  // if (KeINP_bCU2A5DataAvailableFlg) {
  //   BSW_VCU2A5DataAvailable = KeINP_VCU2A5DataAvailableVal;
  // } else {
  //   BSW_VCU2A5DataAvailable = hld_PrivateCAN_0x2A5_Received;
  // }

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

  /* Switch: '<S190>/Switch' incorporates:
   *  Constant: '<S190>/Constant'
   *  Constant: '<S190>/Constant1'
   *  Constant: '<S202>/Conversion'
   */
  // if (KeINP_bCCharger0x2E1MessageAvailableFlg) {
  //   BSW_ACCharger0x2E1MessageAvailable = KeINP_ACCharger0x2E1MessageAvailableVal;
  // } else {
  //   BSW_ACCharger0x2E1MessageAvailable = hld_PrivateCAN_0x2E1_Received;
  // }

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

  /* Switch: '<S191>/Switch' incorporates:
   *  Constant: '<S191>/Constant'
   *  Constant: '<S191>/Constant1'
   *  Constant: '<S203>/Conversion'
   */
  // if (KeINP_bCCharger0x2E6MessageAvailableFlg) {
  //   BSW_ACCharger0x2E6MessageAvailable = KeINP_ACCharger0x2E6MessageAvailableVal;
  // } else {
  //   BSW_ACCharger0x2E6MessageAvailable = hld_PrivateCAN_0x2E6_Received;
  // }

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

  /* Switch: '<S192>/Switch' incorporates:
   *  Constant: '<S192>/Constant'
   *  Constant: '<S192>/Constant1'
   *  Constant: '<S196>/Conversion'
   */
  // if (KeINP_bBM050DataAvailableFlg) {
  //   BSW_ABM050DataAvailable = KeINP_ABM050DataAvailableVal;
  // } else {
  //   BSW_ABM050DataAvailable = hld_PrivateCAN_0x050_Received;
  // }

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

  /* Switch: '<S181>/Switch' incorporates:
   *  Constant: '<S181>/Constant'
   *  Constant: '<S181>/Constant1'
   *  Constant: '<S200>/Conversion'
   */
  // if (KeINP_bW2ADDataAvailableFlg) {
  //   BSW_GW2ADDataAvailable = KeINP_GW2ADDataAvailableVal;
  // } else {
  //   BSW_GW2ADDataAvailable = hld_PrivateCAN_0x2AD_Received;
  // }

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

  /* Switch: '<S182>/Switch' incorporates:
   *  Constant: '<S182>/Constant'
   *  Constant: '<S182>/Constant1'
   *  Constant: '<S201>/Conversion'
   */
  // if (KeINP_bW2BBDataAvailableFlg) {
  //   BSW_GW2BBDataAvailable = KeINP_GW2BBDataAvailableVal;
  // } else {
  //   BSW_GW2BBDataAvailable = hld_PrivateCAN_0x2BB_Received;
  // }

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

  /* Switch: '<S183>/Switch' incorporates:
   *  Constant: '<S178>/Constant'
   *  Constant: '<S183>/Constant'
   *  Constant: '<S183>/Constant1'
   *  DataTypeConversion: '<S178>/Data Type Conversion'
   */
  if (KeINP_bFC_VeCanBusOffFlg) {
    COMR_DFC_VeCanBusOff = KeINP_DFC_VeCanBusOffVal;
  } else {
    COMR_DFC_VeCanBusOff = false;
  }

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

  /* Switch: '<S184>/Switch' incorporates:
   *  Constant: '<S179>/Constant'
   *  Constant: '<S184>/Constant'
   *  Constant: '<S184>/Constant1'
   *  DataTypeConversion: '<S179>/Data Type Conversion'
   */
  if (KeINP_bFC_DcCanBusOffFlg) {
    COMR_DFC_DcCanBusOff = KeINP_DFC_DcCanBusOffVal;
  } else {
    COMR_DFC_DcCanBusOff = false;
  }

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

  /* Switch: '<S355>/Switch' incorporates:
   *  Constant: '<S322>/Conversion'
   *  Constant: '<S355>/Constant'
   *  Constant: '<S355>/Constant1'
   *  DataTypeConversion: '<S216>/Data Type Conversion'
   */
  if (KeINP_bMcuVoltFlg) {
    COMR_uMcuVolt = KeINP_uMcuVoltVal;
  } else {
    COMR_uMcuVolt = (real32_T)MCU_UdcCurr;
  }

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

  /* Switch: '<S366>/Switch' incorporates:
   *  Constant: '<S343>/Conversion'
   *  Constant: '<S366>/Constant'
   *  Constant: '<S366>/Constant1'
   *  DataTypeConversion: '<S227>/Data Type Conversion'
   */
  if (KeINP_bffObcChrgFlg) {
    COMR_effObcChrg = KeINP_effObcChrgVal;
  } else {
    COMR_effObcChrg = (real32_T)OBC_Ecy * 0.5F;
  }

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

  /* Switch: '<S377>/Switch' incorporates:
   *  Constant: '<S346>/Conversion'
   *  Constant: '<S377>/Constant'
   *  Constant: '<S377>/Constant1'
   *  DataTypeConversion: '<S238>/Data Type Conversion'
   */
  if (KeINP_bMaxCurrObcChrgFlg) {
    COMR_iMaxCurrObcChrg = KeINP_iMaxCurrObcChrgVal;
  } else {
    COMR_iMaxCurrObcChrg = (real32_T)OBC_HV_DC_MAXCurr * 0.2F;
  }

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

  /* Switch: '<S388>/Switch' incorporates:
   *  Constant: '<S347>/Conversion'
   *  Constant: '<S388>/Constant'
   *  Constant: '<S388>/Constant1'
   *  DataTypeConversion: '<S249>/Data Type Conversion'
   */
  if (KeINP_bMaxVoltObcChrgFlg) {
    COMR_uMaxVoltObcChrg = KeINP_uMaxVoltObcChrgVal;
  } else {
    COMR_uMaxVoltObcChrg = (real32_T)OBC_HV_DC_MAXVolt * 2.0F;
  }

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

  /* Switch: '<S399>/Switch' incorporates:
   *  Constant: '<S345>/Conversion'
   *  Constant: '<S399>/Constant'
   *  Constant: '<S399>/Constant1'
   *  DataTypeConversion: '<S260>/Data Type Conversion'
   */
  if (KeINP_bCurrObcChrgFlg) {
    COMR_iCurrObcChrg = KeINP_iCurrObcChrgVal;
  } else {
    COMR_iCurrObcChrg = (real32_T)OBC_HV_DC_Curr * 0.1F - 50.0F;
  }

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

  /* Switch: '<S410>/Switch' incorporates:
   *  Constant: '<S348>/Conversion'
   *  Constant: '<S410>/Constant'
   *  Constant: '<S410>/Constant1'
   *  DataTypeConversion: '<S271>/Data Type Conversion'
   */
  if (KeINP_bVoltObcChrgFlg) {
    COMR_uVoltObcChrg = KeINP_uVoltObcChrgVal;
  } else {
    COMR_uVoltObcChrg = (real32_T)OBC_HV_DC_Volt * 0.02F;
  }

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

  /* Switch: '<S421>/Switch' incorporates:
   *  Constant: '<S351>/Conversion'
   *  Constant: '<S421>/Constant'
   *  Constant: '<S421>/Constant1'
   */
  if (KeINP_bntRCMsg2E6Flg) {
    COMR_cntRCMsg2E6 = KeINP_cntRCMsg2E6Val;
  } else {
    COMR_cntRCMsg2E6 = OBC_RollingCounter_2E6;
  }

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

  /* Switch: '<S432>/Switch' incorporates:
   *  Constant: '<S432>/Constant'
   *  Constant: '<S432>/Constant1'
   *  Constant: '<S442>/Conversion'
   *  DataTypeConversion: '<S293>/Data Type Conversion'
   */
  if (KeINP_btS2Flg) {
    COMR_stS2 = KeINP_stS2Val;
  } else {
    COMR_stS2 = (S2_staus != 0);
  }

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

  /* Switch: '<S441>/Switch' incorporates:
   *  Constant: '<S341>/Conversion'
   *  Constant: '<S441>/Constant'
   *  Constant: '<S441>/Constant1'
   */
  if (KeINP_balChkSumMsg2E6Flg) {
    COMR_valChkSumMsg2E6 = KeINP_valChkSumMsg2E6Val;
  } else {
    COMR_valChkSumMsg2E6 = OBC_Checksum_2E6;
  }

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

  /* Switch: '<S356>/Switch' incorporates:
   *  Constant: '<S354>/Conversion'
   *  Constant: '<S356>/Constant'
   *  Constant: '<S356>/Constant1'
   */
  if (KeINP_btObcFaultLvlFlg) {
    COMR_stObcFaultLvl = KeINP_stObcFaultLvlVal;
  } else {
    COMR_stObcFaultLvl = OBC_failerrSts;
  }

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

  /* Switch: '<S357>/Switch' incorporates:
   *  Constant: '<S344>/Conversion'
   *  Constant: '<S357>/Constant'
   *  Constant: '<S357>/Constant1'
   */
  if (KeINP_btObcElecLckFlg) {
    COMR_stObcElecLck = KeINP_stObcElecLckVal;
  } else {
    COMR_stObcElecLck = OBC_EleccLckStt;
  }

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

  /* Switch: '<S358>/Switch' incorporates:
   *  Constant: '<S339>/Conversion'
   *  Constant: '<S358>/Constant'
   *  Constant: '<S358>/Constant1'
   */
  if (KeINP_btObcCPFlg) {
    COMR_stObcCP = KeINP_stObcCPVal;
  } else {
    COMR_stObcCP = OBC_CPStatus;
  }

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

  /* Switch: '<S359>/Switch' incorporates:
   *  Constant: '<S349>/Conversion'
   *  Constant: '<S359>/Constant'
   *  Constant: '<S359>/Constant1'
   */
  if (KeINP_bcObcCPFlg) {
    COMR_dcObcCP = KeINP_dcObcCPVal;
  } else {
    COMR_dcObcCP = OBC_PwmDuty;
  }

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

  /* Switch: '<S360>/Switch' incorporates:
   *  Constant: '<S350>/Conversion'
   *  Constant: '<S360>/Constant'
   *  Constant: '<S360>/Constant1'
   */
  if (KeINP_bntRCMsg2E1Flg) {
    COMR_cntRCMsg2E1 = KeINP_cntRCMsg2E1Val;
  } else {
    COMR_cntRCMsg2E1 = OBC_RollingCounter_2E1;
  }

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

  /* Switch: '<S361>/Switch' incorporates:
   *  Constant: '<S340>/Conversion'
   *  Constant: '<S361>/Constant'
   *  Constant: '<S361>/Constant1'
   */
  if (KeINP_balChkSumMsg2E1Flg) {
    COMR_valChkSumMsg2E1 = KeINP_valChkSumMsg2E1Val;
  } else {
    COMR_valChkSumMsg2E1 = OBC_Checksum_2E1;
  }

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

  /* Switch: '<S362>/Switch' incorporates:
   *  Constant: '<S353>/Conversion'
   *  Constant: '<S362>/Constant'
   *  Constant: '<S362>/Constant1'
   */
  if (KeINP_btObcChrgFlg) {
    COMR_stObcChrg = KeINP_stObcChrgVal;
  } else {
    COMR_stObcChrg = OBC_Status;
  }

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

  /* Switch: '<S363>/Switch' incorporates:
   *  Constant: '<S338>/Conversion'
   *  Constant: '<S363>/Constant'
   *  Constant: '<S363>/Constant1'
   */
  if (KeINP_btObcCCFlg) {
    COMR_stObcCC = KeINP_stObcCCVal;
  } else {
    COMR_stObcCC = OBC_CC_connect_Status;
  }

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

  /* Switch: '<S364>/Switch' incorporates:
   *  Constant: '<S352>/Conversion'
   *  Constant: '<S364>/Constant'
   *  Constant: '<S364>/Constant1'
   */
  if (KeINP_bntRCMsg2EBFlg) {
    COMR_cntRCMsg2EB = KeINP_cntRCMsg2EBVal;
  } else {
    COMR_cntRCMsg2EB = OBC_RollingCounter_2EB;
  }

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

  /* Switch: '<S365>/Switch' incorporates:
   *  Constant: '<S342>/Conversion'
   *  Constant: '<S365>/Constant'
   *  Constant: '<S365>/Constant1'
   */
  if (KeINP_balChkSumMsg2EBFlg) {
    COMR_valChkSumMsg2EB = KeINP_valChkSumMsg2EBVal;
  } else {
    COMR_valChkSumMsg2EB = OBC_Checksum_2EB;
  }

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

  /* Switch: '<S367>/Switch' incorporates:
   *  Constant: '<S209>/Conversion'
   *  Constant: '<S367>/Constant'
   *  Constant: '<S367>/Constant1'
   *  DataTypeConversion: '<S228>/Data Type Conversion'
   */
  if (KeINP_bCabErrStatusFlg) {
    COMR_bCabErrStatus = KeINP_bCabErrStatusVal;
  } else {
    COMR_bCabErrStatus = (CAB_ErrorStatus != 0);
  }

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

  /* Switch: '<S368>/Switch' incorporates:
   *  Constant: '<S208>/Conversion'
   *  Constant: '<S368>/Constant'
   *  Constant: '<S368>/Constant1'
   */
  if (KeINP_btCabErrInfoFlg) {
    COMR_stCabErrInfo = KeINP_stCabErrInfoVal;
  } else {
    COMR_stCabErrInfo = CAB_ErrorInfo;
  }

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

  /* Switch: '<S369>/Switch' incorporates:
   *  Constant: '<S210>/Conversion'
   *  Constant: '<S369>/Constant'
   *  Constant: '<S369>/Constant1'
   *  DataTypeConversion: '<S230>/Data Type Conversion'
   */
  if (KeINP_bBattCurr_mAFlg) {
    COMR_iBattCurr_mA = KeINP_iBattCurr_mAVal;
  } else {
    COMR_iBattCurr_mA = (real32_T)CAB_IpValue - 2.14748365E+9F;
  }

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

  /* Switch: '<S370>/Switch' incorporates:
   *  Constant: '<S370>/Constant'
   *  Constant: '<S370>/Constant1'
   *  Constant: '<S447>/Conversion'
   */
  if (KeINP_blgAPPInvldFlg) {
    COMR_flgAPPInvld = KeINP_flgAPPInvldVal;
  } else {
    COMR_flgAPPInvld = VCU_AccelPedalPositionInvalid;
  }

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

  /* Switch: '<S371>/Switch' incorporates:
   *  Constant: '<S371>/Constant'
   *  Constant: '<S371>/Constant1'
   *  Constant: '<S446>/Conversion'
   *  DataTypeConversion: '<S232>/Data Type Conversion'
   */
  if (KeINP_bhiAPPFlg) {
    COMR_phiAPP = KeINP_phiAPPVal;
  } else {
    COMR_phiAPP = (real32_T)VCU_AccelPedalPosition * 0.4F;
  }

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

  /* Switch: '<S372>/Switch' incorporates:
   *  Constant: '<S372>/Constant'
   *  Constant: '<S372>/Constant1'
   *  Constant: '<S453>/Conversion'
   *  DataTypeConversion: '<S233>/Data Type Conversion'
   */
  if (KeINP_bwrChrgLdReqFlg) {
    COMR_pwrChrgLdReq = KeINP_pwrChrgLdReqVal;
  } else {
    COMR_pwrChrgLdReq = (real32_T)VCU_ChargeLoadPower * 0.1F;
  }

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

  /* Switch: '<S373>/Switch' incorporates:
   *  Constant: '<S373>/Constant'
   *  Constant: '<S373>/Constant1'
   *  Constant: '<S449>/Conversion'
   */
  if (KeINP_btPwrUpDwnVcuReqFlg) {
    COMR_stPwrUpDwnVcuReq = KeINP_stPwrUpDwnVcuReqVal;
  } else {
    COMR_stPwrUpDwnVcuReq = VCU_BMSHVreq_BatA;
  }

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

  /* Switch: '<S374>/Switch' incorporates:
   *  Constant: '<S374>/Constant'
   *  Constant: '<S374>/Constant1'
   *  Constant: '<S450>/Conversion'
   */
  if (KeINP_btPreThmVcuPmtFlg) {
    COMR_stPreThmVcuPmt = KeINP_stPreThmVcuPmtVal;
  } else {
    COMR_stPreThmVcuPmt = VCU_BMSPreThemalPermit;
  }

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

  /* Switch: '<S375>/Switch' incorporates:
   *  Constant: '<S375>/Constant'
   *  Constant: '<S375>/Constant1'
   *  Constant: '<S448>/Conversion'
   *  DataTypeConversion: '<S236>/Data Type Conversion'
   */
  if (KeINP_bVcuChrgDisableFlg) {
    COMR_bVcuChrgDisable = KeINP_bVcuChrgDisableVal;
  } else {
    COMR_bVcuChrgDisable = (VCU_BMSChgDisable != 0);
  }

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

  /* Switch: '<S376>/Switch' incorporates:
   *  Constant: '<S376>/Constant'
   *  Constant: '<S376>/Constant1'
   *  Constant: '<S459>/Conversion'
   *  DataTypeConversion: '<S237>/Data Type Conversion'
   */
  if (KeINP_bLeadAcidChgHvOnFlg) {
    COMR_bLeadAcidChgHvOn = KeINP_bLeadAcidChgHvOnVal;
  } else {
    COMR_bLeadAcidChgHvOn = (VCU_IntelligentChargeHVONFlg != 0);
  }

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

  /* Switch: '<S378>/Switch' incorporates:
   *  Constant: '<S378>/Constant'
   *  Constant: '<S378>/Constant1'
   *  Constant: '<S461>/Conversion'
   */
  if (KeINP_bntRCMsg2A3Flg) {
    COMR_cntRCMsg2A3 = KeINP_cntRCMsg2A3Val;
  } else {
    COMR_cntRCMsg2A3 = VCU_RollingCounter_2A3;
  }

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

  /* Switch: '<S379>/Switch' incorporates:
   *  Constant: '<S379>/Constant'
   *  Constant: '<S379>/Constant1'
   *  Constant: '<S454>/Conversion'
   */
  if (KeINP_balChkSumMsg2A3Flg) {
    COMR_valChkSumMsg2A3 = KeINP_valChkSumMsg2A3Val;
  } else {
    COMR_valChkSumMsg2A3 = VCU_Checksum_2A3;
  }

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

  /* Switch: '<S380>/Switch' incorporates:
   *  Constant: '<S380>/Constant'
   *  Constant: '<S380>/Constant1'
   *  Constant: '<S457>/Conversion'
   */
  if (KeINP_btElecModFlg) {
    COMR_stElecMod = KeINP_stElecModVal;
  } else {
    COMR_stElecMod = VCU_ElecModFlg;
  }

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

  /* Switch: '<S381>/Switch' incorporates:
   *  Constant: '<S381>/Constant'
   *  Constant: '<S381>/Constant1'
   *  Constant: '<S460>/Conversion'
   */
  if (KeINP_btPreThmEnaFlg) {
    COMR_stPreThmEna = KeINP_stPreThmEnaVal;
  } else {
    COMR_stPreThmEna = VCU_PreThemalEna;
  }

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

  /* Switch: '<S382>/Switch' incorporates:
   *  Constant: '<S382>/Constant'
   *  Constant: '<S382>/Constant1'
   *  Constant: '<S462>/Conversion'
   */
  if (KeINP_bntRCMsg2A5Flg) {
    COMR_cntRCMsg2A5 = KeINP_cntRCMsg2A5Val;
  } else {
    COMR_cntRCMsg2A5 = VCU_RollingCounter_2A5;
  }

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

  /* Switch: '<S383>/Switch' incorporates:
   *  Constant: '<S383>/Constant'
   *  Constant: '<S383>/Constant1'
   *  Constant: '<S455>/Conversion'
   */
  if (KeINP_balChkSumMsg2A5Flg) {
    COMR_valChkSumMsg2A5 = KeINP_valChkSumMsg2A5Val;
  } else {
    COMR_valChkSumMsg2A5 = VCU_Checksum_2A5;
  }

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

  /* Switch: '<S384>/Switch' incorporates:
   *  Constant: '<S384>/Constant'
   *  Constant: '<S384>/Constant1'
   *  Constant: '<S458>/Conversion'
   */
  if (KeINP_btVcuFalutLvlFlg) {
    COMR_stVcuFalutLvl = KeINP_stVcuFalutLvlVal;
  } else {
    COMR_stVcuFalutLvl = VCU_FaultLvl;
  }

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

  /* Switch: '<S385>/Switch' incorporates:
   *  Constant: '<S385>/Constant'
   *  Constant: '<S385>/Constant1'
   *  Constant: '<S464>/Conversion'
   */
  if (KeINP_btVcuWrkFlg) {
    COMR_stVcuWrk = KeINP_stVcuWrkVal;
  } else {
    COMR_stVcuWrk = VCU_STAUS;
  }

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

  /* Switch: '<S386>/Switch' incorporates:
   *  Constant: '<S386>/Constant'
   *  Constant: '<S386>/Constant1'
   *  Constant: '<S452>/Conversion'
   *  DataTypeConversion: '<S247>/Data Type Conversion'
   */
  if (KeINP_blgBrkPedInvldFlg) {
    COMR_flgBrkPedInvld = KeINP_flgBrkPedInvldVal;
  } else {
    COMR_flgBrkPedInvld = (VCU_BrakePedalSwitchStatus != 0);
  }

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

  /* Switch: '<S387>/Switch' incorporates:
   *  Constant: '<S387>/Constant'
   *  Constant: '<S387>/Constant1'
   *  Constant: '<S451>/Conversion'
   *  DataTypeConversion: '<S248>/Data Type Conversion'
   */
  if (KeINP_bwtBrkPedFlg) {
    COMR_swtBrkPed = KeINP_swtBrkPedVal;
  } else {
    COMR_swtBrkPed = (VCU_BrakePedalSwitchInvalid != 0);
  }

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

  /* Switch: '<S389>/Switch' incorporates:
   *  Constant: '<S389>/Constant'
   *  Constant: '<S389>/Constant1'
   *  Constant: '<S463>/Conversion'
   */
  if (KeINP_bntRCMsg2A7Flg) {
    COMR_cntRCMsg2A7 = KeINP_cntRCMsg2A7Val;
  } else {
    COMR_cntRCMsg2A7 = VCU_RollingCounter_2A7;
  }

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

  /* Switch: '<S390>/Switch' incorporates:
   *  Constant: '<S390>/Constant'
   *  Constant: '<S390>/Constant1'
   *  Constant: '<S456>/Conversion'
   */
  if (KeINP_balChkSumMsg2A7Flg) {
    COMR_valChkSumMsg2A7 = KeINP_valChkSumMsg2A7Val;
  } else {
    COMR_valChkSumMsg2A7 = VCU_Checksum_2A7;
  }

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

  /* Switch: '<S391>/Switch' incorporates:
   *  Constant: '<S336>/Conversion'
   *  Constant: '<S391>/Constant'
   *  Constant: '<S391>/Constant1'
   */
  if (KeINP_blgVcuSrceIDFlg) {
    COMR_flgVcuSrceID = KeINP_flgVcuSrceIDVal;
  } else {
    COMR_flgVcuSrceID = NMVCU_SourceID;
  }

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

  /* Switch: '<S392>/Switch' incorporates:
   *  Constant: '<S335>/Conversion'
   *  Constant: '<S392>/Constant'
   *  Constant: '<S392>/Constant1'
   *  DataTypeConversion: '<S253>/Data Type Conversion'
   */
  if (KeINP_bMRepeatReqFlg) {
    VCU_NMRepeatReq = KeINP_NMRepeatReqVal;
  } else {
    VCU_NMRepeatReq = (NMVCU_RepeatReq != 0);
  }

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

  /* Switch: '<S393>/Switch' incorporates:
   *  Constant: '<S328>/Conversion'
   *  Constant: '<S393>/Constant'
   *  Constant: '<S393>/Constant1'
   *  DataTypeConversion: '<S254>/Data Type Conversion'
   */
  if (KeINP_bMActwakeFlg) {
    VCU_NMActwake = KeINP_NMActwakeVal;
  } else {
    VCU_NMActwake = (NMVCU_Actwake != 0);
  }

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

  /* Switch: '<S394>/Switch' incorporates:
   *  Constant: '<S334>/Conversion'
   *  Constant: '<S394>/Constant'
   *  Constant: '<S394>/Constant1'
   *  DataTypeConversion: '<S255>/Data Type Conversion'
   */
  if (KeINP_blgVcuRptFromSlpFlg) {
    COMR_flgVcuRptFromSlp = KeINP_flgVcuRptFromSlpVal;
  } else {
    COMR_flgVcuRptFromSlp = (NMVCU_RepeatFromSleep != 0);
  }

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

  /* Switch: '<S395>/Switch' incorporates:
   *  Constant: '<S332>/Conversion'
   *  Constant: '<S395>/Constant'
   *  Constant: '<S395>/Constant1'
   *  DataTypeConversion: '<S256>/Data Type Conversion'
   */
  if (KeINP_blgVcuRptFromPreprFlg) {
    COMR_flgVcuRptFromPrepr = KeINP_flgVcuRptFromPreprVal;
  } else {
    COMR_flgVcuRptFromPrepr = (NMVCU_RepeatFromPrepare != 0);
  }

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

  /* Switch: '<S396>/Switch' incorporates:
   *  Constant: '<S331>/Conversion'
   *  Constant: '<S396>/Constant'
   *  Constant: '<S396>/Constant1'
   *  DataTypeConversion: '<S257>/Data Type Conversion'
   */
  if (KeINP_blgVcuRptFromNormFlg) {
    COMR_flgVcuRptFromNorm = KeINP_flgVcuRptFromNormVal;
  } else {
    COMR_flgVcuRptFromNorm = (NMVCU_RepeatFromNormal != 0);
  }

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

  /* Switch: '<S397>/Switch' incorporates:
   *  Constant: '<S333>/Conversion'
   *  Constant: '<S397>/Constant'
   *  Constant: '<S397>/Constant1'
   *  DataTypeConversion: '<S258>/Data Type Conversion'
   */
  if (KeINP_blgVcuRptFromRdyFlg) {
    COMR_flgVcuRptFromRdy = KeINP_flgVcuRptFromRdyVal;
  } else {
    COMR_flgVcuRptFromRdy = (NMVCU_RepeatFromReady != 0);
  }

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

  /* Switch: '<S398>/Switch' incorporates:
   *  Constant: '<S330>/Conversion'
   *  Constant: '<S398>/Constant'
   *  Constant: '<S398>/Constant1'
   *  DataTypeConversion: '<S259>/Data Type Conversion'
   */
  if (KeINP_blgVcuNormFromRptFlg) {
    COMR_flgVcuNormFromRpt = KeINP_flgVcuNormFromRptVal;
  } else {
    COMR_flgVcuNormFromRpt = (NMVCU_NormalFromRepeat != 0);
  }

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

  /* Switch: '<S400>/Switch' incorporates:
   *  Constant: '<S329>/Conversion'
   *  Constant: '<S400>/Constant'
   *  Constant: '<S400>/Constant1'
   *  DataTypeConversion: '<S261>/Data Type Conversion'
   */
  if (KeINP_blgVcuNormFromRdyFlg) {
    COMR_flgVcuNormFromRdy = KeINP_flgVcuNormFromRdyVal;
  } else {
    COMR_flgVcuNormFromRdy = (NMVCU_NormalFromReady != 0);
  }

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

  /* Switch: '<S401>/Switch' incorporates:
   *  Constant: '<S337>/Conversion'
   *  Constant: '<S401>/Constant'
   *  Constant: '<S401>/Constant1'
   *  DataTypeConversion: '<S262>/Data Type Conversion'
   */
  if (KeINP_blgVcuWkSrceFlg) {
    COMR_flgVcuWkSrce = KeINP_flgVcuWkSrceVal;
  } else {
    COMR_flgVcuWkSrce = (NMVCU_WakeSource != 0);
  }

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

  /* Switch: '<S402>/Switch' incorporates:
   *  Constant: '<S323>/Conversion'
   *  Constant: '<S402>/Constant'
   *  Constant: '<S402>/Constant1'
   *  DataTypeConversion: '<S263>/Data Type Conversion'
   */
  if (KeINP_blgVcuActSrce_AFlg) {
    COMR_flgVcuActSrce_A = KeINP_flgVcuActSrce_AVal;
  } else {
    COMR_flgVcuActSrce_A = (NMVCU_ActiveSource1 != 0);
  }

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

  /* Switch: '<S403>/Switch' incorporates:
   *  Constant: '<S324>/Conversion'
   *  Constant: '<S403>/Constant'
   *  Constant: '<S403>/Constant1'
   *  DataTypeConversion: '<S264>/Data Type Conversion'
   */
  if (KeINP_blgVcuActSrce_BFlg) {
    COMR_flgVcuActSrce_B = KeINP_flgVcuActSrce_BVal;
  } else {
    COMR_flgVcuActSrce_B = (NMVCU_ActiveSource2 != 0);
  }

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

  /* Switch: '<S404>/Switch' incorporates:
   *  Constant: '<S325>/Conversion'
   *  Constant: '<S404>/Constant'
   *  Constant: '<S404>/Constant1'
   *  DataTypeConversion: '<S265>/Data Type Conversion'
   */
  if (KeINP_blgVcuActSrce_CFlg) {
    COMR_flgVcuActSrce_C = KeINP_flgVcuActSrce_CVal;
  } else {
    COMR_flgVcuActSrce_C = (NMVCU_ActiveSource3 != 0);
  }

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

  /* Switch: '<S405>/Switch' incorporates:
   *  Constant: '<S326>/Conversion'
   *  Constant: '<S405>/Constant'
   *  Constant: '<S405>/Constant1'
   *  DataTypeConversion: '<S266>/Data Type Conversion'
   */
  if (KeINP_blgVcuActSrce_DFlg) {
    COMR_flgVcuActSrce_D = KeINP_flgVcuActSrce_DVal;
  } else {
    COMR_flgVcuActSrce_D = (NMVCU_ActiveSource4 != 0);
  }

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

  /* Switch: '<S406>/Switch' incorporates:
   *  Constant: '<S327>/Conversion'
   *  Constant: '<S406>/Constant'
   *  Constant: '<S406>/Constant1'
   *  DataTypeConversion: '<S267>/Data Type Conversion'
   */
  if (KeINP_blgVcuActSrce_EFlg) {
    COMR_flgVcuActSrce_E = KeINP_flgVcuActSrce_EVal;
  } else {
    COMR_flgVcuActSrce_E = (NMVCU_ActiveSource5 != 0);
  }

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

  /* Switch: '<S407>/Switch' incorporates:
   *  Constant: '<S303>/Conversion'
   *  Constant: '<S407>/Constant'
   *  Constant: '<S407>/Constant1'
   *  DataTypeConversion: '<S268>/Data Type Conversion'
   */
  if (KeINP_behSpdFlg) {
    COMR_VehSpd = KeINP_VehSpdVal;
  } else {
    COMR_VehSpd = (real32_T)ESP_VehicleSpeed * 0.05625F;
  }

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

  /* Switch: '<S408>/Switch' incorporates:
   *  Constant: '<S304>/Conversion'
   *  Constant: '<S408>/Constant'
   *  Constant: '<S408>/Constant1'
   *  DataTypeConversion: '<S269>/Data Type Conversion'
   */
  if (KeINP_behSpdVldFlg) {
    COMR_VehSpdVld = KeINP_VehSpdVldVal;
  } else {
    COMR_VehSpdVld = (ESP_VehicleSpeedValid != 0);
  }

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

  /* Switch: '<S409>/Switch' incorporates:
   *  Constant: '<S213>/Conversion'
   *  Constant: '<S409>/Constant'
   *  Constant: '<S409>/Constant1'
   *  DataTypeConversion: '<S270>/Data Type Conversion'
   */
  if (KeINP_bEnvTFlg) {
    COMR_tEnvT = KeINP_tEnvTVal;
  } else {
    COMR_tEnvT = (real32_T)CCM_OutsideTemp * 0.5F - 80.0F;
  }

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

  /* Switch: '<S411>/Switch' incorporates:
   *  Constant: '<S314>/Conversion'
   *  Constant: '<S411>/Constant'
   *  Constant: '<S411>/Constant1'
   *  DataTypeConversion: '<S272>/Data Type Conversion'
   */
  if (KeINP_balAcmDistFlg) {
    COMR_valAcmDist = KeINP_valAcmDistVal;
  } else {
    COMR_valAcmDist = (real32_T)IP_TotalOdometer * 0.1F;
  }

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

  /* Switch: '<S412>/Switch' incorporates:
   *  Constant: '<S313>/Conversion'
   *  Constant: '<S412>/Constant'
   *  Constant: '<S412>/Constant1'
   *  DataTypeConversion: '<S273>/Data Type Conversion'
   */
  if (KeINP_blgAcmDistVldFlg) {
    COMR_flgAcmDistVld = KeINP_flgAcmDistVldVal;
  } else {
    COMR_flgAcmDistVld = (IP_OdometerSts != 0);
  }

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

  /* Switch: '<S413>/Switch' incorporates:
   *  Constant: '<S306>/Conversion'
   *  Constant: '<S413>/Constant'
   *  Constant: '<S413>/Constant1'
   */
  if (KeINP_balVinCode_AFlg) {
    COMR_valVinCode_A = KeINP_valVinCode_AVal;
  } else {
    COMR_valVinCode_A = GW_VIN_Value_1;
  }

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

  /* Switch: '<S414>/Switch' incorporates:
   *  Constant: '<S307>/Conversion'
   *  Constant: '<S414>/Constant'
   *  Constant: '<S414>/Constant1'
   */
  if (KeINP_balVinCode_BFlg) {
    COMR_valVinCode_B = KeINP_valVinCode_BVal;
  } else {
    COMR_valVinCode_B = GW_VIN_Value_2;
  }

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

  /* Switch: '<S415>/Switch' incorporates:
   *  Constant: '<S308>/Conversion'
   *  Constant: '<S415>/Constant'
   *  Constant: '<S415>/Constant1'
   */
  if (KeINP_balVinCode_CFlg) {
    COMR_valVinCode_C = KeINP_valVinCode_CVal;
  } else {
    COMR_valVinCode_C = GW_VIN_Value_3;
  }

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

  /* Switch: '<S416>/Switch' incorporates:
   *  Constant: '<S309>/Conversion'
   *  Constant: '<S416>/Constant'
   *  Constant: '<S416>/Constant1'
   */
  if (KeINP_balVinCode_DFlg) {
    COMR_valVinCode_D = KeINP_valVinCode_DVal;
  } else {
    COMR_valVinCode_D = GW_VIN_Value_4;
  }

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

  /* Switch: '<S417>/Switch' incorporates:
   *  Constant: '<S310>/Conversion'
   *  Constant: '<S417>/Constant'
   *  Constant: '<S417>/Constant1'
   */
  if (KeINP_balVinCode_EFlg) {
    COMR_valVinCode_E = KeINP_valVinCode_EVal;
  } else {
    COMR_valVinCode_E = GW_VIN_Value_5;
  }

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

  /* Switch: '<S418>/Switch' incorporates:
   *  Constant: '<S311>/Conversion'
   *  Constant: '<S418>/Constant'
   *  Constant: '<S418>/Constant1'
   */
  if (KeINP_balVinCode_FFlg) {
    COMR_valVinCode_F = KeINP_valVinCode_FVal;
  } else {
    COMR_valVinCode_F = GW_VIN_Value_6;
  }

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

  /* Switch: '<S419>/Switch' incorporates:
   *  Constant: '<S312>/Conversion'
   *  Constant: '<S419>/Constant'
   *  Constant: '<S419>/Constant1'
   */
  if (KeINP_balVinCode_GFlg) {
    COMR_valVinCode_G = KeINP_valVinCode_GVal;
  } else {
    COMR_valVinCode_G = GW_VIN_Value_7;
  }

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

  /* Switch: '<S420>/Switch' incorporates:
   *  Constant: '<S305>/Conversion'
   *  Constant: '<S420>/Constant'
   *  Constant: '<S420>/Constant1'
   */
  if (KeINP_bntVinCodeNumFlg) {
    COMR_cntVinCodeNum = KeINP_cntVinCodeNumVal;
  } else {
    COMR_cntVinCodeNum = GW_VINFrameNumber;
  }

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

  /* Switch: '<S422>/Switch' incorporates:
   *  Constant: '<S205>/Conversion'
   *  Constant: '<S422>/Constant'
   *  Constant: '<S422>/Constant1'
   */
  if (KeINP_btCrashSglFlg) {
    COMR_stCrashSgl = KeINP_stCrashSglVal;
  } else {
    COMR_stCrashSgl = ABM_CrashOutputSt;
  }

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

  /* Switch: '<S423>/Switch' incorporates:
   *  Constant: '<S206>/Conversion'
   *  Constant: '<S423>/Constant'
   *  Constant: '<S423>/Constant1'
   */
  if (KeINP_bntRCMsg050Flg) {
    COMR_cntRCMsg050 = KeINP_cntRCMsg050Val;
  } else {
    COMR_cntRCMsg050 = ABM_RollingCounter_50;
  }

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

  /* Switch: '<S424>/Switch' incorporates:
   *  Constant: '<S204>/Conversion'
   *  Constant: '<S424>/Constant'
   *  Constant: '<S424>/Constant1'
   */
  if (KeINP_balChkSumMsg050Flg) {
    COMR_valChkSumMsg050 = KeINP_valChkSumMsg050Val;
  } else {
    COMR_valChkSumMsg050 = ABM_Checksum_50;
  }

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

  /* Switch: '<S425>/Switch' incorporates:
   *  Constant: '<S212>/Conversion'
   *  Constant: '<S425>/Constant'
   *  Constant: '<S425>/Constant1'
   *  DataTypeConversion: '<S286>/Data Type Conversion'
   */
  if (KeINP_bPTCOptPwrReqFlg) {
    COMR_pPTCOptPwrReq = KeINP_pPTCOptPwrReqVal;
  } else {
    COMR_pPTCOptPwrReq = (real32_T)CCM_CcmBmsReqPtcPower;
  }

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

  /* Switch: '<S426>/Switch' incorporates:
   *  Constant: '<S211>/Conversion'
   *  Constant: '<S426>/Constant'
   *  Constant: '<S426>/Constant1'
   *  DataTypeConversion: '<S287>/Data Type Conversion'
   */
  if (KeINP_bCompOptPwrReqFlg) {
    COMR_pCompOptPwrReq = KeINP_pCompOptPwrReqVal;
  } else {
    COMR_pCompOptPwrReq = (real32_T)CCM_CcmBmsReqAcPower;
  }

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

  /* Switch: '<S427>/Switch' incorporates:
   *  Constant: '<S214>/Conversion'
   *  Constant: '<S427>/Constant'
   *  Constant: '<S427>/Constant1'
   *  DataTypeConversion: '<S288>/Data Type Conversion'
   */
  if (KeINP_btPreCoolWkFlg) {
    COMR_stPreCoolWk = KeINP_stPreCoolWkVal;
  } else {
    COMR_stPreCoolWk = (CCM_PreCoolWorkSt != 0);
  }

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

  /* Switch: '<S428>/Switch' incorporates:
   *  Constant: '<S215>/Conversion'
   *  Constant: '<S428>/Constant'
   *  Constant: '<S428>/Constant1'
   *  DataTypeConversion: '<S289>/Data Type Conversion'
   */
  if (KeINP_btPreHeatlWkFlg) {
    COMR_stPreHeatlWk = KeINP_stPreHeatlWkVal;
  } else {
    COMR_stPreHeatlWk = (CCM_PreHeatWorkSt != 0);
  }

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

  /* Switch: '<S429>/Switch' incorporates:
   *  Constant: '<S316>/Conversion'
   *  Constant: '<S429>/Constant'
   *  Constant: '<S429>/Constant1'
   *  DataTypeConversion: '<S290>/Data Type Conversion'
   */
  if (KeINP_bIviDischgOrdFlg) {
    COMR_bIviDischgOrd = KeINP_bIviDischgOrdVal;
  } else {
    COMR_bIviDischgOrd = IVI_DischargeSetReq;
  }

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

  /* Switch: '<S430>/Switch' incorporates:
   *  Constant: '<S321>/Conversion'
   *  Constant: '<S430>/Constant'
   *  Constant: '<S430>/Constant1'
   *  DataTypeConversion: '<S291>/Data Type Conversion'
   */
  if (KeINP_bearSetFlg) {
    COMR_YearSet = KeINP_YearSetVal;
  } else {
    COMR_YearSet = (uint16_T)(IVI_YearSet + 2018U);
  }

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

  /* Switch: '<S431>/Switch' incorporates:
   *  Constant: '<S319>/Conversion'
   *  Constant: '<S431>/Constant'
   *  Constant: '<S431>/Constant1'
   */
  if (KeINP_bonthSetFlg) {
    COMR_MonthSet = KeINP_MonthSetVal;
  } else {
    COMR_MonthSet = IVI_MonthSet;
  }

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

  /* Switch: '<S433>/Switch' incorporates:
   *  Constant: '<S315>/Conversion'
   *  Constant: '<S433>/Constant'
   *  Constant: '<S433>/Constant1'
   */
  if (KeINP_baySetFlg) {
    COMR_DaySet = KeINP_DaySetVal;
  } else {
    COMR_DaySet = IVI_DaySet;
  }

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

  /* Switch: '<S434>/Switch' incorporates:
   *  Constant: '<S317>/Conversion'
   *  Constant: '<S434>/Constant'
   *  Constant: '<S434>/Constant1'
   */
  if (KeINP_bourSetFlg) {
    COMR_HourSet = KeINP_HourSetVal;
  } else {
    COMR_HourSet = IVI_HourSet;
  }

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

  /* Switch: '<S435>/Switch' incorporates:
   *  Constant: '<S318>/Conversion'
   *  Constant: '<S435>/Constant'
   *  Constant: '<S435>/Constant1'
   */
  if (KeINP_binSetFlg) {
    COMR_MinSet = KeINP_MinSetVal;
  } else {
    COMR_MinSet = IVI_MinuteSet;
  }

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

  /* Switch: '<S436>/Switch' incorporates:
   *  Constant: '<S320>/Conversion'
   *  Constant: '<S436>/Constant'
   *  Constant: '<S436>/Constant1'
   */
  if (KeINP_becondSetFlg) {
    COMR_SecondSet = KeINP_SecondSetVal;
  } else {
    COMR_SecondSet = IVI_SecondSet;
  }

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

  /* Switch: '<S437>/Switch' incorporates:
   *  Constant: '<S437>/Constant'
   *  Constant: '<S437>/Constant1'
   *  Constant: '<S443>/Conversion'
   */
  if (KeINP_btAppChrgOrdCmdFlg) {
    COMR_stAppChrgOrdCmd = KeINP_stAppChrgOrdCmdVal;
  } else {
    COMR_stAppChrgOrdCmd = TBOX_AppChgOrdCmd;
  }

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

  /* Switch: '<S438>/Switch' incorporates:
   *  Constant: '<S438>/Constant'
   *  Constant: '<S438>/Constant1'
   *  Constant: '<S444>/Conversion'
   */
  if (KeINP_btAppChrgOrdStartFlg) {
    COMR_stAppChrgOrdStart = KeINP_stAppChrgOrdStartVal;
  } else {
    COMR_stAppChrgOrdStart = TBOX_AppChgOrdStart;
  }

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

  /* Switch: '<S439>/Switch' incorporates:
   *  Constant: '<S207>/Conversion'
   *  Constant: '<S439>/Constant'
   *  Constant: '<S439>/Constant1'
   *  DataTypeConversion: '<S300>/Data Type Conversion'
   */
  if (KeINP_bChrgStopActiveFlg) {
    COMR_bChrgStopActive = KeINP_bChrgStopActiveVal;
  } else {
    COMR_bChrgStopActive = (BCM_StopchargeReq != 0);
  }

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

  /* Switch: '<S440>/Switch' incorporates:
   *  Constant: '<S440>/Constant'
   *  Constant: '<S440>/Constant1'
   *  Constant: '<S445>/Conversion'
   *  DataTypeConversion: '<S301>/Data Type Conversion'
   */
  if (KeINP_btOTAModeFlg) {
    BSW_stOTAMode = KeINP_stOTAModeVal;
  } else {
    BSW_stOTAMode = (TBOX_OTAmodeONReq != 0);
  }

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

  /* Switch: '<S561>/Switch' incorporates:
   *  Constant: '<S561>/Constant'
   *  Constant: '<S561>/Constant1'
   *  DataTypeConversion: '<S517>/Data Type Conversion'
   */
  if (KeINP_btS2OnFlg) {
    COMR_stS2On = KeINP_stS2OnVal;
  } else {
    COMR_stS2On = false;
  }

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

  /* Switch: '<S572>/Switch' incorporates:
   *  Constant: '<S501>/Conversion'
   *  Constant: '<S572>/Constant'
   *  Constant: '<S572>/Constant1'
   */
  if (KeINP_btInletLockFlg) {
    COMR_stInletLock = KeINP_stInletLockVal;
  } else {
    COMR_stInletLock = CSIF_ElecLockStatus;
  }

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

  /* Switch: '<S583>/Switch' incorporates:
   *  Constant: '<S499>/Conversion'
   *  Constant: '<S583>/Constant'
   *  Constant: '<S583>/Constant1'
   */
  if (KeINP_btCpStateFlg) {
    COMR_stCpState = KeINP_stCpStateVal;
  } else {
    COMR_stCpState = CSIF_CpStatus;
  }

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

  /* Switch: '<S594>/Switch' incorporates:
   *  Constant: '<S500>/Conversion'
   *  Constant: '<S594>/Constant'
   *  Constant: '<S594>/Constant1'
   */
  if (KeINP_btLockAlarmFlg) {
    COMR_stLockAlarm = KeINP_stLockAlarmVal;
  } else {
    COMR_stLockAlarm = CSIF_ElecLockFaultStatus;
  }

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

  /* Switch: '<S600>/Switch' incorporates:
   *  Constant: '<S497>/Conversion'
   *  Constant: '<S600>/Constant'
   *  Constant: '<S600>/Constant1'
   */
  if (KeINP_btPdStateFlg) {
    COMR_stPdState = KeINP_stPdStateVal;
  } else {
    COMR_stPdState = CSIF_ChgCnntPlugStatus;
  }

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

  /* Switch: '<S601>/Switch' incorporates:
   *  Constant: '<S496>/Conversion'
   *  Constant: '<S601>/Constant'
   *  Constant: '<S601>/Constant1'
   *  DataTypeConversion: '<S557>/Data Type Conversion'
   */
  if (KeINP_bMaxAChrgCurrFlg) {
    COMR_iMaxAChrgCurr = KeINP_iMaxAChrgCurrVal;
  } else {
    COMR_iMaxAChrgCurr = (real32_T)CSIF_AChrgMaxCurr;
  }

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

  /* Switch: '<S602>/Switch' incorporates:
   *  Constant: '<S498>/Conversion'
   *  Constant: '<S602>/Constant'
   *  Constant: '<S602>/Constant1'
   */
  if (KeINP_btDcAcChgModeFlg) {
    COMR_stDcAcChgMode = KeINP_stDcAcChgModeVal;
  } else {
    COMR_stDcAcChgMode = CSIF_ChrgModeDcAc;
  }

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

  /* Switch: '<S603>/Switch' incorporates:
   *  Constant: '<S503>/Conversion'
   *  Constant: '<S603>/Constant'
   *  Constant: '<S603>/Constant1'
   *  DataTypeConversion: '<S559>/Data Type Conversion'
   */
  if (KeINP_bEvseOutputVoltFlg) {
    COMR_uEvseOutputVolt = KeINP_uEvseOutputVoltVal;
  } else {
    COMR_uEvseOutputVolt = (real32_T)CSIF_EvseOutputVolt * 0.1F;
  }

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

  /* Switch: '<S604>/Switch' incorporates:
   *  Constant: '<S502>/Conversion'
   *  Constant: '<S604>/Constant'
   *  Constant: '<S604>/Constant1'
   *  DataTypeConversion: '<S560>/Data Type Conversion'
   */
  if (KeINP_bwrEvseMaxPwrLmtFlg) {
    COMR_pwrEvseMaxPwrLmt = KeINP_pwrEvseMaxPwrLmtVal;
  } else {
    COMR_pwrEvseMaxPwrLmt = (real32_T)CSIF_EvseMaxPowerLmt * 10.0F;
  }

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

  /* Switch: '<S562>/Switch' incorporates:
   *  Constant: '<S484>/Conversion'
   *  Constant: '<S562>/Constant'
   *  Constant: '<S562>/Constant1'
   */
  if (KeINP_bumComVerFlg) {
    COMR_numComVer = KeINP_numComVerVal;
  } else {
    COMR_numComVer = 0U;
  }

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

  /* Switch: '<S563>/Switch' incorporates:
   *  Constant: '<S490>/Conversion'
   *  Constant: '<S563>/Constant'
   *  Constant: '<S563>/Constant1'
   *  DataTypeConversion: '<S519>/Data Type Conversion'
   */
  if (KeINP_beserved1Flg) {
    COMR_Reserved1 = KeINP_Reserved1Val;
  } else {
    COMR_Reserved1 = CRM_ChgrNum + 1U;
  }

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

  /* Switch: '<S564>/Switch' incorporates:
   *  Constant: '<S491>/Conversion'
   *  Constant: '<S564>/Constant'
   *  Constant: '<S564>/Constant1'
   */
  if (KeINP_btIdtfRstCrmFlg) {
    COMR_stIdtfRstCrm = KeINP_stIdtfRstCrmVal;
  } else {
    COMR_stIdtfRstCrm = CRM_RecogResult;
  }

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

  /* Switch: '<S565>/Switch' incorporates:
   *  Constant: '<S489>/Conversion'
   *  Constant: '<S565>/Constant'
   *  Constant: '<S565>/Constant1'
   */
  if (KeINP_beserved2Flg) {
    COMR_Reserved2 = KeINP_Reserved2Val;
  } else {
    COMR_Reserved2 = CRM_AreaNumforChgr;
  }

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

  /* Switch: '<S566>/Switch' incorporates:
   *  Constant: '<S485>/Conversion'
   *  Constant: '<S566>/Constant'
   *  Constant: '<S566>/Constant1'
   *  DataTypeConversion: '<S522>/Data Type Conversion'
   */
  if (KeINP_bDcChrgMaxCurrOutputPmtdCmlFlg) {
    COMR_iDcChrgMaxCurrOutputPmtdCml = KeINP_iDcChrgMaxCurrOutputPmtdCmlVal;
  } else {
    COMR_iDcChrgMaxCurrOutputPmtdCml = (real32_T)CML_OutputChgCurrMax * 0.1F -
      400.0F;
  }

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

  /* Switch: '<S567>/Switch' incorporates:
   *  Constant: '<S487>/Conversion'
   *  Constant: '<S567>/Constant'
   *  Constant: '<S567>/Constant1'
   *  DataTypeConversion: '<S523>/Data Type Conversion'
   */
  if (KeINP_bDcChrgMaxVoltOutputPmtdCmlFlg) {
    COMR_uDcChrgMaxVoltOutputPmtdCml = KeINP_uDcChrgMaxVoltOutputPmtdCmlVal;
  } else {
    COMR_uDcChrgMaxVoltOutputPmtdCml = (real32_T)CML_OutputChgVoltMax * 0.1F;
  }

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

  /* Switch: '<S568>/Switch' incorporates:
   *  Constant: '<S488>/Conversion'
   *  Constant: '<S568>/Constant'
   *  Constant: '<S568>/Constant1'
   *  DataTypeConversion: '<S524>/Data Type Conversion'
   */
  if (KeINP_bDcChrgMinVoltOutputPmtdCmlFlg) {
    COMR_uDcChrgMinVoltOutputPmtdCml = KeINP_uDcChrgMinVoltOutputPmtdCmlVal;
  } else {
    COMR_uDcChrgMinVoltOutputPmtdCml = (real32_T)CML_OutputChgVoltMin * 0.1F;
  }

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

  /* Switch: '<S569>/Switch' incorporates:
   *  Constant: '<S486>/Conversion'
   *  Constant: '<S569>/Constant'
   *  Constant: '<S569>/Constant1'
   *  DataTypeConversion: '<S525>/Data Type Conversion'
   */
  if (KeINP_bDcChrgMinCurrOutputPmtdCmlFlg) {
    COMR_iDcChrgMinCurrOutputPmtdCml = KeINP_iDcChrgMinCurrOutputPmtdCmlVal;
  } else {
    COMR_iDcChrgMinCurrOutputPmtdCml = (real32_T)CML_OutputChgCurrMin * 0.1F -
      400.0F;
  }

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

  /* Switch: '<S570>/Switch' incorporates:
   *  Constant: '<S492>/Conversion'
   *  Constant: '<S570>/Constant'
   *  Constant: '<S570>/Constant1'
   */
  if (KeINP_btChrgRdyCroFlg) {
    COMR_stChrgRdyCro = KeINP_stChrgRdyCroVal;
  } else {
    COMR_stChrgRdyCro = CRO_ReadyforChg;
  }

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

  /* Switch: '<S571>/Switch' incorporates:
   *  Constant: '<S475>/Conversion'
   *  Constant: '<S571>/Constant'
   *  Constant: '<S571>/Constant1'
   *  DataTypeConversion: '<S527>/Data Type Conversion'
   */
  if (KeINP_bDcChrgOutputCurrCcsFlg) {
    COMR_iDcChrgOutputCurrCcs = KeINP_iDcChrgOutputCurrCcsVal;
  } else {
    COMR_iDcChrgOutputCurrCcs = (real32_T)CCS_OutputChgCurr * 0.1F - 400.0F;
  }

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

  /* Switch: '<S573>/Switch' incorporates:
   *  Constant: '<S474>/Conversion'
   *  Constant: '<S573>/Constant'
   *  Constant: '<S573>/Constant1'
   *  DataTypeConversion: '<S529>/Data Type Conversion'
   */
  if (KeINP_biDcChrgTimeActualCcsFlg) {
    COMR_tiDcChrgTimeActualCcs = KeINP_tiDcChrgTimeActualCcsVal;
  } else {
    COMR_tiDcChrgTimeActualCcs = (real32_T)CCS_ChgTimeAccum;
  }

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

  /* Switch: '<S574>/Switch' incorporates:
   *  Constant: '<S476>/Conversion'
   *  Constant: '<S574>/Constant'
   *  Constant: '<S574>/Constant1'
   *  DataTypeConversion: '<S530>/Data Type Conversion'
   */
  if (KeINP_bDcChrgOutputVoltCcsFlg) {
    COMR_vDcChrgOutputVoltCcs = KeINP_vDcChrgOutputVoltCcsVal;
  } else {
    COMR_vDcChrgOutputVoltCcs = (real32_T)CCS_OutputChgVolt * 0.1F;
  }

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

  /* Switch: '<S575>/Switch' incorporates:
   *  Constant: '<S473>/Conversion'
   *  Constant: '<S575>/Constant'
   *  Constant: '<S575>/Constant1'
   */
  if (KeINP_btDcChrgCmdCcsFlg) {
    COMR_stDcChrgCmdCcs = KeINP_stDcChrgCmdCcsVal;
  } else {
    COMR_stDcChrgCmdCcs = CCS_ChgPermitSt;
  }

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

  /* Switch: '<S576>/Switch' incorporates:
   *  Constant: '<S512>/Conversion'
   *  Constant: '<S576>/Constant'
   *  Constant: '<S576>/Constant1'
   */
  if (KeINP_btRchSetCondCstFlg) {
    COMR_stRchSetCondCst = KeINP_stRchSetCondCstVal;
  } else {
    COMR_stRchSetCondCst = CST_ChrgerRchSetCond;
  }

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

  /* Switch: '<S577>/Switch' incorporates:
   *  Constant: '<S515>/Conversion'
   *  Constant: '<S577>/Constant'
   *  Constant: '<S577>/Constant1'
   */
  if (KeINP_btMnlStopCstFlg) {
    COMR_stMnlStopCst = KeINP_stMnlStopCstVal;
  } else {
    COMR_stMnlStopCst = CST_MnlStop;
  }

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

  /* Switch: '<S578>/Switch' incorporates:
   *  Constant: '<S507>/Conversion'
   *  Constant: '<S578>/Constant'
   *  Constant: '<S578>/Constant1'
   */
  if (KeINP_btChrgErrStopCstFlg) {
    COMR_stChrgErrStopCst = KeINP_stChrgErrStopCstVal;
  } else {
    COMR_stChrgErrStopCst = CST_ChrgErrStop;
  }

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

  /* Switch: '<S579>/Switch' incorporates:
   *  Constant: '<S505>/Conversion'
   *  Constant: '<S579>/Constant'
   *  Constant: '<S579>/Constant1'
   */
  if (KeINP_btBmsStopActCstFlg) {
    COMR_stBmsStopActCst = KeINP_stBmsStopActCstVal;
  } else {
    COMR_stBmsStopActCst = CST_BmsStopAct;
  }

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

  /* Switch: '<S580>/Switch' incorporates:
   *  Constant: '<S511>/Conversion'
   *  Constant: '<S580>/Constant'
   *  Constant: '<S580>/Constant1'
   */
  if (KeINP_btChrgerOvrTempErrCstFlg) {
    COMR_stChrgerOvrTempErrCst = KeINP_stChrgerOvrTempErrCstVal;
  } else {
    COMR_stChrgerOvrTempErrCst = CST_ChrgerOvrTempErr;
  }

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

  /* Switch: '<S581>/Switch' incorporates:
   *  Constant: '<S509>/Conversion'
   *  Constant: '<S581>/Constant'
   *  Constant: '<S581>/Constant1'
   */
  if (KeINP_btChrgerCnntErrCstFlg) {
    COMR_stChrgerCnntErrCst = KeINP_stChrgerCnntErrCstVal;
  } else {
    COMR_stChrgerCnntErrCst = CST_ChrgerCnntErr;
  }

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

  /* Switch: '<S582>/Switch' incorporates:
   *  Constant: '<S510>/Conversion'
   *  Constant: '<S582>/Constant'
   *  Constant: '<S582>/Constant1'
   */
  if (KeINP_btChrgerInrOvrTempErrCstFlg) {
    COMR_stChrgerInrOvrTempErrCst = KeINP_stChrgerInrOvrTempErrCstVal;
  } else {
    COMR_stChrgerInrOvrTempErrCst = CST_ChrgerInrOvrTempErr;
  }

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

  /* Switch: '<S584>/Switch' incorporates:
   *  Constant: '<S514>/Conversion'
   *  Constant: '<S584>/Constant'
   *  Constant: '<S584>/Constant1'
   */
  if (KeINP_btEnrgTxAbnrmErrCstFlg) {
    COMR_stEnrgTxAbnrmErrCst = KeINP_stEnrgTxAbnrmErrCstVal;
  } else {
    COMR_stEnrgTxAbnrmErrCst = CST_EnrgTxAbnrmErr;
  }

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

  /* Switch: '<S585>/Switch' incorporates:
   *  Constant: '<S513>/Conversion'
   *  Constant: '<S585>/Constant'
   *  Constant: '<S585>/Constant1'
   */
  if (KeINP_btChrgerSrmErrCstFlg) {
    COMR_stChrgerSrmErrCst = KeINP_stChrgerSrmErrCstVal;
  } else {
    COMR_stChrgerSrmErrCst = CST_ChrgerSrmErr;
  }

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

  /* Switch: '<S586>/Switch' incorporates:
   *  Constant: '<S516>/Conversion'
   *  Constant: '<S586>/Constant'
   *  Constant: '<S586>/Constant1'
   */
  if (KeINP_btOtherErrCstFlg) {
    COMR_stOtherErrCst = KeINP_stOtherErrCstVal;
  } else {
    COMR_stOtherErrCst = CST_OtherErr;
  }

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

  /* Switch: '<S587>/Switch' incorporates:
   *  Constant: '<S506>/Conversion'
   *  Constant: '<S587>/Constant'
   *  Constant: '<S587>/Constant1'
   */
  if (KeINP_btChrgCurrAbnrmCstFlg) {
    COMR_stChrgCurrAbnrmCst = KeINP_stChrgCurrAbnrmCstVal;
  } else {
    COMR_stChrgCurrAbnrmCst = CST_ChrgCurrAbnrm;
  }

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

  /* Switch: '<S588>/Switch' incorporates:
   *  Constant: '<S508>/Conversion'
   *  Constant: '<S588>/Constant'
   *  Constant: '<S588>/Constant1'
   */
  if (KeINP_btChrgVoltAbnrmCstFlg) {
    COMR_stChrgVoltAbnrmCst = KeINP_stChrgVoltAbnrmCstVal;
  } else {
    COMR_stChrgVoltAbnrmCst = CST_ChrgVoltAbnrm;
  }

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

  /* Switch: '<S589>/Switch' incorporates:
   *  Constant: '<S494>/Conversion'
   *  Constant: '<S589>/Constant'
   *  Constant: '<S589>/Constant1'
   *  DataTypeConversion: '<S545>/Data Type Conversion'
   */
  if (KeINP_bumChrgerNumCsdFlg) {
    COMR_numChrgerNumCsd = KeINP_numChrgerNumCsdVal;
  } else {
    COMR_numChrgerNumCsd = CSD_ChgrNum + 1U;
  }

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

  /* Switch: '<S590>/Switch' incorporates:
   *  Constant: '<S495>/Conversion'
   *  Constant: '<S590>/Constant'
   *  Constant: '<S590>/Constant1'
   *  DataTypeConversion: '<S546>/Data Type Conversion'
   */
  if (KeINP_bOutpEnrgCsdFlg) {
    COMR_eOutpEnrgCsd = KeINP_eOutpEnrgCsdVal;
  } else {
    COMR_eOutpEnrgCsd = (real32_T)CSD_OutputChgEngTotal * 0.1F;
  }

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

  /* Switch: '<S591>/Switch' incorporates:
   *  Constant: '<S493>/Conversion'
   *  Constant: '<S591>/Constant'
   *  Constant: '<S591>/Constant1'
   *  DataTypeConversion: '<S547>/Data Type Conversion'
   */
  if (KeINP_biChrgTimeCsdFlg) {
    COMR_tiChrgTimeCsd = KeINP_tiChrgTimeCsdVal;
  } else {
    COMR_tiChrgTimeCsd = (real32_T)CSD_ChgTimeTotal;
  }

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

  /* Switch: '<S592>/Switch' incorporates:
   *  Constant: '<S477>/Conversion'
   *  Constant: '<S592>/Constant'
   *  Constant: '<S592>/Constant1'
   */
  if (KeINP_btRcvBrmTimeOutCemFlg) {
    COMR_stRcvBrmTimeOutCem = KeINP_stRcvBrmTimeOutCemVal;
  } else {
    COMR_stRcvBrmTimeOutCem = CEM_RcvMsgTimeOut1_BRM;
  }

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

  /* Switch: '<S593>/Switch' incorporates:
   *  Constant: '<S478>/Conversion'
   *  Constant: '<S593>/Constant'
   *  Constant: '<S593>/Constant1'
   */
  if (KeINP_btRcvBcpTimeOutCemFlg) {
    COMR_stRcvBcpTimeOutCem = KeINP_stRcvBcpTimeOutCemVal;
  } else {
    COMR_stRcvBcpTimeOutCem = CEM_RcvMsgTimeOut2_BCP;
  }

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

  /* Switch: '<S595>/Switch' incorporates:
   *  Constant: '<S479>/Conversion'
   *  Constant: '<S595>/Constant'
   *  Constant: '<S595>/Constant1'
   */
  if (KeINP_btRcvBroOkTimeOutCemFlg) {
    COMR_stRcvBroOkTimeOutCem = KeINP_stRcvBroOkTimeOutCemVal;
  } else {
    COMR_stRcvBroOkTimeOutCem = CEM_RcvMsgTimeOut3_BRO_OK;
  }

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

  /* Switch: '<S596>/Switch' incorporates:
   *  Constant: '<S480>/Conversion'
   *  Constant: '<S596>/Constant'
   *  Constant: '<S596>/Constant1'
   */
  if (KeINP_btRcvBcsTimeOutCemFlg) {
    COMR_stRcvBcsTimeOutCem = KeINP_stRcvBcsTimeOutCemVal;
  } else {
    COMR_stRcvBcsTimeOutCem = CEM_RcvMsgTimeOut4_BCS;
  }

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

  /* Switch: '<S597>/Switch' incorporates:
   *  Constant: '<S481>/Conversion'
   *  Constant: '<S597>/Constant'
   *  Constant: '<S597>/Constant1'
   */
  if (KeINP_btRcvBclTimeOutCemFlg) {
    COMR_stRcvBclTimeOutCem = KeINP_stRcvBclTimeOutCemVal;
  } else {
    COMR_stRcvBclTimeOutCem = CEM_RcvMsgTimeOut5_BCL;
  }

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

  /* Switch: '<S598>/Switch' incorporates:
   *  Constant: '<S482>/Conversion'
   *  Constant: '<S598>/Constant'
   *  Constant: '<S598>/Constant1'
   */
  if (KeINP_btRcvBstTimeOutCemFlg) {
    COMR_stRcvBstTimeOutCem = KeINP_stRcvBstTimeOutCemVal;
  } else {
    COMR_stRcvBstTimeOutCem = CEM_RcvMsgTimeOut6_BST;
  }

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

  /* Switch: '<S599>/Switch' incorporates:
   *  Constant: '<S483>/Conversion'
   *  Constant: '<S599>/Constant'
   *  Constant: '<S599>/Constant1'
   */
  if (KeINP_btRcvBsdTimeOutCemFlg) {
    COMR_stRcvBsdTimeOutCem = KeINP_stRcvBsdTimeOutCemVal;
  } else {
    COMR_stRcvBsdTimeOutCem = CEM_RcvMsgTimeOut7_BSD;
  }

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

  /* Switch: '<S617>/Switch' incorporates:
   *  Constant: '<S617>/Constant'
   *  Constant: '<S617>/Constant1'
   *  Constant: '<S631>/Conversion'
   */
  if (KeINP_bcHvilPwmDutyInpFlg) {
    BSW_dcHvilPwmDutyInp = KeINP_dcHvilPwmDutyInpVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT1' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetDutyCycle_I_F_HVIL1(), 100U, 32768U);

    /* End of Outputs for SubSystem: '<S7>/DT1' */
    BSW_dcHvilPwmDutyInp = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S621>/Switch' incorporates:
   *  Constant: '<S621>/Constant'
   *  Constant: '<S621>/Constant1'
   *  Constant: '<S635>/Conversion'
   */
  if (KeINP_bHvilPwmFrqFlg) {
    BSW_fHvilPwmFrq = KeINP_fHvilPwmFrqVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT2' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetPeriod_I_F_HVIL1(), 1U, 1000U);

    /* End of Outputs for SubSystem: '<S7>/DT2' */
    BSW_fHvilPwmFrq = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S622>/Switch' incorporates:
   *  Constant: '<S622>/Constant'
   *  Constant: '<S622>/Constant1'
   *  Constant: '<S639>/Conversion'
   */
  if (KeINP_btHVILInpFlg) {
    BSW_stHVILInp = KeINP_stHVILInpVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT3' */
    rtb_DataTypeConversion_jo = (uint8_T) IOS_INP_DT12
      (Sws_Io_Icu_GetState_I_F_HVIL1(), 1U, 1U);

    /* End of Outputs for SubSystem: '<S7>/DT3' */
    BSW_stHVILInp = rtb_DataTypeConversion_jo;
  }

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

  /* Switch: '<S623>/Switch' incorporates:
   *  Constant: '<S623>/Constant'
   *  Constant: '<S623>/Constant1'
   *  Constant: '<S630>/Conversion'
   */
  if (KeINP_bcCrashPwmDutyFlg) {
    BSW_dcCrashPwmDuty = KeINP_dcCrashPwmDutyVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT4' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetDutyCycle_I_F_Crash(), 100U, 32768U);

    /* End of Outputs for SubSystem: '<S7>/DT4' */
    BSW_dcCrashPwmDuty = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S624>/Switch' incorporates:
   *  Constant: '<S624>/Constant'
   *  Constant: '<S624>/Constant1'
   *  Constant: '<S634>/Conversion'
   */
  if (KeINP_bCrashPwmFrqFlg) {
    BSW_fCrashPwmFrq = KeINP_fCrashPwmFrqVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT5' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetPeriod_I_F_Crash(), 1U, 1000U);

    /* End of Outputs for SubSystem: '<S7>/DT5' */
    BSW_fCrashPwmFrq = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S625>/Switch' incorporates:
   *  Constant: '<S625>/Constant'
   *  Constant: '<S625>/Constant1'
   *  Constant: '<S638>/Conversion'
   */
  if (KeINP_btCrashInptFlg) {
    BSW_stCrashInpt = KeINP_stCrashInptVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT6' */
    rtb_DataTypeConversion_jo = (uint8_T) IOS_INP_DT12
      (Sws_Io_Icu_GetState_I_F_Crash(), 1U, 1U);

    /* End of Outputs for SubSystem: '<S7>/DT6' */
    BSW_stCrashInpt = rtb_DataTypeConversion_jo;
  }

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

  /* Switch: '<S626>/Switch' incorporates:
   *  Constant: '<S626>/Constant'
   *  Constant: '<S626>/Constant1'
   *  Constant: '<S632>/Conversion'
   */
  if (KeINP_bcHvilPwmDutyOutDetFlg) {
    BSW_dcHvilPwmDutyOutDet = KeINP_dcHvilPwmDutyOutDetVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT7' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetDutyCycle_I_F_HVIL2_OUT_Fbk(), 100U, 32768U);

    /* End of Outputs for SubSystem: '<S7>/DT7' */
    BSW_dcHvilPwmDutyOutDet = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S627>/Switch' incorporates:
   *  Constant: '<S627>/Constant'
   *  Constant: '<S627>/Constant1'
   *  Constant: '<S636>/Conversion'
   */
  if (KeINP_bHvilPwmFrqOutDetFlg) {
    BSW_fHvilPwmFrqOutDet = KeINP_fHvilPwmFrqOutDetVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT8' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetPeriod_I_F_HVIL2_OUT_Fbk(), 1U, 1000U);

    /* End of Outputs for SubSystem: '<S7>/DT8' */
    BSW_fHvilPwmFrqOutDet = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S628>/Switch' incorporates:
   *  Constant: '<S628>/Constant'
   *  Constant: '<S628>/Constant1'
   *  Constant: '<S640>/Conversion'
   */
  if (KeINP_btHVILOutpFdbkFlg) {
    BSW_stHVILOutpFdbk = KeINP_stHVILOutpFdbkVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT9' */
    rtb_DataTypeConversion_jo = (uint8_T) IOS_INP_DT12
      (Sws_Io_Icu_GetState_I_F_HVIL2_OUT_Fbk(), 1U, 1U);

    /* End of Outputs for SubSystem: '<S7>/DT9' */
    BSW_stHVILOutpFdbk = rtb_DataTypeConversion_jo;
  }

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

  /* Switch: '<S618>/Switch' incorporates:
   *  Constant: '<S618>/Constant'
   *  Constant: '<S618>/Constant1'
   *  Constant: '<S629>/Conversion'
   */
  if (KeINP_bcCrashPwmDutyOutDetFlg) {
    BSW_dcCrashPwmDutyOutDet = KeINP_dcCrashPwmDutyOutDetVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT10' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetDutyCycle_I_F_Crash(), 100U, 32768U);

    /* End of Outputs for SubSystem: '<S7>/DT10' */
    BSW_dcCrashPwmDutyOutDet = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S619>/Switch' incorporates:
   *  Constant: '<S619>/Constant'
   *  Constant: '<S619>/Constant1'
   *  Constant: '<S633>/Conversion'
   */
  if (KeINP_bCrashPwmFrqOutDetFlg) {
    BSW_fCrashPwmFrqOutDet = KeINP_fCrashPwmFrqOutDetVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT11' */
    rtb_DataTypeConversion_iik = (real32_T) IOS_INP_DT1
      (Sws_Io_Icu_GetPeriod_I_F_Crash(), 1U, 1000U);

    /* End of Outputs for SubSystem: '<S7>/DT11' */
    BSW_fCrashPwmFrqOutDet = rtb_DataTypeConversion_iik;
  }

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

  /* Switch: '<S620>/Switch' incorporates:
   *  Constant: '<S620>/Constant'
   *  Constant: '<S620>/Constant1'
   *  Constant: '<S637>/Conversion'
   */
  if (KeINP_btCrashOutpFdbkFlg) {
    BSW_stCrashOutpFdbk = KeINP_stCrashOutpFdbkVal;
  } else {
    /* Outputs for Atomic SubSystem: '<S7>/DT12' */
    rtb_DataTypeConversion_jo = (uint8_T) IOS_INP_DT12
      (Sws_Io_Icu_GetState_I_F_Crash(), 1U, 1U);

    /* End of Outputs for SubSystem: '<S7>/DT12' */
    BSW_stCrashOutpFdbk = rtb_DataTypeConversion_jo;
  }

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

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()1' */

  /* Constant: '<S58>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_CC2(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_CC21);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()1' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()2' */

  /* Constant: '<S59>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_CC2(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_CC22);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CC2()2' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_IsoDet()3' */

  /* Constant: '<S119>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV_IsoDet(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV_IsoDet3);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_IsoDet()3' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Rly_Volt()4' */

  /* Constant: '<S128>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_UBR_Rly_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_UBR_Rly_Vo_e);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Rly_Volt()4' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()5' */

  /* Constant: '<S134>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_UBR_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_UBR_Volt5);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()5' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr()6' */

  /* Constant: '<S98>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Plus);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Curr()6' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr()7' */

  /* Constant: '<S80>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Curr()7' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr()8' */

  /* Constant: '<S92>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Minu);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Curr()8' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr()9' */

  /* Constant: '<S86>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Curr()9' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()10' */

  /* Constant: '<S62>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_CMC_Fbk_Vo_b);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_CMC_Fbk_Volt()10' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()11' */

  /* Constant: '<S83>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT1_F_i);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT1_Fbk_Volt()11' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()12' */

  /* Constant: '<S89>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_CONT2_F_g);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_CONT2_Fbk_Volt()12' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()13' */

  /* Constant: '<S101>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Pl_e);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Plus_Fbk_Volt()13' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()14' */

  /* Constant: '<S95>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HS_Main_Mi_m);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HS_Main_Minus_Fbk_Volt()14' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()15' */

  /* Constant: '<S133>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_UBR_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_UBR_Volt15);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_UBR_Volt()15' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()16' */

  /* Constant: '<S122>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV_Plus(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV_Plus16);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV_Plus()16' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV4()17' */

  /* Constant: '<S110>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV4(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV417);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV4()17' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV2()18' */

  /* Constant: '<S104>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV2(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV218);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV2()18' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV6()19' */

  /* Constant: '<S116>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV6(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV619);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV6()19' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV5()20' */

  /* Constant: '<S113>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV5(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV520);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV5()20' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()21' */

  /* Constant: '<S65>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_Coolt_In_Temp(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Coolt_In_Tem);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_In_Temp()21' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()22' */

  /* Constant: '<S68>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_Coolt_Out_Temp(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Coolt_Out_Te);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Coolt_Out_Temp()22' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD5()23' */

  /* Constant: '<S50>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_AD5(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_AD523);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD5()23' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD4()24' */

  /* Constant: '<S47>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_AD4(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_AD424);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD4()24' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD3()25' */

  /* Constant: '<S44>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_AD3(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_AD325);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_AD3()25' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Aplus()26' */

  /* Constant: '<S53>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_Aplus(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Aplus26);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Aplus()26' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()27' */

  /* Constant: '<S71>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_Curr_Sens_Hall(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Curr_Sens_Ha);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Curr_Sens_Hall()27' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_Current()28' */

  /* Constant: '<S74>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HSD_Current(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HSD_Current2);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_Current()28' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_HS()29' */

  /* Constant: '<S77>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HSD_HS(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HSD_HS29);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HSD_HS()29' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV3()30' */

  /* Constant: '<S107>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_HV3(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_HV330);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_HV3()30' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Heat_Temp()31' */

  /* Constant: '<S125>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_Heat_Temp(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_Heat_Temp31);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_Heat_Temp()31' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt()32' */

  /* Constant: '<S137>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_VDD5Ref2_Vol);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref2_Volt()32' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref_Volt()33' */

  /* Constant: '<S140>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_VDD5Ref_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_VDD5Ref_Vo_f);

  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Ref_Volt()33' */

  /* Update for Atomic SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Trc_Volt()34' */

  /* Constant: '<S143>/Conversion' */
  AI_Filter_Update(Sws_Io_Adc_Get_I_A_VDD5Trc_Volt(),
                   &IOS_INP_DWork.Sws_Io_Adc_Get_I_A_VDD5Trc_Vo_e);

  COMR_pMaxpwrObcChrg = OBC_HV_DC_MAXPOWER * 10U;
  /* End of Update for SubSystem: '<S2>/Sws_Io_Adc_Get_I_A_VDD5Trc_Volt()34' */
}

/* Model initialize function */
void IOS_INP_initialize(void)
{
  /* SystemInitialize for Atomic SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Wake()1' */
  DI_Filter_Init(&IOS_INP_B.output);

  /* End of SystemInitialize for SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Wake()1' */

  /* SystemInitialize for Atomic SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Key()2' */
  DI_Filter_Init(&IOS_INP_B.output_f);

  /* End of SystemInitialize for SubSystem: '<S5>/Sws_Io_Dio_Get_I_S_Key()2' */
}

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

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