#include "Common_include.h"
#if (CAN_3RD)
#pragma location="BACKUP_RAM_CONTENT"
SOFTWARE_VARIANT_CODING_STRUCT SoftwareVariantCoding;
volatile  HTCU_04_10ms_                   HTCU_04_10ms;
//volatile  HCU_02_10ms_                    HCU_02_10ms;
volatile  EMS_07_10ms_                    EMS_07_10ms;
volatile  EMS_11_10ms_                    EMS_11_10ms;
volatile  HCU_03_10ms_                    HCU_03_10ms;
volatile  ABS_ESC_01_10ms_                ABS_ESC_01_10ms;
volatile  EMS_01_10ms_                    EMS_01_10ms;
volatile  EMS_02_10ms_                    EMS_02_10ms;
volatile  ESC_01_10ms_                    ESC_01_10ms;
volatile  MDPS_01_10ms_                   MDPS_01_10ms;
//volatile  SAS_01_10ms_                    SAS_01_10ms;
//volatile  SBW_SHFTR_FF_01_10ms_           SBW_SHFTR_FF_01_10ms;
//volatile  SCU_FF_01_10ms_                 SCU_FF_01_10ms;
volatile  TCU_01_10ms_                    TCU_01_10ms;
volatile  HTCU_05_10ms_                   HTCU_05_10ms;
//volatile  TCU_02_10ms_                    TCU_02_10ms;
volatile  WHL_01_10ms_                    WHL_01_10ms;
volatile  ADAS_CMD_30_10ms_               ADAS_CMD_30_10ms;     
volatile  RKE_01_00ms_                    RKE_01_00ms;
volatile  SMK_01_00ms_                    SMK_01_00ms;

//volatile  ADAS_PRK_10_20ms_               ADAS_PRK_10_20ms;
//volatile  ADAS_PRK_20_20ms_               ADAS_PRK_20_20ms;
//volatile  ADAS_PRK_21_20ms_               ADAS_PRK_21_20ms;
volatile  AWD_01_20ms_                    AWD_01_20ms;
volatile  DATC_01_20ms_                   DATC_01_20ms;
volatile  ADAS_CMD_10_20ms_               ADAS_CMD_10_20ms;
volatile  ADAS_CMD_20_20ms_               ADAS_CMD_20_20ms;

volatile  EPB_01_50ms_                    EPB_01_50ms;
volatile  ADAS_CMD_31_50ms_               ADAS_CMD_31_50ms;
volatile  RR_C_RDR_01_50ms_               RR_C_RDR_01_50ms;
volatile  RR_C_RDR_02_50ms_               RR_C_RDR_02_50ms;


volatile  HTCU_06_100ms_                 HTCU_06_100ms;
volatile  BMS_02_100ms_                   BMS_02_100ms;
volatile  BMS_06_100ms_                   BMS_06_100ms;
volatile  HCU_05_100ms_                   HCU_05_100ms;
volatile  HCU_04_100ms_                   HCU_04_100ms;
volatile  HTCU_07_100ms_                  HTCU_07_100ms;
volatile  LDC_01_100ms_                   LDC_01_100ms;
volatile  EMS_08_100ms_                   EMS_08_100ms;
volatile  OBC_01_100ms_                   OBC_01_100ms;
volatile  ACU_01_100ms_                   ACU_01_100ms;
volatile  ECS_01_100ms_                   ECS_01_100ms;
volatile  LDC48V_01_100ms_                   LDC48V_01_100ms;
//volatile  BMS_13_48V_100ms_                   BMS_13_48V_100ms;
volatile  EMS_05_100ms_                   EMS_05_100ms;
volatile  SCU_FF_02_100ms_                SCU_FF_02_100ms;
volatile  TCU_03_100ms_                   TCU_03_100ms;
volatile  FR_CMR_02_100ms_                FR_CMR_02_100ms;


volatile  SWRC_01_200ms_                  SWRC_01_200ms;
volatile  SWRC_05_200ms_                  SWRC_05_200ms;
//volatile  RCS_01_200ms_                   RCS_01_200ms;
volatile  SWRC_01_200ms_                   SWRC_01_200ms;


volatile  ICU_12_200ms_                   ICU_12_200ms;
volatile  ILCU_RH_01_200ms_               ILCU_RH_01_200ms;
volatile  ILCU_LH_01_200ms_               ILCU_LH_01_200ms;
volatile  BCM_03_200ms_                   BCM_03_200ms;
volatile  BCM_04_200ms_                   BCM_04_200ms;
volatile  BCM_05_200ms_                   BCM_05_200ms;
volatile  BCM_06_200ms_                   BCM_06_200ms;
volatile  BCM_07_200ms_                   BCM_07_200ms;
volatile  BCM_09_200ms_                   BCM_09_200ms;
//volatile  BCM_10_200ms_                   BCM_10_200ms;
//volatile  BCM_11_200ms_                   BCM_11_200ms;
//volatile  BCM_12_200ms_                   BCM_12_200ms;
//volatile  CTM_01_200ms_                   CTM_01_200ms;
//volatile  IAU_16_200ms_                   IAU_16_200ms;
//volatile  IAU_23_200ms_                   IAU_23_200ms;
//volatile  IAU_24_200ms_                   IAU_24_200ms;
//volatile  IBU_MFSW_01_200ms_              IBU_MFSW_01_200ms;
//volatile  IBU_MFSW_02_200ms_              IBU_MFSW_02_200ms;
volatile  ICU_02_200ms_                   ICU_02_200ms;
volatile  ICU_04_200ms_                   ICU_04_200ms;
volatile  ICU_05_200ms_                   ICU_05_200ms;
//volatile  ICU_06_200ms_                   ICU_06_200ms;
volatile  ICU_07_200ms_                   ICU_07_200ms;
volatile  ICU_08_200ms_                   ICU_08_200ms;
//volatile  ICU_10_200ms_                   ICU_10_200ms;
//volatile  MFSW_01_200ms_                  MFSW_01_200ms;;
//volatile  MFSW_02_200ms_                  MFSW_02_200ms;
//volatile  PSM_02_200ms_                   PSM_02_200ms;
//volatile  PTGM_01_200ms_                  PTGM_01_200ms;
//volatile  EMS_03_10ms_                    EMS_03_10ms;
//volatile  SMK_02_200ms_                   SMK_02_200ms;
volatile  SMK_04_200ms_                   SMK_04_200ms;
volatile  EMS_14_200ms_                   EMS_14_200ms;
volatile  SMK_06_200ms_                   SMK_06_200ms;;
volatile  TPMS_01_200ms_                  TPMS_01_200ms;
volatile  WPC_01_200ms_                   WPC_01_200ms;
volatile  DATC_05_200ms_                  DATC_05_200ms;

//volatile  ICU_11_1000ms_                  ICU_11_1000ms;
//volatile  ROA_01_1000ms_                  ROA_01_1000ms;
volatile  ECALL_CLU_PE_01_                ECALL_CLU_PE_01;
//volatile  IFS_01_200ms_                   IFS_01_200ms;

volatile EMS_01_10ms_                EMS_01_10ms;
volatile  HU_MON_PE_01_              HU_MON_PE_01;
volatile  HU_USM_E_05_                    HU_USM_E_05;
volatile  HU_USM_E_04_       HU_USM_E_04;
volatile  HU_CLU_PE_05_      HU_CLU_PE_05;
volatile  HU_CLU_PE_06_      HU_CLU_PE_06;
volatile  IEB_01_10ms_                    IEB_01_10ms;
volatile  EVP_01_200ms_                   EVP_01_200ms;
volatile  FR_CMR_01_10ms_                 FR_CMR_01_10ms;
volatile  HU_GW_PE_01_                    HU_GW_PE_01;


#define ByteToWord(x, y, m, n) (uint32_t)(((x) << 24) + ((y) << 16) + ((m) << 8) + (n))
#define ByteToHalfWord(x, y) (uint16_t)(((x) << 8) + (y))

//xxhh add
/*Send_Data Send_7CE_Data;
CGW2_     CGW2;
EMS11_    EMS11;
*/
//xxhh add end
//CAN_DATA_STRUCT CanDataStruct;
//MMCAN_DATA_STRUCT MMCanDataStruct;
static const INIT_CAN_FRAME CanInit[] = {
    
    
    
    
    //SU2_C-CAN_RX
    /*ID        timeout    continueCnts                                                     */
    /*     peroid     lv1 2  3         analysis func                 timeoutfunc            */
	{0x040, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x040, CanFrameTimeoutFunc_0x040, NULL},
	{0x060, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x060, CanFrameTimeoutFunc_0x060, NULL},
	{0x06A, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x06A, CanFrameTimeoutFunc_0x06A, NULL},
	{0x06F, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x06F, CanFrameTimeoutFunc_0x06F, NULL},
	{0x0A0, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x0A0, CanFrameTimeoutFunc_0x0A0, NULL},
	{0x0B5, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x0B5, CanFrameTimeoutFunc_0x0B5, NULL},
	{0x0EA, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x0EA, CanFrameTimeoutFunc_0x0EA, NULL},
	{0x100, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x100, CanFrameTimeoutFunc_0x100, NULL},
	{0x11A, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x11A, CanFrameTimeoutFunc_0x11A, NULL},
	{0x125, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x125, CanFrameTimeoutFunc_0x125, NULL},
	{0x12A, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x12A, CanFrameTimeoutFunc_0x12A, NULL},
	{0x130, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x130, CanFrameTimeoutFunc_0x130, NULL},
	{0x145, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x145, CanFrameTimeoutFunc_0x145, NULL},
	{0x15A, 10, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x15A, CanFrameTimeoutFunc_0x15A, NULL},
	{0x160, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x160, CanFrameTimeoutFunc_0x160, NULL},
	{0x165, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x165, CanFrameTimeoutFunc_0x165, NULL},
	{0x16A, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x16A, CanFrameTimeoutFunc_0x16A, NULL},
	{0x170, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x170, CanFrameTimeoutFunc_0x170, NULL},
	{0x1A0, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1A0, CanFrameTimeoutFunc_0x1A0, NULL},
	{0x1A5, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1A5, CanFrameTimeoutFunc_0x1A5, NULL},
    {0x1AA, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1AA, CanFrameTimeoutFunc_0x1AA, NULL},
    {0x180, 20, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x180, CanFrameTimeoutFunc_0x180, NULL},
	{0x1BA, 50, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1BA, CanFrameTimeoutFunc_0x1BA, NULL},
	{0x1E0, 50, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1E0, CanFrameTimeoutFunc_0x1E0, NULL},
	{0x1E5, 50, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1E5, CanFrameTimeoutFunc_0x1E5, NULL},
	{0x1F0, 50, 500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1F0, CanFrameTimeoutFunc_0x1F0, NULL},
	{0x1FA, 100, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x1FA, CanFrameTimeoutFunc_0x1FA, NULL},
	{0x20A, 100, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x20A, CanFrameTimeoutFunc_0x20A, NULL},
	{0x220, 100, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x220, CanFrameTimeoutFunc_0x220, NULL},
    {0x225,  100, 1000, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x225, CanFrameTimeoutFunc_0x225, NULL},
	{0x260, 100, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x260, CanFrameTimeoutFunc_0x260, NULL},
	{0x2D0, 100, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x2D0, CanFrameTimeoutFunc_0x2D0, NULL},
	{0x382, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x382, CanFrameTimeoutFunc_0x382, NULL},
	{0x386, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x386, CanFrameTimeoutFunc_0x386, NULL},
	{0x3A0, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3A0, CanFrameTimeoutFunc_0x3A0, NULL},
	{0x3A5, 100, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3A5, CanFrameTimeoutFunc_0x3A5, NULL},
	{0x3A6, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3A6, CanFrameTimeoutFunc_0x3A6, NULL},
	{0x3C0, 1000, 2500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3C0, CanFrameTimeoutFunc_0x3C0, NULL},
	{0x3C1, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3C1, CanFrameTimeoutFunc_0x3C1, NULL},
	{0x3C2, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3C2, CanFrameTimeoutFunc_0x3C2, NULL},
	{0x3E1, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3E1, CanFrameTimeoutFunc_0x3E1, NULL},
	{0x3E2, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3E2, CanFrameTimeoutFunc_0x3E2, NULL},
	{0x3E5, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3E5, CanFrameTimeoutFunc_0x3E5, NULL},
	{0x3E6, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x3E6, CanFrameTimeoutFunc_0x3E6, NULL},
	{0x408, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x408, CanFrameTimeoutFunc_0x408, NULL},
	{0x40C, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x40C, CanFrameTimeoutFunc_0x40C, NULL},
	{0x410, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x410, CanFrameTimeoutFunc_0x410, NULL},
	{0x411, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x411, CanFrameTimeoutFunc_0x411, NULL},
	{0x08B, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x08B, CanFrameTimeoutFunc_0x08B, NULL},
	{0x413, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x413, CanFrameTimeoutFunc_0x413, NULL},
	{0x414, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x414, CanFrameTimeoutFunc_0x414, NULL},
	{0x416, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x416, CanFrameTimeoutFunc_0x416, NULL},
	{0x417, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x417, CanFrameTimeoutFunc_0x417, NULL},
	{0x418, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x418, CanFrameTimeoutFunc_0x418, NULL},
	{0x41A, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x41A, CanFrameTimeoutFunc_0x41A, NULL},
	{0x41C, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x41C, CanFrameTimeoutFunc_0x41C, NULL},
	{0x422, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x422, CanFrameTimeoutFunc_0x422, NULL},
	{0x425, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x425, CanFrameTimeoutFunc_0x425, NULL},
	{0x432, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x432, CanFrameTimeoutFunc_0x432, NULL},
	{0x434, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x434, CanFrameTimeoutFunc_0x434, NULL},
	{0x437, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x437, CanFrameTimeoutFunc_0x437, NULL},
	{0x442, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x442, CanFrameTimeoutFunc_0x442, NULL},
	{0x444, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x444, CanFrameTimeoutFunc_0x444, NULL},
	{0x445, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x445, CanFrameTimeoutFunc_0x445, NULL},
	{0x44B, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x44B, CanFrameTimeoutFunc_0x44B, NULL},
	{0x476, 600, 2500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x476, CanFrameTimeoutFunc_0x476, NULL},
	{0x477, 600, 2500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x477, CanFrameTimeoutFunc_0x477, NULL},
	{0x488, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x488, CanFrameTimeoutFunc_0x488, NULL},
	{0x489, 200, 1500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x489, CanFrameTimeoutFunc_0x489, NULL},
	{0x48F, 1000, 2500, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x48F, CanFrameTimeoutFunc_0x48F, NULL},
	{0x4CB, 0, 0, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x4CB, CanFrameTimeoutFunc_0x4CB, NULL},
	{0x4E4, 0, 0, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x4E4, CanFrameTimeoutFunc_0x4E4, NULL},
	{0x4E5, 0, 0, 0 ,0, 0, 1, CanFrameAnlysisFunc_0x4E5, CanFrameTimeoutFunc_0x4E5, NULL},
    
	
};




void InitCanRecvModule(void)
{
	for (uint8_t i = 0; i < (sizeof (CanInit) / sizeof (CanInit[0])); i++) {
		InitCanFrame(i, (INIT_CAN_FRAME*)&CanInit[i]);
	}
}


/*-----------------------------CanFD-------------------------*/

void CanFrameAnlysisFunc_0x040(uint8_t *data)
{
    //TCU_01_10ms_ p = {0};
    //memcpy((void*)&p.Data[0], data, sizeof(TCU_01_10ms_));
 //   
	//CanDataStruct.TCU_Crc1Val = (uint16_t)p.TCU_Crc1Val;
	//CanDataStruct.TCU_AlvCnt1Val = (uint8_t)p.TCU_AlvCnt1Val;
	//CanDataStruct.TCU_GearSlctDis = (uint8_t)p.TCU_GearSlctDis;
	//CanDataStruct.TCU_Typ = (uint8_t)p.TCU_Typ;
	//CanDataStruct.TCU_TqRdctnVal = (uint16_t)p.TCU_TqRdctnVal;
	//CanDataStruct.TCU_GearSlctDis_FS = (uint8_t)p.TCU_GearSlctDis_FS;
	//CanDataStruct.TCU_GearStepTyp = (uint8_t)p.TCU_GearStepTyp;
	//CanDataStruct.TCU_GearShftSta = (uint8_t)p.TCU_GearShftSta;
	//CanDataStruct.TCU_TqCnvrtrSta = (uint8_t)p.TCU_TqCnvrtrSta;
	//CanDataStruct.TCU_CurrGearSta = (uint8_t)p.TCU_CurrGearSta;
	//CanDataStruct.TCU_TrgtGearSta = (uint8_t)p.TCU_TrgtGearSta;
	//CanDataStruct.TCU_CluTrgtGearSta = (uint8_t)p.TCU_CluTrgtGearSta;
	//CanDataStruct.TCH_EngTrgtGearSta = (uint8_t)p.TCH_EngTrgtGearSta;
	//CanDataStruct.TCU_EngTqLimVal = (uint16_t)p.TCU_EngTqLimVal;
	//CanDataStruct.TCU_CluTrgtGearConfg = (uint8_t)p.TCU_CluTrgtGearConfg;
	//CanDataStruct.TCU_VehSpdKphVal = (uint8_t)p.TCU_VehSpdKphVal;
	//CanDataStruct.TCU_DcmlVehSpdKphVal = (uint8_t)p.TCU_DcmlVehSpdKphVal;
	//CanDataStruct.TCU_SprkRtrdReq = (uint8_t)p.TCU_SprkRtrdReq;
	//CanDataStruct.TCU_EngRpmDisSta = (uint8_t)p.TCU_EngRpmDisSta;
	//CanDataStruct.TCU_GearLmpBlnkngReq = (uint8_t)p.TCU_GearLmpBlnkngReq;
	//CanDataStruct.TCU_FuelCutInhbtReq = (uint8_t)p.TCU_FuelCutInhbtReq;
	//CanDataStruct.TCU_IdleUpReq = (uint8_t)p.TCU_IdleUpReq;
	//CanDataStruct.TCU_EngRpmDis = (uint16_t)p.TCU_EngRpmDis;
	//CanDataStruct.TCU_SlpVal = (uint8_t)p.TCU_SlpVal;
	//CanDataStruct.TCU_EngSpdIncReq = (uint8_t)p.TCU_EngSpdIncReq;
	//CanDataStruct.TCU_ObdSta = (uint8_t)p.TCU_ObdSta;
	//CanDataStruct.TCU_SprtyIndxSta = (uint8_t)p.TCU_SprtyIndxSta;
	//CanDataStruct.TCU_DrvngModDis = (uint8_t)p.TCU_DrvngModDis;
	//CanDataStruct.TCU_DrvngModReq = (uint8_t)p.TCU_DrvngModReq;
	//CanDataStruct.TCU_SmrtShftSta = (uint8_t)p.TCU_SmrtShftSta;
	//CanDataStruct.TCU_LupTrgtEngSpdVal = (uint8_t)p.TCU_LupTrgtEngSpdVal;
	//CanDataStruct.TCU_FrtStcShftSta = (uint8_t)p.TCU_FrtStcShftSta;
	//CanDataStruct.TCU_IsgInhbtReq = (uint8_t)p.TCU_IsgInhbtReq;
	//CanDataStruct.TCU_CdaInhbtReq = (uint8_t)p.TCU_CdaInhbtReq;
	//CanDataStruct.TCU_BrkOnReq = (uint8_t)p.TCU_BrkOnReq;
	//CanDataStruct.TCU_TqGrdntLimVal = (uint8_t)p.TCU_TqGrdntLimVal;
	//CanDataStruct.TCU_NetrlCtrlSta = (uint8_t)p.TCU_NetrlCtrlSta;
	//CanDataStruct.TCU_ShftPtrnSta = (uint8_t)p.TCU_ShftPtrnSta;
	//CanDataStruct.TCU_VgisInhbtReq = (uint8_t)p.TCU_VgisInhbtReq;
	//CanDataStruct.TCU_EngTqIncReqVal = (uint16_t)p.TCU_EngTqIncReqVal;
	//CanDataStruct.TCU_EPBReq = (uint8_t)p.TCU_EPBReq;
	//CanDataStruct.IMT_EOLstate = (uint8_t)p.IMT_EOLstate;
	//CanDataStruct.IMT_DisCmd = (uint8_t)p.IMT_DisCmd;
	//CanDataStruct.DCT_RegenInhbt = (uint8_t)p.DCT_RegenInhbt;
	//CanDataStruct.DCT_EngIdleReq = (uint8_t)p.DCT_EngIdleReq;
	//CanDataStruct.DCT_CltchState = (uint8_t)p.DCT_CltchState;
	//CanDataStruct.DCT_FuelCutReq = (uint8_t)p.DCT_FuelCutReq;
	//CanDataStruct.DCT_TqIncReq = (uint8_t)p.DCT_TqIncReq;
	//CanDataStruct.DCT_CrpTqReq = (uint16_t)p.DCT_CrpTqReq;
	//CanDataStruct.DCT_ShftTqReq = (uint16_t)p.DCT_ShftTqReq;
    
    
}
void CanFrameAnlysisFunc_0x070(uint8_t data[])
{
	//HTCU_05_10ms_ p = {0};
	//memcpy((void*)&p.Data[0], data, sizeof(HTCU_05_10ms_));

	//CanDataStruct.HTCU_Crc5Val = (uint16_t)p.HTCU_Crc5Val;
	//CanDataStruct.HTCU_AlvCnt5Val = (uint8_t)p.HTCU_AlvCnt5Val;
	//CanDataStruct.HDCT_AddtnlTqLssVal = (uint8_t)p.HDCT_AddtnlTqLssVal;
	//CanDataStruct.HDCT_OBDSta = (uint8_t)p.HDCT_OBDSta;
	//CanDataStruct.HDCT_OBDErrSta = (uint8_t)p.HDCT_OBDErrSta;
	//CanDataStruct.HDCT_StcShftLrchCtrl = (uint8_t)p.HDCT_StcShftLrchCtrl;
	//CanDataStruct.HDCT_EngCltchLmphmMod = (uint8_t)p.HDCT_EngCltchLmphmMod;
	//CanDataStruct.HDCT_CurrPrgrm = (uint8_t)p.HDCT_CurrPrgrm;
	//CanDataStruct.HDCT_MCUAntJrkInhbt = (uint8_t)p.HDCT_MCUAntJrkInhbt;
	//CanDataStruct.HDCT_TrgtGear = (uint8_t)p.HDCT_TrgtGear;
	//CanDataStruct.HDCT_CurrGear = (uint8_t)p.HDCT_CurrGear;
	//CanDataStruct.HDCT_GearSelDis = (uint8_t)p.HDCT_GearSelDis;
	//CanDataStruct.HDCT_TCURdySta = (uint8_t)p.HDCT_TCURdySta;
	//CanDataStruct.HDCT_CtrlablSta = (uint8_t)p.HDCT_CtrlablSta;
	//CanDataStruct.HDCT_TrgtShftCls = (uint8_t)p.HDCT_TrgtShftCls;
	//CanDataStruct.HDCT_ShftPhase = (uint8_t)p.HDCT_ShftPhase;
	//CanDataStruct.HDCT_NetrlCtrlSta = (uint8_t)p.HDCT_NetrlCtrlSta;
	//CanDataStruct.HDCT_GearShftSta = (uint8_t)p.HDCT_GearShftSta;
	//CanDataStruct.HDCT_TqRdctnVal = (uint16_t)p.HDCT_TqRdctnVal;
	//CanDataStruct.HTCU_SlwTqRdctnVal = (uint16_t)p.HTCU_SlwTqRdctnVal;
	//CanDataStruct.HDCT_TqIncReq = (uint8_t)p.HDCT_TqIncReq;
	//CanDataStruct.HDCT_TqIncVal = (uint16_t)p.HDCT_TqIncVal;
	//CanDataStruct.HDCT_EOLReq = (uint8_t)p.HDCT_EOLReq;
	//CanDataStruct.HDCT_CltchSta = (uint8_t)p.HDCT_CltchSta;
	//CanDataStruct.HDCT_DblCltchSta = (uint8_t)p.HDCT_DblCltchSta;
	//CanDataStruct.HDCT_AcnChrgInhbtReq = (uint8_t)p.HDCT_AcnChrgInhbtReq;
	//CanDataStruct.HDCT_SlipCrnkAllw = (uint8_t)p.HDCT_SlipCrnkAllw;
	//CanDataStruct.HDCT_KckDnSkpShftCnt = (uint8_t)p.HDCT_KckDnSkpShftCnt;
	//CanDataStruct.HDCT_FuelCutReq = (uint8_t)p.HDCT_FuelCutReq;
	//CanDataStruct.HDCT_NCoastTrgtGear = (uint8_t)p.HDCT_NCoastTrgtGear;
	//CanDataStruct.HDCT_NCoastDnReq = (uint8_t)p.HDCT_NCoastDnReq;
	//CanDataStruct.HDCT_CLUEngSpd = (uint16_t)p.HDCT_CLUEngSpd;
	//CanDataStruct.HDCT_CLUEngSpdFlag = (uint8_t)p.HDCT_CLUEngSpdFlag;
	//CanDataStruct.HDCT_CLUTrgtGear = (uint8_t)p.HDCT_CLUTrgtGear;
	//CanDataStruct.HDCT_GSITrgtGear = (uint8_t)p.HDCT_GSITrgtGear;


}

void CanFrameTimeoutFunc_0x040(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x060(uint8_t *data)
{
 //   ESC_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ESC_01_10ms_));
 //   
	//CanDataStruct.ESC_Crc1Val = (uint16_t)p.ESC_Crc1Val;
	//CanDataStruct.ESC_AlvCnt1Val = (uint8_t)p.ESC_AlvCnt1Val;
	//CanDataStruct.TCS_LmpSta = (uint8_t)p.TCS_LmpSta;
	//CanDataStruct.TCS_OffLmpSta = (uint8_t)p.TCS_OffLmpSta;
	//CanDataStruct.ESC_OffTempSta = (uint8_t)p.ESC_OffTempSta;
	//CanDataStruct.DBC_WrngLmpSta = (uint8_t)p.DBC_WrngLmpSta;
	//CanDataStruct.DBC_FuncLmpSta = (uint8_t)p.DBC_FuncLmpSta;
	//CanDataStruct.DBC_ClusterDis = (uint8_t)p.DBC_ClusterDis;
	//CanDataStruct.ESC_BrkCtrlSta = (uint8_t)p.ESC_BrkCtrlSta;
	//CanDataStruct.TCS_Sta = (uint8_t)p.TCS_Sta;
	//CanDataStruct.ESC_Sta = (uint8_t)p.ESC_Sta;
	//CanDataStruct.TCS_PreActvSta = (uint8_t)p.TCS_PreActvSta;
	//CanDataStruct.DBC_Sta = (uint8_t)p.DBC_Sta;
	//CanDataStruct.TCS_TqFlag = (uint8_t)p.TCS_TqFlag;
	//CanDataStruct.MSR_TqFlag = (uint8_t)p.MSR_TqFlag;
	//CanDataStruct.HAC_Sta = (uint8_t)p.HAC_Sta;
	//CanDataStruct.TCS_SlwTqFlag = (uint8_t)p.TCS_SlwTqFlag;
	//CanDataStruct.TCS_Req = (uint8_t)p.TCS_Req;
	//CanDataStruct.MSR_FuncReq = (uint8_t)p.MSR_FuncReq;
	//CanDataStruct.TCS_GearShftCharacteristicVal = (uint8_t)p.TCS_GearShftCharacteristicVal;
	//CanDataStruct.TCS_ManufacturerVal = (uint8_t)p.TCS_ManufacturerVal;
	//CanDataStruct.TCS_TqIntrvntnVal = (uint8_t)p.TCS_TqIntrvntnVal;
	//CanDataStruct.MSR_TqIntrvntnVal = (uint8_t)p.MSR_TqIntrvntnVal;
	//CanDataStruct.TCS_SlwTqIntrvntnVal = (uint8_t)p.TCS_SlwTqIntrvntnVal;
	//CanDataStruct.ESC_CylPrsrVal = (uint16_t)p.ESC_CylPrsrVal;
	//CanDataStruct.ESC_CylPrsrSta = (uint8_t)p.ESC_CylPrsrSta;
	//CanDataStruct.ESC_CylPrsrDiagSta = (uint8_t)p.ESC_CylPrsrDiagSta;
	//CanDataStruct.ESC_CylPrsrFlagSta = (uint8_t)p.ESC_CylPrsrFlagSta;
	//CanDataStruct.ESC_VsmActvSta = (uint8_t)p.ESC_VsmActvSta;
	//CanDataStruct.ESC_VsmDfctvSta = (uint8_t)p.ESC_VsmDfctvSta;
	//CanDataStruct.ESC_VsmCtrlModSta = (uint8_t)p.ESC_VsmCtrlModSta;
	//CanDataStruct.ESC_StrTqReq = (uint16_t)p.ESC_StrTqReq;
	//CanDataStruct.ESC_LongAccelOffstCalibPrmtr = (uint16_t)p.ESC_LongAccelOffstCalibPrmtr;
	//CanDataStruct.ESC_IMURstStaAck = (uint8_t)p.ESC_IMURstStaAck;
	//CanDataStruct.AVH_Sta = (uint8_t)p.AVH_Sta;
	//CanDataStruct.LDM_Sta = (uint8_t)p.LDM_Sta;
	//CanDataStruct.EPB_ActvReq = (uint8_t)p.EPB_ActvReq;
	//CanDataStruct.EPB_StaReq = (uint8_t)p.EPB_StaReq;
	//CanDataStruct.ECD_ActvSta = (uint8_t)p.ECD_ActvSta;
	//CanDataStruct.AVH_CluDis = (uint8_t)p.AVH_CluDis;
	//CanDataStruct.AVH_AlrmReq = (uint8_t)p.AVH_AlrmReq;
	//CanDataStruct.AVH_ActvStaLmpDis = (uint8_t)p.AVH_ActvStaLmpDis;
	//CanDataStruct.AVH_LmpDis = (uint8_t)p.AVH_LmpDis;
	//CanDataStruct.AWD_CrdnShftTqLimVal = (uint16_t)p.AWD_CrdnShftTqLimVal;
	//CanDataStruct.AWD_CltchDtyLimVal = (uint8_t)p.AWD_CltchDtyLimVal;
	//CanDataStruct.AWD_TransmsnTqLimModSta = (uint8_t)p.AWD_TransmsnTqLimModSta;
	//CanDataStruct.AWD_RrWhlDtyLimReq = (uint8_t)p.AWD_RrWhlDtyLimReq;
	//CanDataStruct.AWD_FastOpnCrdnShftCltchReq = (uint8_t)p.AWD_FastOpnCrdnShftCltchReq;
}

void CanFrameTimeoutFunc_0x060(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x06A(uint8_t *data)
{
 //   TCU_02_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(TCU_02_10ms_));
 //   
	//CanDataStruct.TCU_Crc2Val = (uint16_t)p.TCU_Crc2Val;
	//CanDataStruct.TCU_AlvCnt2Val = (uint8_t)p.TCU_AlvCnt2Val;
	//CanDataStruct.TCU_RawTqCnvrtrSpdVal = (uint16_t)p.TCU_RawTqCnvrtrSpdVal;
	//CanDataStruct.TCU_AtTempCVal = (uint8_t)p.TCU_AtTempCVal;
	//CanDataStruct.TCU_TqCnvrtrSpdVal = (uint16_t)p.TCU_TqCnvrtrSpdVal;
	//CanDataStruct.TCU_PrkReleaseReq = (uint8_t)p.TCU_PrkReleaseReq;
	//CanDataStruct.TCU_InertiaPhaseSta = (uint8_t)p.TCU_InertiaPhaseSta;
	//CanDataStruct.TCU_ActvEcoRdySta = (uint8_t)p.TCU_ActvEcoRdySta;
	//CanDataStruct.TCU_SprtDrvRdySta = (uint8_t)p.TCU_SprtDrvRdySta;
	//CanDataStruct.TCU_StrtReleaseSta = (uint8_t)p.TCU_StrtReleaseSta;
	//CanDataStruct.TCU_CltchDrvngTqVal = (uint16_t)p.TCU_CltchDrvngTqVal;
	//CanDataStruct.TCU_SbwPrkSta = (uint8_t)p.TCU_SbwPrkSta;
	//CanDataStruct.TCU_StallLaunchStat = (uint8_t)p.TCU_StallLaunchStat;
	//CanDataStruct.TCU_OilPmpTrgtSpdVal = (uint8_t)p.TCU_OilPmpTrgtSpdVal;
	//CanDataStruct.TCU_GrRatioChngProg = (uint8_t)p.TCU_GrRatioChngProg;
	//CanDataStruct.TCU_TgtTurSpd = (uint16_t)p.TCU_TgtTurSpd;
	//CanDataStruct.TCU_FastTipOutFlag = (uint8_t)p.TCU_FastTipOutFlag;
	//CanDataStruct.TCU_NCExitBrk = (uint8_t)p.TCU_NCExitBrk;
	//CanDataStruct.TCU_RevMatchFlag = (uint8_t)p.TCU_RevMatchFlag;
	//CanDataStruct.TCU_NCCStat = (uint8_t)p.TCU_NCCStat;
	//CanDataStruct.TCU_CVTPumpLoad = (uint8_t)p.TCU_CVTPumpLoad;
	//CanDataStruct.TCU_EngSpdIncRev = (uint16_t)p.TCU_EngSpdIncRev;
	//CanDataStruct.TCU_ShiftTarCls = (uint8_t)p.TCU_ShiftTarCls;
}

void CanFrameTimeoutFunc_0x06A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x06F(uint8_t *data)
{
 //   ABS_ESC_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ABS_ESC_01_10ms_));
 //   
	//CanDataStruct.ABS_ESC_Crc1Val = (uint16_t)p.ABS_ESC_Crc1Val;
	//CanDataStruct.ABS_ESC_AlvCnt1Val = (uint8_t)p.ABS_ESC_AlvCnt1Val;
	//CanDataStruct.ABS_WrngLmpSta = (uint8_t)p.ABS_WrngLmpSta;
	//CanDataStruct.ABS_DfctvSta = (uint8_t)p.ABS_DfctvSta;
	//CanDataStruct.ABS_ActvSta = (uint8_t)p.ABS_ActvSta;
	//CanDataStruct.ABS_DiagSta = (uint8_t)p.ABS_DiagSta;
	//CanDataStruct.EBD_WrngLmpSta = (uint8_t)p.EBD_WrngLmpSta;
	//CanDataStruct.EBD_DfctvSta = (uint8_t)p.EBD_DfctvSta;
	//CanDataStruct.ESC_BrkLtActSta = (uint8_t)p.ESC_BrkLtActSta;
	//CanDataStruct.ESS_Sta = (uint8_t)p.ESS_Sta;
}

void CanFrameTimeoutFunc_0x06F(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x0A0(uint8_t *data)
{
 //   WHL_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(WHL_01_10ms_));
 //   
	//CanDataStruct.WHL_Crc1Val = (uint16_t)p.WHL_Crc1Val;
	//CanDataStruct.WHL_AlvCnt1Val = (uint8_t)p.WHL_AlvCnt1Val;
	//CanDataStruct.WHL_PlsFLVal = (uint8_t)p.WHL_PlsFLVal;
	//CanDataStruct.WHL_PlsFRVal = (uint8_t)p.WHL_PlsFRVal;
	//CanDataStruct.WHL_PlsRLVal = (uint8_t)p.WHL_PlsRLVal;
	//CanDataStruct.WHL_PlsRRVal = (uint8_t)p.WHL_PlsRRVal;
	//CanDataStruct.WHL_DirFLVal = (uint8_t)p.WHL_DirFLVal;
	//CanDataStruct.WHL_DirFRVal = (uint8_t)p.WHL_DirFRVal;
	//CanDataStruct.WHL_DirRLVal = (uint8_t)p.WHL_DirRLVal;
	//CanDataStruct.WHL_DirRRVal = (uint8_t)p.WHL_DirRRVal;
	//CanDataStruct.WHL_SpdFLVal = (uint16_t)p.WHL_SpdFLVal;
	//CanDataStruct.WHL_SpdFRVal = (uint16_t)p.WHL_SpdFRVal;
	//CanDataStruct.WHL_SpdRLVal = (uint16_t)p.WHL_SpdRLVal;
	//CanDataStruct.WHL_SpdRRVal = (uint16_t)p.WHL_SpdRRVal;
}

void CanFrameTimeoutFunc_0x0A0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x0B5(uint8_t *data)
{
 //   EMS_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(EMS_01_10ms_));
 //   
	//CanDataStruct.EMS_Crc1Val = (uint16_t)p.EMS_Crc1Val;
	//CanDataStruct.EMS_AlvCnt1Val = (uint8_t)p.EMS_AlvCnt1Val;
	//CanDataStruct.ENG_CrctEngTqVal = (uint16_t)p.ENG_CrctEngTqVal;
	//CanDataStruct.ENG_StndTqRatioVal = (uint8_t)p.ENG_StndTqRatioVal;
	//CanDataStruct.ENG_FrctTqVal = (uint16_t)p.ENG_FrctTqVal;
	//CanDataStruct.ENG_IndTqVal = (uint16_t)p.ENG_IndTqVal;
	//CanDataStruct.ENG_IndTqBVal = (uint16_t)p.ENG_IndTqBVal;
	//CanDataStruct.ENG_EngSpdErrSta = (uint8_t)p.ENG_EngSpdErrSta;
	//CanDataStruct.ENG_MafErrSta = (uint8_t)p.ENG_MafErrSta;
	//CanDataStruct.ENG_EtcLmphModSta = (uint8_t)p.ENG_EtcLmphModSta;
	//CanDataStruct.ENG_SpltInjctnSta = (uint8_t)p.ENG_SpltInjctnSta;
	//CanDataStruct.ENG_MaxAirconTqVal = (uint8_t)p.ENG_MaxAirconTqVal;
	//CanDataStruct.ENG_AirconPrsrSnsrVal = (uint8_t)p.ENG_AirconPrsrSnsrVal;
	//CanDataStruct.ENG_IsgSta = (uint8_t)p.ENG_IsgSta;
	//CanDataStruct.ENG_OilLvlSta = (uint8_t)p.ENG_OilLvlSta;
	//CanDataStruct.ENG_TrgtIdleRpmVal = (uint8_t)p.ENG_TrgtIdleRpmVal;
	//CanDataStruct.ENG_GearShftUpDis = (uint8_t)p.ENG_GearShftUpDis;
	//CanDataStruct.ENG_GearShftDnDis = (uint8_t)p.ENG_GearShftDnDis;
	//CanDataStruct.ENG_DsrGearPosDis = (uint8_t)p.ENG_DsrGearPosDis;
	//CanDataStruct.ENG_SldFuncSta = (uint8_t)p.ENG_SldFuncSta;
	//CanDataStruct.ENG_SldActnSta = (uint8_t)p.ENG_SldActnSta;
	//CanDataStruct.ENG_FuelTnkPrsrSta = (uint8_t)p.ENG_FuelTnkPrsrSta;
	//CanDataStruct.ENG_IsgBzrReq = (uint8_t)p.ENG_IsgBzrReq;
	//CanDataStruct.ENG_IsgFuelCnsmptDis = (uint8_t)p.ENG_IsgFuelCnsmptDis;
	//CanDataStruct.ENG_FuelCapOpnSta = (uint8_t)p.ENG_FuelCapOpnSta;
	//CanDataStruct.ENG_EcoDrvActvSta = (uint8_t)p.ENG_EcoDrvActvSta;
	//CanDataStruct.ENG_EngRunSta = (uint8_t)p.ENG_EngRunSta;
	//CanDataStruct.ENG_Isg2Sta = (uint8_t)p.ENG_Isg2Sta;
	//CanDataStruct.ENG_IgnOnSta = (uint8_t)p.ENG_IgnOnSta;
	//CanDataStruct.ENG_Ack4TcsSta = (uint8_t)p.ENG_Ack4TcsSta;
	//CanDataStruct.ENG_FuelCutOffSta = (uint8_t)p.ENG_FuelCutOffSta;
	//CanDataStruct.ENG_CrctTqSta = (uint8_t)p.ENG_CrctTqSta;
	//CanDataStruct.ENG_AirCompRlySta = (uint8_t)p.ENG_AirCompRlySta;
	//CanDataStruct.ENG_LnchCntrlSta = (uint8_t)p.ENG_LnchCntrlSta;
	//CanDataStruct.ENG_EngSpdVal = (uint16_t)p.ENG_EngSpdVal;
	//CanDataStruct.ENG_FuelCnsmptVal = (uint16_t)p.ENG_FuelCnsmptVal;
	//CanDataStruct.ENG_TrgtFuelPmpPrsrVal = (uint8_t)p.ENG_TrgtFuelPmpPrsrVal;
	//CanDataStruct.ENG_VehSpdHiVal = (uint16_t)p.ENG_VehSpdHiVal;
	//CanDataStruct.ENG_EngInhbNCC = (uint8_t)p.ENG_EngInhbNCC;
	//CanDataStruct.ENG_VehSpdLimVal = (uint16_t)p.ENG_VehSpdLimVal;
}

void CanFrameTimeoutFunc_0x0B5(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x0EA(uint8_t *data)
{
 //   MDPS_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(MDPS_01_10ms_));
 //   
	//CanDataStruct.MDPS_Crc1Val = (uint16_t)p.MDPS_Crc1Val;
	//CanDataStruct.MDPS_AlvCnt1Val = (uint8_t)p.MDPS_AlvCnt1Val;
	//CanDataStruct.MDPS_WrngLmpSta = (uint8_t)p.MDPS_WrngLmpSta;
	//CanDataStruct.MDPS_Typ = (uint8_t)p.MDPS_Typ;
	//CanDataStruct.MDPS_EngIdleRpmReq = (uint8_t)p.MDPS_EngIdleRpmReq;
	//CanDataStruct.MDPS_VsmPlgInSta = (uint8_t)p.MDPS_VsmPlgInSta;
	//CanDataStruct.MDPS_VsmDfctvSta = (uint8_t)p.MDPS_VsmDfctvSta;
	//CanDataStruct.MDPS_VsmSigErrSta = (uint8_t)p.MDPS_VsmSigErrSta;
	//CanDataStruct.MDPS_PaPlugInSta = (uint8_t)p.MDPS_PaPlugInSta;
	//CanDataStruct.MDPS_PaModeSta = (uint8_t)p.MDPS_PaModeSta;
	//CanDataStruct.MDPS_PaCanfltSta = (uint8_t)p.MDPS_PaCanfltSta;
	//CanDataStruct.MDPS_LkaPlgInSta = (uint8_t)p.MDPS_LkaPlgInSta;
	//CanDataStruct.MDPS_LkaToiActvSta = (uint8_t)p.MDPS_LkaToiActvSta;
	//CanDataStruct.MDPS_LkaToiUnblSta = (uint8_t)p.MDPS_LkaToiUnblSta;
	//CanDataStruct.MDPS_LkaToiFltSta = (uint8_t)p.MDPS_LkaToiFltSta;
	//CanDataStruct.MDPS_LkaFailSta = (uint8_t)p.MDPS_LkaFailSta;
	//CanDataStruct.MDPS_FlxStrSta = (uint8_t)p.MDPS_FlxStrSta;
	//CanDataStruct.MDPS_FlxStrDis = (uint8_t)p.MDPS_FlxStrDis;
	//CanDataStruct.MDPS_CurrModVal = (uint8_t)p.MDPS_CurrModVal;
	//CanDataStruct.MDPS_OutTqVal = (uint16_t)p.MDPS_OutTqVal;
	//CanDataStruct.MDPS_StrTqSnsrVal = (uint16_t)p.MDPS_StrTqSnsrVal;
	//CanDataStruct.MDPS_PaStrAnglVal = (uint16_t)p.MDPS_PaStrAnglVal;
	//CanDataStruct.MDPS_LoamModSta = (uint8_t)p.MDPS_LoamModSta;
	//CanDataStruct.MDPS_EstStrAnglVal = (uint16_t)p.MDPS_EstStrAnglVal;
}

void CanFrameTimeoutFunc_0x0EA(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x100(uint8_t *data)
{
 //   EMS_02_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(EMS_02_10ms_));
 //   
	//CanDataStruct.EMS_Crc2Val = (uint16_t)p.EMS_Crc2Val;
	//CanDataStruct.EMS_AlvCnt2Val = (uint8_t)p.EMS_AlvCnt2Val;
	//CanDataStruct.ENG_BrkSwSta = (uint8_t)p.ENG_BrkSwSta;
	//CanDataStruct.ENG_ObdFrzFrmSta = (uint8_t)p.ENG_ObdFrzFrmSta;
	//CanDataStruct.ENG_EngClntTempVal = (uint8_t)p.ENG_EngClntTempVal;
	//CanDataStruct.ENG_MafCrctVal = (uint8_t)p.ENG_MafCrctVal;
	//CanDataStruct.ENG_BattDscnctSta = (uint8_t)p.ENG_BattDscnctSta;
	//CanDataStruct.OBD_MilConfgVal = (uint8_t)p.OBD_MilConfgVal;
	//CanDataStruct.ENG_EngSta = (uint8_t)p.ENG_EngSta;
	//CanDataStruct.ENG_Ack4EngStpSta = (uint8_t)p.ENG_Ack4EngStpSta;
	//CanDataStruct.ENG_OverDrvOffReq = (uint8_t)p.ENG_OverDrvOffReq;
	//CanDataStruct.ENG_AccActSta = (uint8_t)p.ENG_AccActSta;
	//CanDataStruct.ENG_CltchOpSta = (uint8_t)p.ENG_CltchOpSta;
	//CanDataStruct.DSL_GlowCtrlReq = (uint8_t)p.DSL_GlowCtrlReq;
	//CanDataStruct.ENG_GlowLmpSta = (uint8_t)p.ENG_GlowLmpSta;
	//CanDataStruct.ENG_ThrPosVal = (uint8_t)p.ENG_ThrPosVal;
	//CanDataStruct.ENG_AccelPdlVal = (uint16_t)p.ENG_AccelPdlVal;
	//CanDataStruct.ACC_CrsMainSwLmpSta = (uint8_t)p.ACC_CrsMainSwLmpSta;
	//CanDataStruct.ACC_CrsSetSwLmpSta = (uint8_t)p.ACC_CrsSetSwLmpSta;
	//CanDataStruct.ENG_LV_FUP_ENA_THD = (uint8_t)p.ENG_LV_FUP_ENA_THD;
	//CanDataStruct.ENG_SoakTimeErrSta = (uint8_t)p.ENG_SoakTimeErrSta;
	//CanDataStruct.ENG_SoakTimeVal = (uint8_t)p.ENG_SoakTimeVal;
	//CanDataStruct.ENG_SprkTimeVal = (uint8_t)p.ENG_SprkTimeVal;
	//CanDataStruct.ENG_MinIndTqVal = (uint16_t)p.ENG_MinIndTqVal;
	//CanDataStruct.ENG_TrgtTqVal = (uint16_t)p.ENG_TrgtTqVal;
	//CanDataStruct.ENG_MaxIndTqVal = (uint16_t)p.ENG_MaxIndTqVal;
	//CanDataStruct.ENG_AppAccelPdlSta = (uint8_t)p.ENG_AppAccelPdlSta;
	//CanDataStruct.ENG_BrkCtrlReq = (uint8_t)p.ENG_BrkCtrlReq;
	//CanDataStruct.ACC_DnShftCtrlReq = (uint8_t)p.ACC_DnShftCtrlReq;
	//CanDataStruct.ENG_DclBrkCntrlReq = (uint16_t)p.ENG_DclBrkCntrlReq;
	//CanDataStruct.ENG_BstPrsrVal = (uint16_t)p.ENG_BstPrsrVal;
	//CanDataStruct.ENG_EngOilTempVal = (uint8_t)p.ENG_EngOilTempVal;
	//CanDataStruct.ENG_AmbtTempModelVal = (uint8_t)p.ENG_AmbtTempModelVal;
	//CanDataStruct.ENG_DpfWrngSta = (uint8_t)p.ENG_DpfWrngSta;
	//CanDataStruct.ENG_BattWrngLmpSta = (uint8_t)p.ENG_BattWrngLmpSta;
	//CanDataStruct.ENG_OilPrsrWrngLmpSta = (uint8_t)p.ENG_OilPrsrWrngLmpSta;
	//CanDataStruct.ENG_IsgInhbtLmpSta = (uint8_t)p.ENG_IsgInhbtLmpSta;
}

void CanFrameTimeoutFunc_0x100(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x11A(uint8_t *data)
{
 //   FR_CMR_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(FR_CMR_01_10ms_));
 //   
	//CanDataStruct.FR_CMR_Crc1Val = (uint16_t)p.FR_CMR_Crc1Val;
	//CanDataStruct.FR_CMR_AlvCnt1Val = (uint8_t)p.FR_CMR_AlvCnt1Val;
	//CanDataStruct.HBA_SysOptSta = (uint8_t)p.HBA_SysOptSta;
	//CanDataStruct.HBA_SysSta = (uint8_t)p.HBA_SysSta;
	//CanDataStruct.HBA_IndLmpReq = (uint8_t)p.HBA_IndLmpReq;
	//CanDataStruct.FR_CMR_FCA_Plus_Sta = (uint8_t)p.FR_CMR_FCA_Plus_Sta;
	//CanDataStruct.FCA_Equip_MFC = (uint8_t)p.FCA_Equip_MFC;
	//CanDataStruct.HBA_OptUsmSta = (uint8_t)p.HBA_OptUsmSta;
	//CanDataStruct.DAW_LVDA_PUDis = (uint8_t)p.DAW_LVDA_PUDis;
	//CanDataStruct.DAW_LVDA_OptUsmSta = (uint8_t)p.DAW_LVDA_OptUsmSta;
	//CanDataStruct.DAW_OptUsmSta = (uint8_t)p.DAW_OptUsmSta;
	//CanDataStruct.DAW_SysSta = (uint8_t)p.DAW_SysSta;
	//CanDataStruct.DAW_WrnMsgSta = (uint8_t)p.DAW_WrnMsgSta;
	//CanDataStruct.DAW_TimeRstReq = (uint8_t)p.DAW_TimeRstReq;
	//CanDataStruct.DAW_SnstvtyModRetVal = (uint8_t)p.DAW_SnstvtyModRetVal;
	//CanDataStruct.FR_CMR_FCAEquipSta = (uint8_t)p.FR_CMR_FCAEquipSta;
	//CanDataStruct.FR_CMR_MDPSCtrlSta = (uint8_t)p.FR_CMR_MDPSCtrlSta;
	//CanDataStruct.FR_CMR_FailInfoSta = (uint8_t)p.FR_CMR_FailInfoSta;
	//CanDataStruct.FR_CMR_CodingSta = (uint8_t)p.FR_CMR_CodingSta;
	//CanDataStruct.FR_CMR_ACANMonSta = (uint8_t)p.FR_CMR_ACANMonSta;
	//CanDataStruct.PRVECS_CodedSta = (uint8_t)p.PRVECS_CodedSta;
	//CanDataStruct.FR_CMR_SCCEquipSta = (uint8_t)p.FR_CMR_SCCEquipSta;
	//CanDataStruct.FR_CMR_ReqADASMapMsgVal = (uint16_t)p.FR_CMR_ReqADASMapMsgVal;
	//CanDataStruct.FR_CMR_SwVer1Val = (uint8_t)p.FR_CMR_SwVer1Val;
	//CanDataStruct.FR_CMR_SwVer2Val = (uint8_t)p.FR_CMR_SwVer2Val;
}

void CanFrameTimeoutFunc_0x11A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x125(uint8_t *data)
{
 //   SAS_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SAS_01_10ms_));
 //   
	//CanDataStruct.SAS_Crc1Val = (uint16_t)p.SAS_Crc1Val;
	//CanDataStruct.SAS_AlvCnt1Val = (uint8_t)p.SAS_AlvCnt1Val;
	//CanDataStruct.SAS_AnglVal = (uint16_t)p.SAS_AnglVal;
	//CanDataStruct.SAS_SpdVal = (uint8_t)p.SAS_SpdVal;
	//CanDataStruct.SAS_IntSta = (uint8_t)p.SAS_IntSta;
}

void CanFrameTimeoutFunc_0x125(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x12A(uint8_t *data)
{
 //   ADAS_CMD_30_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_CMD_30_10ms_));
 //   
	//CanDataStruct.ADAS_CMD_Crc30Val = (uint16_t)p.ADAS_CMD_Crc30Val;
	//CanDataStruct.ADAS_CMD_AlvCnt30Val = (uint8_t)p.ADAS_CMD_AlvCnt30Val;
	//CanDataStruct.LKA_OptUsmSta = (uint8_t)p.LKA_OptUsmSta;
	//CanDataStruct.LKA_RcgSta = (uint8_t)p.LKA_RcgSta;
	//CanDataStruct.LKA_LHLnWrnSta = (uint8_t)p.LKA_LHLnWrnSta;
	//CanDataStruct.LKA_RHLnWrnSta = (uint8_t)p.LKA_RHLnWrnSta;
	//CanDataStruct.LKA_HndsoffSnd = (uint8_t)p.LKA_HndsoffSnd;
	//CanDataStruct.LKA_StrSnd = (uint8_t)p.LKA_StrSnd;
	//CanDataStruct.LKA_SysIndReq = (uint8_t)p.LKA_SysIndReq;
	//CanDataStruct.ADAS_StrTqReqVal = (uint16_t)p.ADAS_StrTqReqVal;
	//CanDataStruct.ADAS_ActToiSta = (uint8_t)p.ADAS_ActToiSta;
	//CanDataStruct.ADAS_ToiFltSta = (uint8_t)p.ADAS_ToiFltSta;
	//CanDataStruct.LKA_SysWrn = (uint8_t)p.LKA_SysWrn;
	//CanDataStruct.LKA_UsmMod = (uint8_t)p.LKA_UsmMod;
	//CanDataStruct.ADAS_Damping_Gain = (uint8_t)p.ADAS_Damping_Gain;
}
void CanFrameAnlysisFunc_0x230(uint8_t data[])
{
	//HCU_05_100ms_ p = {0};
	//memcpy((void*)&p.Data[0], data, sizeof(HCU_05_100ms_));

	//CanDataStruct.HCU_Crc5Val = (uint16_t)p.HCU_Crc5Val;
	//CanDataStruct.HCU_AlvCnt5Val = (uint8_t)p.HCU_AlvCnt5Val;
	//CanDataStruct.HCU_AafCtrlReq = (uint8_t)p.HCU_AafCtrlReq;
	//CanDataStruct.HCU_SmartRegen_UsmSta = (uint8_t)p.HCU_SmartRegen_UsmSta;
	//CanDataStruct.HCU_SmartRegen_OnSta = (uint8_t)p.HCU_SmartRegen_OnSta;
	//CanDataStruct.HCU_SmartRegen_RdrCstActSta = (uint8_t)p.HCU_SmartRegen_RdrCstActSta;
	//CanDataStruct.HCU_SmartRegen_WarnMsgSta = (uint8_t)p.HCU_SmartRegen_WarnMsgSta;
	//CanDataStruct.HCU_AcnOpPrmssnSta = (uint8_t)p.HCU_AcnOpPrmssnSta;
	//CanDataStruct.HCU_AcPwrIncSta = (uint8_t)p.HCU_AcPwrIncSta;
	//CanDataStruct.HCU_SmartRegen_VehHoldSta = (uint8_t)p.HCU_SmartRegen_VehHoldSta;
	//CanDataStruct.HCU_BlueDrvModSta = (uint8_t)p.HCU_BlueDrvModSta;
	//CanDataStruct.HCU_BlwOffReq = (uint8_t)p.HCU_BlwOffReq;
	//CanDataStruct.HCU_CcCameraOperSta = (uint8_t)p.HCU_CcCameraOperSta;
	//CanDataStruct.HCU_CcCameraSta = (uint8_t)p.HCU_CcCameraSta;
	//CanDataStruct.HCU_ChrgIncModSta = (uint8_t)p.HCU_ChrgIncModSta;
	//CanDataStruct.HCU_CrsCtrlOnLmpDis = (uint8_t)p.HCU_CrsCtrlOnLmpDis;
	//CanDataStruct.HCU_CrsCtrlSetLmpDis = (uint8_t)p.HCU_CrsCtrlSetLmpDis;
	//CanDataStruct.HCU_DptEnaSet1FriSta = (uint8_t)p.HCU_DptEnaSet1FriSta;
	//CanDataStruct.HCU_DptEnaSet1MonSta = (uint8_t)p.HCU_DptEnaSet1MonSta;
	//CanDataStruct.HCU_DptEnaSet1SatSta = (uint8_t)p.HCU_DptEnaSet1SatSta;
	//CanDataStruct.HCU_DptEnaSet1Sta = (uint8_t)p.HCU_DptEnaSet1Sta;
	//CanDataStruct.HCU_DptEnaSet1SunSta = (uint8_t)p.HCU_DptEnaSet1SunSta;
	//CanDataStruct.HCU_DptEnaSet1ThuSta = (uint8_t)p.HCU_DptEnaSet1ThuSta;
	//CanDataStruct.HCU_DptEnaSet1TueSta = (uint8_t)p.HCU_DptEnaSet1TueSta;
	//CanDataStruct.HCU_DptEnaSet1WedSta = (uint8_t)p.HCU_DptEnaSet1WedSta;
	//CanDataStruct.HCU_DptEnaSet2FriSta = (uint8_t)p.HCU_DptEnaSet2FriSta;
	//CanDataStruct.HCU_DptEnaSet2MonSta = (uint8_t)p.HCU_DptEnaSet2MonSta;
	//CanDataStruct.HCU_DptEnaSet2SatSta = (uint8_t)p.HCU_DptEnaSet2SatSta;
	//CanDataStruct.HCU_DptEnaSet2Sta = (uint8_t)p.HCU_DptEnaSet2Sta;
	//CanDataStruct.HCU_DptEnaSet2SunSta = (uint8_t)p.HCU_DptEnaSet2SunSta;
	//CanDataStruct.HCU_DptEnaSet2ThuSta = (uint8_t)p.HCU_DptEnaSet2ThuSta;
	//CanDataStruct.HCU_DptEnaSet2TueSta = (uint8_t)p.HCU_DptEnaSet2TueSta;
	//CanDataStruct.HCU_DptEnaSet2WedSta = (uint8_t)p.HCU_DptEnaSet2WedSta;
	//CanDataStruct.HCU_DptHrSet1Val = (uint8_t)p.HCU_DptHrSet1Val;
	//CanDataStruct.HCU_DptHrSet2Val = (uint8_t)p.HCU_DptHrSet2Val;
	//CanDataStruct.HCU_DptMinSet1Val = (uint8_t)p.HCU_DptMinSet1Val;
	//CanDataStruct.HCU_DptMinSet2Val = (uint8_t)p.HCU_DptMinSet2Val;
	//CanDataStruct.HCU_DrvModSta = (uint8_t)p.HCU_DrvModSta;
	//CanDataStruct.HCU_EcoChrgEndHrVal = (uint8_t)p.HCU_EcoChrgEndHrVal;
	//CanDataStruct.HCU_EcoChrgEndHrWeekendVal = (uint8_t)p.HCU_EcoChrgEndHrWeekendVal;
	//CanDataStruct.HCU_EcoChrgEndMinVal = (uint8_t)p.HCU_EcoChrgEndMinVal;
	//CanDataStruct.HCU_EcoChrgEndMinWeekendVal = (uint8_t)p.HCU_EcoChrgEndMinWeekendVal;
	//CanDataStruct.HCU_SmartRegen_MapCstActSta = (uint8_t)p.HCU_SmartRegen_MapCstActSta;
	//CanDataStruct.HCU_EcoChrgStrtHrVal = (uint8_t)p.HCU_EcoChrgStrtHrVal;
	//CanDataStruct.HCU_EcoChrgStrtHrWeekendVal = (uint8_t)p.HCU_EcoChrgStrtHrWeekendVal;
	//CanDataStruct.HCU_EcoChrgStrtMinVal = (uint8_t)p.HCU_EcoChrgStrtMinVal;
	//CanDataStruct.HCU_EcoChrgStrtMinWeekendVal = (uint8_t)p.HCU_EcoChrgStrtMinWeekendVal;
	//CanDataStruct.HCU_EcoLvlVal = (uint8_t)p.HCU_EcoLvlVal;
	//CanDataStruct.HCU_EcoScoVal = (uint8_t)p.HCU_EcoScoVal;
	//CanDataStruct.HCU_EmissionTestModSta = (uint8_t)p.HCU_EmissionTestModSta;
	//CanDataStruct.HCU_EnhancedEVModEnblSta = (uint8_t)p.HCU_EnhancedEVModEnblSta;
	//CanDataStruct.HCU_FuelEcoVal = (uint8_t)p.HCU_FuelEcoVal;
	//CanDataStruct.HCU_HevSysModSta = (uint8_t)p.HCU_HevSysModSta;
	//CanDataStruct.HCU_LdcCtrlModSta = (uint8_t)p.HCU_LdcCtrlModSta;
	//CanDataStruct.HCU_LdcInhbtReq = (uint8_t)p.HCU_LdcInhbtReq;
	//CanDataStruct.HCU_LdcUnderVoltCtrlSta = (uint8_t)p.HCU_LdcUnderVoltCtrlSta;
	//CanDataStruct.HCU_NccAlrmInfoSta = (uint8_t)p.HCU_NccAlrmInfoSta;
	//CanDataStruct.HCU_PaddleCoastCtrlSta = (uint8_t)p.HCU_PaddleCoastCtrlSta;
	//CanDataStruct.HCU_PaddleStepCtrlSta = (uint8_t)p.HCU_PaddleStepCtrlSta;
	//CanDataStruct.HCU_PhevDrvModClusterSta = (uint8_t)p.HCU_PhevDrvModClusterSta;
	//CanDataStruct.HCU_PIFailFreezeReq = (uint8_t)p.HCU_PIFailFreezeReq;
	//CanDataStruct.HCU_PreFATCHysTempVal = (uint8_t)p.HCU_PreFATCHysTempVal;
	//CanDataStruct.HCU_PreFATCOffstTempVal = (uint8_t)p.HCU_PreFATCOffstTempVal;
	//CanDataStruct.HCU_SchedChgEndDayVal = (uint8_t)p.HCU_SchedChgEndDayVal;
	//CanDataStruct.HCU_SchedChgEndHrVal = (uint8_t)p.HCU_SchedChgEndHrVal;
	//CanDataStruct.HCU_SchedChgEndMinVal = (uint8_t)p.HCU_SchedChgEndMinVal;
	//CanDataStruct.HCU_SchedChgStrtDayVal = (uint8_t)p.HCU_SchedChgStrtDayVal;
	//CanDataStruct.HCU_SchedChgStrtHrVal = (uint8_t)p.HCU_SchedChgStrtHrVal;
	//CanDataStruct.HCU_SchedChgStrtMinVal = (uint8_t)p.HCU_SchedChgStrtMinVal;
	//CanDataStruct.HCU_SrvLmpDis = (uint8_t)p.HCU_SrvLmpDis;
	//CanDataStruct.HCU_SrvLmpTmpryOnSta = (uint8_t)p.HCU_SrvLmpTmpryOnSta;
	//CanDataStruct.HCU_AcnCompPrmsnPwrVal = (uint16_t)p.HCU_AcnCompPrmsnPwrVal;
	//CanDataStruct.HCU_PreFATCOffstTempValHR = (uint8_t)p.HCU_PreFATCOffstTempValHR;
	//CanDataStruct.HCU_SmartRegen_LvlVal = (uint8_t)p.HCU_SmartRegen_LvlVal;
	//CanDataStruct.HCU_PhevMod = (uint8_t)p.HCU_PhevMod;


}
void CanFrameTimeoutFunc_0x12A(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x130(uint8_t *data)
{
 //   SBW_SHFTR_FF_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SBW_SHFTR_FF_01_10ms_));
 //   
	//CanDataStruct.SBW_SHFTR_FF_Crc1Val = (uint16_t)p.SBW_SHFTR_FF_Crc1Val;
	//CanDataStruct.SBW_SHFTR_FF_AlvCnt1Val = (uint8_t)p.SBW_SHFTR_FF_AlvCnt1Val;
	//CanDataStruct.SBW_SHFTR_FF_LvrTyp = (uint8_t)p.SBW_SHFTR_FF_LvrTyp;
	//CanDataStruct.SBW_SHFTR_FF_P_Sta = (uint8_t)p.SBW_SHFTR_FF_P_Sta;
	//CanDataStruct.SBW_SHFTR_FF_LvrPosInfo = (uint8_t)p.SBW_SHFTR_FF_LvrPosInfo;
	//CanDataStruct.SBW_SHFTR_FF_LvrWrngMsg = (uint8_t)p.SBW_SHFTR_FF_LvrWrngMsg;
	//CanDataStruct.SBW_SHFTR_FF_LvrUnitSta = (uint8_t)p.SBW_SHFTR_FF_LvrUnitSta;
	//CanDataStruct.SBW_SHFTR_FF_LvrIndicatorSta = (uint8_t)p.SBW_SHFTR_FF_LvrIndicatorSta;
}

void CanFrameTimeoutFunc_0x130(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x145(uint8_t *data)
{
 //   DATC_01_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(DATC_01_20ms_));
 //   
	//CanDataStruct.DATC_Crc1Val = (uint16_t)p.DATC_Crc1Val;
	//CanDataStruct.DATC_AlvCnt1Val = (uint8_t)p.DATC_AlvCnt1Val;
	//CanDataStruct.DATC_PtcRlySta = (uint8_t)p.DATC_PtcRlySta;
	//CanDataStruct.DATC_ManufacturerTyp = (uint8_t)p.DATC_ManufacturerTyp;
	//CanDataStruct.DATC_AcnCompTyp = (uint8_t)p.DATC_AcnCompTyp;
	//CanDataStruct.DATC_AcnReq = (uint8_t)p.DATC_AcnReq;
	//CanDataStruct.DATC_BlwSta = (uint8_t)p.DATC_BlwSta;
	//CanDataStruct.DATC_BlwMaxSta = (uint8_t)p.DATC_BlwMaxSta;
	//CanDataStruct.DATC_EngStrtReq = (uint8_t)p.DATC_EngStrtReq;
	//CanDataStruct.DATC_IsgInhbtReq = (uint8_t)p.DATC_IsgInhbtReq;
	//CanDataStruct.DATC_AcnCompOnReq = (uint8_t)p.DATC_AcnCompOnReq;
	//CanDataStruct.DATC_EcvFltSta = (uint8_t)p.DATC_EcvFltSta;
	//CanDataStruct.DATC_CalcAcnCompTqVal = (uint8_t)p.DATC_CalcAcnCompTqVal;
	//CanDataStruct.DATC_MixDfgSelSta = (uint8_t)p.DATC_MixDfgSelSta;
	//CanDataStruct.DATC_OutTempSnsrVal = (uint8_t)p.DATC_OutTempSnsrVal;
	//CanDataStruct.DATC_ActvEco = (uint8_t)p.DATC_ActvEco;
	//CanDataStruct.DATC_AUTOActv = (uint8_t)p.DATC_AUTOActv;
	//CanDataStruct.DATC_DfgSw = (uint8_t)p.DATC_DfgSw;
	//CanDataStruct.DATC_SSC_EngStrtReq = (uint8_t)p.DATC_SSC_EngStrtReq;
	//CanDataStruct.DATC_SSC_InhbtReq = (uint8_t)p.DATC_SSC_InhbtReq;
	//CanDataStruct.DATC_EngIdlRpmUpReq = (uint8_t)p.DATC_EngIdlRpmUpReq;
}

void CanFrameTimeoutFunc_0x145(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x15A(uint8_t *data)
{
 //   SCU_FF_01_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SCU_FF_01_10ms_));
 //   
	//CanDataStruct.SCU_FF_Crc1Val = (uint16_t)p.SCU_FF_Crc1Val;
	//CanDataStruct.SCU_FF_AlvCnt1Val = (uint8_t)p.SCU_FF_AlvCnt1Val;
	//CanDataStruct.SCU_FF_PosActSta = (uint8_t)p.SCU_FF_PosActSta;
	//CanDataStruct.SCU_FF_ErrSta = (uint8_t)p.SCU_FF_ErrSta;
	//CanDataStruct.SCU_FF_EpbReq = (uint8_t)p.SCU_FF_EpbReq;
	//CanDataStruct.SCU_FF_PosTarSta = (uint8_t)p.SCU_FF_PosTarSta;
	//CanDataStruct.SCU_FF_NConReq = (uint8_t)p.SCU_FF_NConReq;
}

void CanFrameTimeoutFunc_0x15A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x160(uint8_t *data)
{
 //   ADAS_CMD_10_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_CMD_10_20ms_));
 //   
	//CanDataStruct.ADAS_CMD_Crc10Val = (uint16_t)p.ADAS_CMD_Crc10Val;
	//CanDataStruct.ADAS_CMD_AlvCnt10Val = (uint8_t)p.ADAS_CMD_AlvCnt10Val;
	//CanDataStruct.FCA_OnOffEquipSta = (uint8_t)p.FCA_OnOffEquipSta;
	//CanDataStruct.FCA_SysFlrSta = (uint8_t)p.FCA_SysFlrSta;
	//CanDataStruct.FCA_WrngLvlSta = (uint8_t)p.FCA_WrngLvlSta;
	//CanDataStruct.FCA_VehStpReq = (uint8_t)p.FCA_VehStpReq;
	//CanDataStruct.FCA_StbltActvReq = (uint8_t)p.FCA_StbltActvReq;
	//CanDataStruct.FCA_HydrlcBstAsstReq = (uint8_t)p.FCA_HydrlcBstAsstReq;
	//CanDataStruct.FCA_DclReqVal = (uint8_t)p.FCA_DclReqVal;
	//CanDataStruct.FCA_PrefillActvReq = (uint8_t)p.FCA_PrefillActvReq;
	//CanDataStruct.FCA_PartialActvReq = (uint8_t)p.FCA_PartialActvReq;
	//CanDataStruct.FCA_FullActvReq = (uint8_t)p.FCA_FullActvReq;
	//CanDataStruct.FCA_SnstvtyModRetVal = (uint8_t)p.FCA_SnstvtyModRetVal;
	//CanDataStruct.FCA_WrngSndSta = (uint8_t)p.FCA_WrngSndSta;
	//CanDataStruct.FCA_RelVel = (uint16_t)p.FCA_RelVel;
	//CanDataStruct.FCA_TimetoCllsn = (uint8_t)p.FCA_TimetoCllsn;
	//CanDataStruct.FCA_WrngTrgtDis = (uint8_t)p.FCA_WrngTrgtDis;
}

void CanFrameTimeoutFunc_0x160(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x165(uint8_t *data)
{
 //   ADAS_PRK_20_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_PRK_20_20ms_));
 //   
	//CanDataStruct.ADAS_PRK_Crc2Val = (uint16_t)p.ADAS_PRK_Crc2Val;
	//CanDataStruct.ADAS_PRK_AlvCnt2Val = (uint8_t)p.ADAS_PRK_AlvCnt2Val;
	//CanDataStruct.PA_ModDis = (uint8_t)p.PA_ModDis;
 //   CanDataStruct.PA_ModSelSeqDis = p.PA_ModSelSeqDis;
	//CanDataStruct.PA_RSPA_Opt = (uint8_t)p.PA_RSPA_Opt;
	//CanDataStruct.PA_HmiStaDis = (uint8_t)p.PA_HmiStaDis;
	//CanDataStruct.PA_FrLftWrngDis = (uint8_t)p.PA_FrLftWrngDis;
	//CanDataStruct.PA_FrCtrWrngDis = (uint8_t)p.PA_FrCtrWrngDis;
	//CanDataStruct.PA_FrRtWrngDis = (uint8_t)p.PA_FrRtWrngDis;
	//CanDataStruct.PA_RrLftWrngDis = (uint8_t)p.PA_RrLftWrngDis;
	//CanDataStruct.PA_RrCtrWrngDis = (uint8_t)p.PA_RrCtrWrngDis;
	//CanDataStruct.PA_RrRtWrngDis = (uint8_t)p.PA_RrRtWrngDis;
	//CanDataStruct.PA_BpAlrmReq = (uint8_t)p.PA_BpAlrmReq;
	//CanDataStruct.PA_AlrmVlmLvlReq = (uint8_t)p.PA_AlrmVlmLvlReq;
	//CanDataStruct.PA_AlrmVlmDeratingReq = (uint8_t)p.PA_AlrmVlmDeratingReq;
	//CanDataStruct.PA_FrWrngAlrmReq = (uint8_t)p.PA_FrWrngAlrmReq;
	//CanDataStruct.PA_RrWrngAlrmReq = (uint8_t)p.PA_RrWrngAlrmReq;
	//CanDataStruct.PA_FrLftWrngAlrmReq = (uint8_t)p.PA_FrLftWrngAlrmReq;
	//CanDataStruct.PA_FrCtrWrngAlrmReq = (uint8_t)p.PA_FrCtrWrngAlrmReq;
	//CanDataStruct.PA_FrRtWrngAlrmReq = (uint8_t)p.PA_FrRtWrngAlrmReq;
	//CanDataStruct.PA_RrLftWrngAlrmReq = (uint8_t)p.PA_RrLftWrngAlrmReq;
	//CanDataStruct.PA_RrCtrWrngAlrmReq = (uint8_t)p.PA_RrCtrWrngAlrmReq;
	//CanDataStruct.PA_RrRtWrngAlrmReq = (uint8_t)p.PA_RrRtWrngAlrmReq;
	//CanDataStruct.PA_Sta = (uint8_t)p.PA_Sta;
	//CanDataStruct.PA_TestModSta = (uint8_t)p.PA_TestModSta;
	//CanDataStruct.PA_StrAnglReq = (uint16_t)p.PA_StrAnglReq;
	//CanDataStruct.ADAS_PRK_OptInfo = (uint8_t)p.ADAS_PRK_OptInfo;
	//CanDataStruct.SVM_CamConfgSta = (uint8_t)p.SVM_CamConfgSta;
	//CanDataStruct.SVM_PhnModSta = (uint8_t)p.SVM_PhnModSta;
}

void CanFrameTimeoutFunc_0x165(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x16A(uint8_t *data)
{
 //   ADAS_PRK_21_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_PRK_21_20ms_));
 //   
	//CanDataStruct.ADAS_PRK_Crc3Val = (uint16_t)p.ADAS_PRK_Crc3Val;
	//CanDataStruct.ADAS_PRK_AlvCnt3Val = (uint8_t)p.ADAS_PRK_AlvCnt3Val;
	//CanDataStruct.RSPA_AvnDis = (uint8_t)p.RSPA_AvnDis;
	//CanDataStruct.RSPA_AvnSubViewDis = (uint8_t)p.RSPA_AvnSubViewDis;
	//CanDataStruct.RSPA_CamDis = (uint8_t)p.RSPA_CamDis;
	//CanDataStruct.RSPA_AvnHmiDis = (uint8_t)p.RSPA_AvnHmiDis;
	//CanDataStruct.RSPA_Sta = (uint8_t)p.RSPA_Sta;
	//CanDataStruct.RSPA_Actv = (uint8_t)p.RSPA_Actv;
	//CanDataStruct.RSPA_TrgtGearSta = (uint8_t)p.RSPA_TrgtGearSta;
	//CanDataStruct.RSPA_EpbReq = (uint8_t)p.RSPA_EpbReq;
	//CanDataStruct.RSPA_ExtLampReq = (uint8_t)p.RSPA_ExtLampReq;
	//CanDataStruct.RSPA_CrankingReq = (uint8_t)p.RSPA_CrankingReq;
	//CanDataStruct.RSPA_IdOutWarnReq = (uint8_t)p.RSPA_IdOutWarnReq;
	//CanDataStruct.RSPA_IndBlnkReq = (uint8_t)p.RSPA_IndBlnkReq;
	//CanDataStruct.RSPA_SysOff = (uint8_t)p.RSPA_SysOff;
	//CanDataStruct.RSPA_DccCmd = (uint8_t)p.RSPA_DccCmd;
	//CanDataStruct.RSPA_StopReq = (uint8_t)p.RSPA_StopReq;
	//CanDataStruct.RSPA_SelDevInfo = (uint8_t)p.RSPA_SelDevInfo;
	//CanDataStruct.RSPA_SelFuncInfo = (uint8_t)p.RSPA_SelFuncInfo;
	//CanDataStruct.RSPA_TrgtVehSpdVal = (uint16_t)p.RSPA_TrgtVehSpdVal;
	//CanDataStruct.RSPA_AddtnlAccelActv = (uint8_t)p.RSPA_AddtnlAccelActv;
	//CanDataStruct.RSPA_Opt = (uint8_t)p.RSPA_Opt;
	//CanDataStruct.RSPA_TrgtTqVal = (uint16_t)p.RSPA_TrgtTqVal;
}

void CanFrameTimeoutFunc_0x16A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x170(uint8_t *data)
{
 //   ADAS_PRK_10_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_PRK_10_20ms_));
 //   
	//CanDataStruct.ADAS_PRK_Crc1Val = (uint16_t)p.ADAS_PRK_Crc1Val;
	//CanDataStruct.ADAS_PRK_AlvCnt1Val = (uint8_t)p.ADAS_PRK_AlvCnt1Val;
	//CanDataStruct.PCA_RrEquipSta = (uint8_t)p.PCA_RrEquipSta;
	//CanDataStruct.PCA_SysFlrSta = (uint8_t)p.PCA_SysFlrSta;
	//CanDataStruct.PCA_RrWrngLvlSta = (uint8_t)p.PCA_RrWrngLvlSta;
	//CanDataStruct.PCA_WrngSndCtrSta = (uint8_t)p.PCA_WrngSndCtrSta;
	//CanDataStruct.PCA_WrngSndLftSta = (uint8_t)p.PCA_WrngSndLftSta;
	//CanDataStruct.PCA_WrngSndRtSta = (uint8_t)p.PCA_WrngSndRtSta;
	//CanDataStruct.PCA_BrkReq = (uint8_t)p.PCA_BrkReq;
	//CanDataStruct.PCA_DclTrgtVal = (uint8_t)p.PCA_DclTrgtVal;
	//CanDataStruct.ADAS_PRK_PDW_OptTyp = (uint8_t)p.ADAS_PRK_PDW_OptTyp;
	//CanDataStruct.ADAS_PRK_PDW_AutoOn_USM = (uint8_t)p.ADAS_PRK_PDW_AutoOn_USM;
}

void CanFrameTimeoutFunc_0x170(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1A0(uint8_t *data)
{
 //   ADAS_CMD_20_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_CMD_20_20ms_));
 //   
	//CanDataStruct.ADAS_CMD_Crc20Val = (uint16_t)p.ADAS_CMD_Crc20Val;
	//CanDataStruct.ADAS_CMD_AlvCnt20Val = (uint8_t)p.ADAS_CMD_AlvCnt20Val;
	//CanDataStruct.SCC_ObjDstVal = (uint16_t)p.SCC_ObjDstVal;
	//CanDataStruct.SCC_ObjRelSpdVal = (uint16_t)p.SCC_ObjRelSpdVal;
	//CanDataStruct.SCC_ObjLatPosVal = (uint16_t)p.SCC_ObjLatPosVal;
	//CanDataStruct.SCC_SysFlrSta = (uint8_t)p.SCC_SysFlrSta;
	//CanDataStruct.SCC_MainOnOffSta = (uint8_t)p.SCC_MainOnOffSta;
	//CanDataStruct.SCC_OpSta = (uint8_t)p.SCC_OpSta;
	//CanDataStruct.SCC_TakeoverReq = (uint8_t)p.SCC_TakeoverReq;
	//CanDataStruct.SCC_InfoDis = (uint8_t)p.SCC_InfoDis;
	//CanDataStruct.SCC_DrvAlrtDis = (uint8_t)p.SCC_DrvAlrtDis;
	//CanDataStruct.SCC_ObjDstLvlVal = (uint8_t)p.SCC_ObjDstLvlVal;
	//CanDataStruct.SCC_HeadwayDstSetVal = (uint8_t)p.SCC_HeadwayDstSetVal;
	//CanDataStruct.SCC_NSCCAutoSetSpdSta = (uint8_t)p.SCC_NSCCAutoSetSpdSta;
	//CanDataStruct.SCC_TrgtSpdSetVal = (uint8_t)p.SCC_TrgtSpdSetVal;
	//CanDataStruct.SCC_NSCCOpSta = (uint8_t)p.SCC_NSCCOpSta;
	//CanDataStruct.SCC_NSCCOnOffSta = (uint8_t)p.SCC_NSCCOnOffSta;
	//CanDataStruct.SCC_ObjSta = (uint8_t)p.SCC_ObjSta;
	//CanDataStruct.SCC_SnstvtyModRetVal = (uint8_t)p.SCC_SnstvtyModRetVal;
	//CanDataStruct.SCC_NSCCAutoSetSpdUpdtSta = (uint8_t)p.SCC_NSCCAutoSetSpdUpdtSta;
	//CanDataStruct.SCC_NSCCInfoPUDis = (uint8_t)p.SCC_NSCCInfoPUDis;
	//CanDataStruct.SCC_AccelReqVal = (uint16_t)p.SCC_AccelReqVal;
	//CanDataStruct.SCC_AccelReqRawVal = (uint16_t)p.SCC_AccelReqRawVal;
	//CanDataStruct.SCC_JrkUppLimVal = (uint8_t)p.SCC_JrkUppLimVal;
	//CanDataStruct.SCC_JrkLwrLimVal = (uint8_t)p.SCC_JrkLwrLimVal;
	//CanDataStruct.SCC_AccelLimBandUppVal = (uint8_t)p.SCC_AccelLimBandUppVal;
	//CanDataStruct.SCC_AccelLimBandLwrVal = (uint8_t)p.SCC_AccelLimBandLwrVal;
	//CanDataStruct.SCC_VehStpReq = (uint8_t)p.SCC_VehStpReq;
	//CanDataStruct.SCC_EngStateReq = (uint8_t)p.SCC_EngStateReq;
	//CanDataStruct.SCC_TrgtDstVal = (uint16_t)p.SCC_TrgtDstVal;
}

void CanFrameTimeoutFunc_0x1A0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1A5(uint8_t *data)
{
 //   AWD_01_20ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(AWD_01_20ms_));
 //   
	//CanDataStruct.AWD_Crc1Val = (uint16_t)p.AWD_Crc1Val;
	//CanDataStruct.AWD_AlvCnt1Val = (uint8_t)p.AWD_AlvCnt1Val;
	//CanDataStruct.AWD_Typ = (uint8_t)p.AWD_Typ;
	//CanDataStruct.AWD_SigSpprtSta = (uint8_t)p.AWD_SigSpprtSta;
	//CanDataStruct.AWD_IcscErrSta = (uint8_t)p.AWD_IcscErrSta;
	//CanDataStruct.AWD_ErrCodeVal = (uint8_t)p.AWD_ErrCodeVal;
	//CanDataStruct.AWD_CltchDtVal = (uint8_t)p.AWD_CltchDtVal;
	//CanDataStruct.AWD_TireRdsVal = (uint8_t)p.AWD_TireRdsVal;
	//CanDataStruct.AWD_SwVerVal = (uint8_t)p.AWD_SwVerVal;
	//CanDataStruct.AWD_OpMod2HSta = (uint8_t)p.AWD_OpMod2HSta;
	//CanDataStruct.AWD_OpMod4HSta = (uint8_t)p.AWD_OpMod4HSta;
	//CanDataStruct.AWD_OpModLowSta = (uint8_t)p.AWD_OpModLowSta;
	//CanDataStruct.AWD_OpModAutoSta = (uint8_t)p.AWD_OpModAutoSta;
	//CanDataStruct.AWD_OpModLkSta = (uint8_t)p.AWD_OpModLkSta;
	//CanDataStruct.AWD_TireSizeWrng = (uint8_t)p.AWD_TireSizeWrng;
	//CanDataStruct.AWD_ShaftTqVal = (uint16_t)p.AWD_ShaftTqVal;
	//CanDataStruct.AWD_StrWhlPosVal = (uint16_t)p.AWD_StrWhlPosVal;
	//CanDataStruct.AWD_FRWhlSpdSnsrVal = (uint8_t)p.AWD_FRWhlSpdSnsrVal;
	//CanDataStruct.AWD_FLWhlSpdSnsrVal = (uint8_t)p.AWD_FLWhlSpdSnsrVal;
	//CanDataStruct.AWD_RRWhlSpdSnsrVal = (uint8_t)p.AWD_RRWhlSpdSnsrVal;
	//CanDataStruct.AWD_RLWhlSpdSnsrVal = (uint8_t)p.AWD_RLWhlSpdSnsrVal;
	//CanDataStruct.AWD_CltchPrsrVal = (uint16_t)p.AWD_CltchPrsrVal;
	//CanDataStruct.AWD_ActrCurrVal = (uint8_t)p.AWD_ActrCurrVal;
	//CanDataStruct.AWD_ActrPosVal = (uint16_t)p.AWD_ActrPosVal;
	//CanDataStruct.AWD_CltchThrmlStrssVal = (uint8_t)p.AWD_CltchThrmlStrssVal;
	//CanDataStruct.AWD_SysOpSta = (uint8_t)p.AWD_SysOpSta;
	//CanDataStruct.AWD_FrTqDistRto = (uint8_t)p.AWD_FrTqDistRto;
	//CanDataStruct.AWD_RrTqDistRto = (uint8_t)p.AWD_RrTqDistRto;
}

void CanFrameTimeoutFunc_0x1A5(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1BA(uint8_t *data)
{
 //   RR_C_RDR_02_50ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(RR_C_RDR_02_50ms_));
 //   
	//CanDataStruct.RR_C_RDR_Crc02Val = (uint16_t)p.RR_C_RDR_Crc02Val;
	//CanDataStruct.RR_C_RDR_AlvCnt02Val = (uint8_t)p.RR_C_RDR_AlvCnt02Val;
	//CanDataStruct.BCW_Sta = (uint8_t)p.BCW_Sta;
	//CanDataStruct.BCW_OnOffEquipSta = (uint8_t)p.BCW_OnOffEquipSta;
	//CanDataStruct.BCW_LftIndSta = (uint8_t)p.BCW_LftIndSta;
	//CanDataStruct.BCW_RtIndSta = (uint8_t)p.BCW_RtIndSta;
	//CanDataStruct.BCW_LftSndWrngSta = (uint8_t)p.BCW_LftSndWrngSta;
	//CanDataStruct.BCW_RtSndWrngSta = (uint8_t)p.BCW_RtSndWrngSta;
	//CanDataStruct.BCW_LftIndBriLvlVal = (uint8_t)p.BCW_LftIndBriLvlVal;
	//CanDataStruct.BCW_RtIndBriLvlVal = (uint8_t)p.BCW_RtIndBriLvlVal;
	//CanDataStruct.BCW_SnstvtyModRetVal = (uint8_t)p.BCW_SnstvtyModRetVal;
	//CanDataStruct.BCW_IndSta = (uint8_t)p.BCW_IndSta;
	//CanDataStruct.BCA_Sta = (uint8_t)p.BCA_Sta;
	//CanDataStruct.BCA_OnOffEquipSta = (uint8_t)p.BCA_OnOffEquipSta;
	//CanDataStruct.BCA_R_Brake_Warning = (uint8_t)p.BCA_R_Brake_Warning;
	//CanDataStruct.BCA_Plus_Deccel_Req = (uint8_t)p.BCA_Plus_Deccel_Req;
	//CanDataStruct.BCA_Plus_BrkCmdSta = (uint8_t)p.BCA_Plus_BrkCmdSta;
	//CanDataStruct.BCA_Plus_LftWrngSta = (uint8_t)p.BCA_Plus_LftWrngSta;
	//CanDataStruct.BCA_Plus_RtWrngSta = (uint8_t)p.BCA_Plus_RtWrngSta;
	//CanDataStruct.BCA_Plus_Sta = (uint8_t)p.BCA_Plus_Sta;
	//CanDataStruct.Brake_Control_FL = (uint8_t)p.Brake_Control_FL;
	//CanDataStruct.Brake_Control_FR = (uint8_t)p.Brake_Control_FR;
	//CanDataStruct.Front_Target_Pressure = (uint8_t)p.Front_Target_Pressure;
}

void CanFrameTimeoutFunc_0x1BA(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1E0(uint8_t *data)
{
 //   ADAS_CMD_31_50ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ADAS_CMD_31_50ms_));
 //   
	//CanDataStruct.ADAS_CMD_Crc31Val = (uint16_t)p.ADAS_CMD_Crc31Val;
	//CanDataStruct.ADAS_CMD_AlvCnt31Val = (uint8_t)p.ADAS_CMD_AlvCnt31Val;
	//CanDataStruct.HDA_OptUsmSta = (uint8_t)p.HDA_OptUsmSta;
	//CanDataStruct.HDA_CntrlModSta = (uint8_t)p.HDA_CntrlModSta;
	//CanDataStruct.HDA_InfoPUDis = (uint8_t)p.HDA_InfoPUDis;
	//CanDataStruct.HDA_LFA_SymSta = (uint8_t)p.HDA_LFA_SymSta;
	//CanDataStruct.HDA_LFA_WrnSnd = (uint8_t)p.HDA_LFA_WrnSnd;
	//CanDataStruct.HDA_InfoPUDis1 = (uint8_t)p.HDA_InfoPUDis1;
	//CanDataStruct.HDA_TDMRMDclReq = (uint8_t)p.HDA_TDMRMDclReq;
}

void CanFrameTimeoutFunc_0x1E0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1E5(uint8_t *data)
{
 //   RR_C_RDR_01_50ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(RR_C_RDR_01_50ms_));
 //   
	//CanDataStruct.RR_C_RDR_Crc1Val = (uint16_t)p.RR_C_RDR_Crc1Val;
	//CanDataStruct.RR_C_RDR_AlvCnt1Val = (uint8_t)p.RR_C_RDR_AlvCnt1Val;
	//CanDataStruct.RCCW_Sta = (uint8_t)p.RCCW_Sta;
	//CanDataStruct.RCCW_OnOffEquipSt = (uint8_t)p.RCCW_OnOffEquipSt;
	//CanDataStruct.RCCW_LftIndSta = (uint8_t)p.RCCW_LftIndSta;
	//CanDataStruct.RCCW_RtIndSta = (uint8_t)p.RCCW_RtIndSta;
	//CanDataStruct.RCCW_LftSndWrngSta = (uint8_t)p.RCCW_LftSndWrngSta;
	//CanDataStruct.RCCW_RtSndWrngSta = (uint8_t)p.RCCW_RtSndWrngSta;
	//CanDataStruct.RCCW_LftWrngIndBriLvlVal = (uint8_t)p.RCCW_LftWrngIndBriLvlVal;
	//CanDataStruct.RCCW_RtWrngIndBriLvlVal = (uint8_t)p.RCCW_RtWrngIndBriLvlVal;
	//CanDataStruct.RCCA_Deccel_Req = (uint8_t)p.RCCA_Deccel_Req;
	//CanDataStruct.RCCA_BrkCmdSta = (uint8_t)p.RCCA_BrkCmdSta;
	//CanDataStruct.RCCA_LftWrngSta = (uint8_t)p.RCCA_LftWrngSta;
	//CanDataStruct.RCCA_RtWrngSta = (uint8_t)p.RCCA_RtWrngSta;
	//CanDataStruct.RCCA_FuncStat = (uint8_t)p.RCCA_FuncStat;
	//CanDataStruct.RCCA_Sta = (uint8_t)p.RCCA_Sta;
	//CanDataStruct.RCCA_OnOffEquipSt = (uint8_t)p.RCCA_OnOffEquipSt;
	//CanDataStruct.SEA_Sta = (uint8_t)p.SEA_Sta;
	//CanDataStruct.SEA_LftWrngSta = (uint8_t)p.SEA_LftWrngSta;
	//CanDataStruct.SEA_RtWrngSta = (uint8_t)p.SEA_RtWrngSta;
	//CanDataStruct.SEW_OnOffEquipSta_New = (uint8_t)p.SEW_OnOffEquipSta_New;
}

void CanFrameTimeoutFunc_0x1E5(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1F0(uint8_t *data)
{
 //   EPB_01_50ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(EPB_01_50ms_));
 //   
	//CanDataStruct.EPB_Crc1Val = (uint16_t)p.EPB_Crc1Val;
	//CanDataStruct.EPB_AlvCnt1Val = (uint8_t)p.EPB_AlvCnt1Val;
	//CanDataStruct.EPB_LmpStaDis = (uint8_t)p.EPB_LmpStaDis;
	//CanDataStruct.EPB_FlrLmpStaDis = (uint8_t)p.EPB_FlrLmpStaDis;
	//CanDataStruct.EPB_OutDataDis = (uint8_t)p.EPB_OutDataDis;
	//CanDataStruct.EPB_AlrmReq = (uint8_t)p.EPB_AlrmReq;
	//CanDataStruct.EPB_SwPosSta = (uint8_t)p.EPB_SwPosSta;
	//CanDataStruct.EPB_RrBrkLtActvReq = (uint8_t)p.EPB_RrBrkLtActvReq;
	//CanDataStruct.EPB_FrcErrSta = (uint8_t)p.EPB_FrcErrSta;
	//CanDataStruct.EPB_DynmBrkFrcReqSigSta = (uint8_t)p.EPB_DynmBrkFrcReqSigSta;
	//CanDataStruct.EPB_FrcSta = (uint8_t)p.EPB_FrcSta;
	//CanDataStruct.EPB_FlSta = (uint8_t)p.EPB_FlSta;
	//CanDataStruct.EPB_EscReqAckSta = (uint8_t)p.EPB_EscReqAckSta;
	//CanDataStruct.EPB_DynmBrkFrcReq = (uint8_t)p.EPB_DynmBrkFrcReq;
	//CanDataStruct.EPB_ActlFrcVal = (uint16_t)p.EPB_ActlFrcVal;
	//CanDataStruct.EPB_DynmBrkFrcDclReq = (uint8_t)p.EPB_DynmBrkFrcDclReq;
}

void CanFrameTimeoutFunc_0x1F0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x1FA(uint8_t *data)
{
 //   FR_CMR_02_100ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(FR_CMR_02_100ms_));
 //   
	//CanDataStruct.FR_CMR_Crc2Val = (uint16_t)p.FR_CMR_Crc2Val;
	//CanDataStruct.FR_CMR_AlvCnt2Val = (uint8_t)p.FR_CMR_AlvCnt2Val;
	//CanDataStruct.ISLW_OptUsmSta = (uint8_t)p.ISLW_OptUsmSta;
	//CanDataStruct.ISLW_SysSta = (uint8_t)p.ISLW_SysSta;
	//CanDataStruct.ISLW_NoPassingInfoDis = (uint8_t)p.ISLW_NoPassingInfoDis;
	//CanDataStruct.ISLW_OvrlpSignDis = (uint8_t)p.ISLW_OvrlpSignDis;
	//CanDataStruct.ISLW_SpdCluMainDis = (uint8_t)p.ISLW_SpdCluMainDis;
	//CanDataStruct.ISLW_SpdNaviMainDis = (uint8_t)p.ISLW_SpdNaviMainDis;
	//CanDataStruct.ISLW_SubCondinfoSta1 = (uint8_t)p.ISLW_SubCondinfoSta1;
	//CanDataStruct.ISLW_SubCondinfoSta2 = (uint8_t)p.ISLW_SubCondinfoSta2;
	//CanDataStruct.ISLW_SpdCluSubMainDis = (uint8_t)p.ISLW_SpdCluSubMainDis;
	//CanDataStruct.ISLW_SpdCluDisSubCond1 = (uint8_t)p.ISLW_SpdCluDisSubCond1;
	//CanDataStruct.ISLW_SpdCluDisSubCond2 = (uint8_t)p.ISLW_SpdCluDisSubCond2;
	//CanDataStruct.ISLW_SpdNaviSubMainDis = (uint8_t)p.ISLW_SpdNaviSubMainDis;
	//CanDataStruct.ISLW_SpdNaviDisSubCond1 = (uint8_t)p.ISLW_SpdNaviDisSubCond1;
	//CanDataStruct.ISLW_SpdNaviDisSubCond2 = (uint8_t)p.ISLW_SpdNaviDisSubCond2;
	//CanDataStruct.ISLA_SpdwOffst = (uint8_t)p.ISLA_SpdwOffst;
	//CanDataStruct.ISLA_SwIgnoreReq = (uint8_t)p.ISLA_SwIgnoreReq;
	//CanDataStruct.ISLA_SpdChgReq = (uint8_t)p.ISLA_SpdChgReq;
	//CanDataStruct.ISLA_SpdWrn = (uint8_t)p.ISLA_SpdWrn;
	//CanDataStruct.ISLA_IcyWrn = (uint8_t)p.ISLA_IcyWrn;
	//CanDataStruct.ISLA_SymFlashMod = (uint8_t)p.ISLA_SymFlashMod;
	//CanDataStruct.ISLA_Popup = (uint8_t)p.ISLA_Popup;
	//CanDataStruct.ISLA_OptUsmSta = (uint8_t)p.ISLA_OptUsmSta;
	//CanDataStruct.ISLA_OffstUsmSta = (uint8_t)p.ISLA_OffstUsmSta;
	//CanDataStruct.ISLA_AutoUsmSta = (uint8_t)p.ISLA_AutoUsmSta;
	//CanDataStruct.ISLA_Cntry = (uint8_t)p.ISLA_Cntry;
	//CanDataStruct.ISLA_AddtnlSign = (uint8_t)p.ISLA_AddtnlSign;
	//CanDataStruct.ISLA_SchoolZone = (uint8_t)p.ISLA_SchoolZone;   
}

void CanFrameTimeoutFunc_0x1FA(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x20A(uint8_t *data)
{
 //   ACU_01_100ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ACU_01_100ms_));
 //   
	//CanDataStruct.ACU_Crc1Val = (uint16_t)p.ACU_Crc1Val;
	//CanDataStruct.ACU_AlvCnt1Val = (uint8_t)p.ACU_AlvCnt1Val;
	//CanDataStruct.ACU_SysWrngLmpDis = (uint8_t)p.ACU_SysWrngLmpDis;
	//CanDataStruct.ACU_TlltlLmpDis = (uint8_t)p.ACU_TlltlLmpDis;
	//CanDataStruct.ACU_OdsIDReq = (uint8_t)p.ACU_OdsIDReq;
	//CanDataStruct.SeatBelt_PassBcklFltSta = (uint8_t)p.SeatBelt_PassBcklFltSta;
	//CanDataStruct.SeatBelt_DrvrBcklFltSta = (uint8_t)p.SeatBelt_DrvrBcklFltSta;
	//CanDataStruct.SeatBelt_PassBcklSta = (uint8_t)p.SeatBelt_PassBcklSta;
	//CanDataStruct.SeatBelt_DrvrBcklSta = (uint8_t)p.SeatBelt_DrvrBcklSta;
	//CanDataStruct.ACU_DiagTrblCodVal = (uint16_t)p.ACU_DiagTrblCodVal;
	//CanDataStruct.ACU_FltNumVal = (uint8_t)p.ACU_FltNumVal;
	//CanDataStruct.ACU_ActvFltSta = (uint8_t)p.ACU_ActvFltSta;
	//CanDataStruct.ACU_SdArbgExtTyp = (uint8_t)p.ACU_SdArbgExtTyp;
	//CanDataStruct.ACU_EmerModSta = (uint8_t)p.ACU_EmerModSta;
	//CanDataStruct.ACU_EvtTrigSta = (uint8_t)p.ACU_EvtTrigSta;
	//CanDataStruct.ACU_NumOfEmerModVal = (uint8_t)p.ACU_NumOfEmerModVal;
	//CanDataStruct.ACU_NumOfEvtTrigVal = (uint16_t)p.ACU_NumOfEvtTrigVal;
}

void CanFrameTimeoutFunc_0x20A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x220(uint8_t *data)
{
 //   ECS_01_100ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ECS_01_100ms_));
 //   
	//CanDataStruct.ECS_Crc1Val = (uint16_t)p.ECS_Crc1Val;
	//CanDataStruct.ECS_AlvCnt1Val = (uint8_t)p.ECS_AlvCnt1Val;
	//CanDataStruct.ECS_WrngLmpSta = (uint8_t)p.ECS_WrngLmpSta;
	//CanDataStruct.ECS_DfctvSta = (uint8_t)p.ECS_DfctvSta;
	//CanDataStruct.ECS_DmpModSta = (uint8_t)p.ECS_DmpModSta;
	//CanDataStruct.ECS_DmpModReq = (uint8_t)p.ECS_DmpModReq;
}

void CanFrameTimeoutFunc_0x220(uint8_t Lv)
{
}
void CanFrameAnlysisFunc_0x225(uint8_t data[])
{
    CLU_02_100ms_ p = {0};
    memcpy((void*)&p.Data[0], data, sizeof(CLU_02_100ms_));
    //
    CLU_02_100ms.CLU_Crc2Val = p.CLU_Crc2Val;
    CLU_02_100ms.CLU_AlvCnt2Val = p.CLU_AlvCnt2Val;
    CLU_02_100ms.CLU_OutTempCSta = p.CLU_OutTempCSta;
    CLU_02_100ms.CLU_DTEVal = p.CLU_DTEVal;
    CLU_02_100ms.CLU_TripUnitSta = p.CLU_TripUnitSta;
    CLU_02_100ms.CLU_AvgFuelCnsmptnVal = p.CLU_AvgFuelCnsmptnVal;
    CLU_02_100ms.CLU_AvgFuelCnsmptnUnitSta = p.CLU_AvgFuelCnsmptnUnitSta;
    CLU_02_100ms.CLU_LoFuelWrngSta = p.CLU_LoFuelWrngSta;
    CLU_02_100ms.CLU_RefuelDetSta = p.CLU_RefuelDetSta;
    CLU_02_100ms.CLU_TerrainMainSwSta = p.CLU_TerrainMainSwSta;
    CLU_02_100ms.CLU_LngSta = p.CLU_LngSta;
    CLU_02_100ms.CLU_SRSWrngLmpSta = p.CLU_SRSWrngLmpSta;
    CLU_02_100ms.CLU_OdoVal = p.CLU_OdoVal;
    CLU_02_100ms.CLU_DawLastBrkTimeVal = p.CLU_DawLastBrkTimeVal;
    CLU_02_100ms.CLU_RefuelWrnSta = p.CLU_RefuelWrnSta;
    CLU_02_100ms.CLU_IceWrnIndSta = p.CLU_IceWrnIndSta;
    CLU_02_100ms.CLU_DrvngModSwSta = p.CLU_DrvngModSwSta;
    CLU_02_100ms.CLU_FuelLvlSta = p.CLU_FuelLvlSta;
    CLU_02_100ms.CLU_OutTempFSta = p.CLU_OutTempFSta;
    CLU_02_100ms.CLU_TerrainModSwSta = p.CLU_TerrainModSwSta;

}

void CanFrameTimeoutFunc_0x225(uint8_t Lv)
{
}
void CanFrameAnlysisFunc_0x24A(uint8_t *data)
{
 //   ARD_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ARD_01_200ms_));
 //   
	//CanDataStruct.ARD_Crc1Val = (uint16_t)p.ARD_Crc1Val;
	//CanDataStruct.ARD_AlvCnt1Val = (uint8_t)p.ARD_AlvCnt1Val;
	//CanDataStruct.ARD_EstRdSta = (uint8_t)p.ARD_EstRdSta;
	//CanDataStruct.ARD_SysOpSta = (uint8_t)p.ARD_SysOpSta;
	//CanDataStruct.ARD_SysAppSta = (uint8_t)p.ARD_SysAppSta;
	//CanDataStruct.ARD_NrmlPrbVal = (uint8_t)p.ARD_NrmlPrbVal;
	//CanDataStruct.ARD_SnowPrbVal = (uint8_t)p.ARD_SnowPrbVal;
	//CanDataStruct.ARD_SandPrbVal = (uint8_t)p.ARD_SandPrbVal;
	//CanDataStruct.ARD_MudPrbVal = (uint8_t)p.ARD_MudPrbVal;
}

void CanFrameTimeoutFunc_0x24A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x260(uint8_t *data)
{
 //   EMS_05_100ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(EMS_05_100ms_));
 //   
	//CanDataStruct.EMS_Crc5Val = (uint16_t)p.EMS_Crc5Val;
	//CanDataStruct.EMS_AlvCnt5Val = (uint8_t)p.EMS_AlvCnt5Val;
	//CanDataStruct.ENG_ImmoLmpSta = (uint8_t)p.ENG_ImmoLmpSta;
	//CanDataStruct.ENG_MilSta = (uint8_t)p.ENG_MilSta;
	//CanDataStruct.ENG_ImmoSta = (uint8_t)p.ENG_ImmoSta;
	//CanDataStruct.OBD_RbmInhbtSta = (uint8_t)p.OBD_RbmInhbtSta;
	//CanDataStruct.ENG_AtmsphPrsrVal = (uint8_t)p.ENG_AtmsphPrsrVal;
	//CanDataStruct.EMS_EngStallDis = (uint8_t)p.EMS_EngStallDis;
	//CanDataStruct.ENG_DpfRgnSta = (uint8_t)p.ENG_DpfRgnSta;
	//CanDataStruct.ENG_AltFdbckLoadVal = (uint8_t)p.ENG_AltFdbckLoadVal;
	//CanDataStruct.ENG_BattVoltVal = (uint8_t)p.ENG_BattVoltVal;
	//CanDataStruct.ENG_FuelTempVal = (uint8_t)p.ENG_FuelTempVal;
	//CanDataStruct.SCC_DrvOvrRidSta = (uint8_t)p.SCC_DrvOvrRidSta;
	//CanDataStruct.SCC_SccFlrDetSta = (uint8_t)p.SCC_SccFlrDetSta;
	//CanDataStruct.SCC_FuncFlrDetSta = (uint8_t)p.SCC_FuncFlrDetSta;
	//CanDataStruct.SCC_SccOffStaDetSta = (uint8_t)p.SCC_SccOffStaDetSta;
	//CanDataStruct.SCC_BrkLtSwFlrDetSta = (uint8_t)p.SCC_BrkLtSwFlrDetSta;
	//CanDataStruct.EMS_RECTrigDta = (uint8_t)p.EMS_RECTrigDta;
	////CanDataStruct.ISA_IsaFuncSta = (uint8_t)p.ISA_IsaFuncSta;
	//CanDataStruct.EMS_PendingTrigSta = (uint8_t)p.EMS_PendingTrigSta;
	//CanDataStruct.SCC_StrtLimFuncSta = (uint8_t)p.SCC_StrtLimFuncSta;
	//CanDataStruct.EMS_SafetyFunctSta = (uint8_t)p.EMS_SafetyFunctSta;
	//CanDataStruct.InAirTempVal = (uint8_t)p.InAirTempVal;
	//CanDataStruct.OBD_RbmSta = (uint8_t)p.OBD_RbmSta;
	//CanDataStruct.AAF_WrnLamp = (uint8_t)p.AAF_WrnLamp;
	//CanDataStruct.OBD_IgnCycCntVal = (uint16_t)p.OBD_IgnCycCntVal;
	//CanDataStruct.OBD_DnmntrCalcVal = (uint16_t)p.OBD_DnmntrCalcVal;
	//CanDataStruct.SCR_LvlWrngLmpSta = (uint8_t)p.SCR_LvlWrngLmpSta;
	//CanDataStruct.SCR_LvlWrngMsgDis = (uint8_t)p.SCR_LvlWrngMsgDis;
	//CanDataStruct.SCR_SysErrMsgDis = (uint8_t)p.SCR_SysErrMsgDis;
	//CanDataStruct.SCR_SysWrngLmpReq = (uint8_t)p.SCR_SysWrngLmpReq;
	//CanDataStruct.SCR_IndcmtExitStaDis = (uint8_t)p.SCR_IndcmtExitStaDis;
	//CanDataStruct.SCR_UreaLvlSta = (uint8_t)p.SCR_UreaLvlSta;
	//CanDataStruct.SCR_RmnRstrtDis = (uint8_t)p.SCR_RmnRstrtDis;
	//CanDataStruct.SCR_RmnDstDis = (uint16_t)p.SCR_RmnDstDis;
	//CanDataStruct.ENG_TransmsnTyp = (uint8_t)p.ENG_TransmsnTyp;
	//CanDataStruct.ENG_IsgEquipped = (uint8_t)p.ENG_IsgEquipped;
	//CanDataStruct.ENG_EngDsplceTyp = (uint8_t)p.ENG_EngDsplceTyp;
	//CanDataStruct.ENG_EngTyp4 = (uint8_t)p.ENG_EngTyp4;
	//CanDataStruct.ENG_EngTyp3 = (uint8_t)p.ENG_EngTyp3;
	//CanDataStruct.ENG_EngTyp2 = (uint8_t)p.ENG_EngTyp2;
	//CanDataStruct.ENG_EngTyp1 = (uint8_t)p.ENG_EngTyp1;
	//CanDataStruct.ENG_S_F = (uint8_t)p.ENG_S_F;
	//CanDataStruct.ENG_S_F_GEN = (uint8_t)p.ENG_S_F_GEN;
	//CanDataStruct.ENG_IsgDispDetail = (uint8_t)p.ENG_IsgDispDetail;
	//CanDataStruct.ENG_TqStndValExt = (uint8_t)p.ENG_TqStndValExt;
	//CanDataStruct.ENG_ExtSoakTimeVal = (uint8_t)p.ENG_ExtSoakTimeVal;
	//CanDataStruct.ENG_KNK_Warning = (uint8_t)p.ENG_KNK_Warning;
	//CanDataStruct.ENG_OilLifeRatio = (uint8_t)p.ENG_OilLifeRatio;
	//CanDataStruct.ENG_OilLifeEna = (uint8_t)p.ENG_OilLifeEna;
	//CanDataStruct.ENG_OilLifeWarn = (uint8_t)p.ENG_OilLifeWarn; 
}

void CanFrameTimeoutFunc_0x260(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x2D0(uint8_t *data)
{
 //   TCU_03_100ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(TCU_03_100ms_));
 //   
	//CanDataStruct.TCU_Crc3Val = (uint16_t)p.TCU_Crc3Val;
	//CanDataStruct.TCU_AlvCnt3Val = (uint8_t)p.TCU_AlvCnt3Val;
	//CanDataStruct.TCU_WrngMsgSta = (uint8_t)p.TCU_WrngMsgSta;
	//CanDataStruct.TCU_VehStpTimeDis = (uint8_t)p.TCU_VehStpTimeDis;
	//CanDataStruct.TCU_NCCSetChk = (uint8_t)p.TCU_NCCSetChk;
	//CanDataStruct.TCU_TrailWarn = (uint8_t)p.TCU_TrailWarn;
	//CanDataStruct.TCU_SmartshiftSPTIndex_Long = (uint8_t)p.TCU_SmartshiftSPTIndex_Long;
	//CanDataStruct.TCU_SmartshiftSPTIndex_Sht = (uint8_t)p.TCU_SmartshiftSPTIndex_Sht;
	//CanDataStruct.TCU_DCTClutchMaxTemp = (uint8_t)p.TCU_DCTClutchMaxTemp;
	//CanDataStruct.TCU_CurCltTemp = (uint8_t)p.TCU_CurCltTemp;
	//CanDataStruct.TCU_AvgCltTemp = (uint8_t)p.TCU_AvgCltTemp;
	//CanDataStruct.TCU_RspaCanfailflag = (uint8_t)p.TCU_RspaCanfailflag;
	//CanDataStruct.TCU_RspaSta = (uint8_t)p.TCU_RspaSta;
	//CanDataStruct.TCU_RspaCtrlSta = (uint8_t)p.TCU_RspaCtrlSta;
	//CanDataStruct.TCU_PNTypConfg = (uint8_t)p.TCU_PNTypConfg;
	//CanDataStruct.DCT_HillHldWrng = (uint8_t)p.DCT_HillHldWrng;
	//CanDataStruct.DCT_CltchBrstWrng = (uint8_t)p.DCT_CltchBrstWrng;
	//CanDataStruct.DCT_WrngSndSta = (uint8_t)p.DCT_WrngSndSta;
	//CanDataStruct.TCU_ATTempWrng = (uint8_t)p.TCU_ATTempWrng;
	//CanDataStruct.TCU_FanCtrlReq = (uint8_t)p.TCU_FanCtrlReq;
}

void CanFrameTimeoutFunc_0x2D0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x382(uint8_t *data)
{
 //   DATC_05_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(DATC_05_200ms_));
 //   
	//CanDataStruct.DATC_Crc5Val = (uint16_t)p.DATC_Crc5Val;
	//CanDataStruct.DATC_AlvCnt5Val = (uint8_t)p.DATC_AlvCnt5Val;
	//CanDataStruct.DATC_FrDrvModDis = (uint8_t)p.DATC_FrDrvModDis;
	//CanDataStruct.DATC_TempDispUnitSta = (uint8_t)p.DATC_TempDispUnitSta;
	//CanDataStruct.DATC_DrvAutoDis = (uint8_t)p.DATC_DrvAutoDis;
	//CanDataStruct.DATC_FrChgReqDis = (uint8_t)p.DATC_FrChgReqDis;
	//CanDataStruct.DATC_AcDis = (uint8_t)p.DATC_AcDis;
	//CanDataStruct.DATC_IntakeSta = (uint8_t)p.DATC_IntakeSta;
}

void CanFrameTimeoutFunc_0x382(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x386(uint8_t *data)
{
 //   PSM_02_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(PSM_02_200ms_));
 //   
	//CanDataStruct.PSM_DrvStEsyAcsUSMSta = (uint8_t)p.PSM_DrvStEsyAcsUSMSta;
	//CanDataStruct.PSM_IMSOptTyp = (uint8_t)p.PSM_IMSOptTyp;
}

void CanFrameTimeoutFunc_0x386(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x39D(uint8_t *data)
{
 //   EMS_14_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(EMS_14_200ms_));
 //       CanDataStruct.EMS_BrkClthPrs_Warn = (uint8_t)p.EMS_BrkClthPrs_Warn;
	//CanDataStruct.ENG_Stall = (uint8_t)p.ENG_Stall;
}

void CanFrameTimeoutFunc_0x39D(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3A0(uint8_t *data)
{
 //   TPMS_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(TPMS_01_200ms_));
 //   
	//CanDataStruct.TPMS_Crc1Val = (uint16_t)p.TPMS_Crc1Val;
	//CanDataStruct.TPMS_AlvCnt1Val = (uint8_t)p.TPMS_AlvCnt1Val;
	//CanDataStruct.TPMS_FLPosWrngLmpSta = (uint8_t)p.TPMS_FLPosWrngLmpSta;
	//CanDataStruct.TPMS_FRPosWrngLmpSta = (uint8_t)p.TPMS_FRPosWrngLmpSta;
	//CanDataStruct.TPMS_RLPosWrngLmpSta = (uint8_t)p.TPMS_RLPosWrngLmpSta;
	//CanDataStruct.TPMS_RRPosWrngLmpSta = (uint8_t)p.TPMS_RRPosWrngLmpSta;
	//CanDataStruct.TPMS_FLTirePrsrVal = (uint8_t)p.TPMS_FLTirePrsrVal;
	//CanDataStruct.TPMS_FRTirePrsrVal = (uint8_t)p.TPMS_FRTirePrsrVal;
	//CanDataStruct.TPMS_RLTirePrsrVal = (uint8_t)p.TPMS_RLTirePrsrVal;
	//CanDataStruct.TPMS_RRTirePrsrVal = (uint8_t)p.TPMS_RRTirePrsrVal;
	//CanDataStruct.TPMS_SnsrSta = (uint8_t)p.TPMS_SnsrSta;
	//CanDataStruct.TPMS_WrngLmpSta = (uint8_t)p.TPMS_WrngLmpSta;
	//CanDataStruct.TPMS_TreadWrngLmpSta = (uint8_t)p.TPMS_TreadWrngLmpSta;
	//CanDataStruct.TPMS_PrsrUnitSta = (uint8_t)p.TPMS_PrsrUnitSta;
	//CanDataStruct.TPMS_FLMuteTimer = (uint8_t)p.TPMS_FLMuteTimer;
	//CanDataStruct.TPMS_FRMuteTimer = (uint8_t)p.TPMS_FRMuteTimer;
	//CanDataStruct.TPMS_RLMuteTimer = (uint8_t)p.TPMS_RLMuteTimer;
	//CanDataStruct.TPMS_RRMuteTimer = (uint8_t)p.TPMS_RRMuteTimer;
    
}

void CanFrameTimeoutFunc_0x3A0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3A5(uint8_t *data)
{
 //   SCU_FF_02_100ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SCU_FF_02_100ms_));
 //   
	//CanDataStruct.SCU_FF_Crc2Val = (uint16_t)p.SCU_FF_Crc2Val;
	//CanDataStruct.SCU_FF_AlvCnt2Val = (uint8_t)p.SCU_FF_AlvCnt2Val;
	//CanDataStruct.SCU_FF_WrnMsgClu = (uint8_t)p.SCU_FF_WrnMsgClu;
	//CanDataStruct.SCU_FF_RspaCanFlFlag = (uint8_t)p.SCU_FF_RspaCanFlFlag;
	//CanDataStruct.SCU_FF_RspaSta = (uint8_t)p.SCU_FF_RspaSta;
	//CanDataStruct.SCU_FF_NPosWshModSta = (uint8_t)p.SCU_FF_NPosWshModSta;
}

void CanFrameTimeoutFunc_0x3A5(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x030(uint8_t *data)
{
 //   EMS_03_10ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(EMS_03_10ms_));
 //   
	//CanDataStruct.Eng_OverRun = (uint16_t)p.Eng_OverRun;
}

void CanFrameTimeoutFunc_0x030(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3A6(uint8_t *data)
{
 //   PTGM_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(PTGM_01_200ms_));
 //   
	//CanDataStruct.PTGM_Crc1Val = (uint8_t)p.PTGM_Crc1Val;
	//CanDataStruct.PTGM_SpeedRValue = (uint8_t)p.PTGM_SpeedRValue;
	//CanDataStruct.PTGM_AlvCnt1Val = (uint8_t)p.PTGM_AlvCnt1Val;
	//CanDataStruct.PTGM_HazardSta = (uint8_t)p.PTGM_HazardSta;
	//CanDataStruct.PTGM_ModSta = (uint8_t)p.PTGM_ModSta;
	//CanDataStruct.PTGM_OptTyp = (uint8_t)p.PTGM_OptTyp;
	//CanDataStruct.PTGM_UsmSetSta = (uint8_t)p.PTGM_UsmSetSta;
	//CanDataStruct.PTGM_HeightRValue = (uint8_t)p.PTGM_HeightRValue;
	//CanDataStruct.PTGM_OpnClsState = (uint8_t)p.PTGM_OpnClsState;
	//CanDataStruct.PTGM_CmdWarn = (uint8_t)p.PTGM_CmdWarn;
	//CanDataStruct.PTGM_AntiPinchSnsr = (uint8_t)p.PTGM_AntiPinchSnsr;
	//CanDataStruct.PTGM_TrnkTlgtOption = (uint8_t)p.PTGM_TrnkTlgtOption;
	//CanDataStruct.PTGM_LatchType = (uint8_t)p.PTGM_LatchType;
}

void CanFrameTimeoutFunc_0x3A6(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3BF(uint8_t *data)
{
 //   ECALL_CLU_PE_01_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ECALL_CLU_PE_01_));
 //   
	//CanDataStruct.eCall_SWL_Ind = (uint8_t)p.eCall_SWL_Ind;
}

void CanFrameTimeoutFunc_0x3BF(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3C0(uint8_t *data)
{
 //   ROA_01_1000ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ROA_01_1000ms_));
 //   
	//CanDataStruct.ROA_SWVerMajor1 = (uint8_t)p.ROA_SWVerMajor1;
	//CanDataStruct.ROA_SWVerMinor1 = (uint8_t)p.ROA_SWVerMinor1;
	//CanDataStruct.ROA_SWVerMinor2 = (uint8_t)p.ROA_SWVerMinor2;
	//CanDataStruct.ROA_RrStRmndAlrm = (uint8_t)p.ROA_RrStRmndAlrm;
	//CanDataStruct.USM_ROA_RrStRmndSta = (uint8_t)p.USM_ROA_RrStRmndSta;
	//CanDataStruct.Warn_ROA_RrStRmndSysSta = (uint8_t)p.Warn_ROA_RrStRmndSysSta;
	//CanDataStruct.Warn_ROA_RrStRmndOpt = (uint8_t)p.Warn_ROA_RrStRmndOpt;
	//CanDataStruct.Warn_ROA_RrStRmndAlrmInfo = (uint8_t)p.Warn_ROA_RrStRmndAlrmInfo;
	//CanDataStruct.Warn_ROA_RrStRmndAlrmOnReq = (uint8_t)p.Warn_ROA_RrStRmndAlrmOnReq;
	//CanDataStruct.Warn_RoaErrStat = (uint8_t)p.Warn_RoaErrStat;
	//CanDataStruct.USM_ROA_RrStRmndSta_RestMode = (uint8_t)p.USM_ROA_RrStRmndSta_RestMode;
	//CanDataStruct.ROA_ClassState = (uint8_t)p.ROA_ClassState;
}

void CanFrameTimeoutFunc_0x3C0(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3C1(uint8_t *data)
{
 //   MFSW_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(MFSW_01_200ms_));
 //   
	//CanDataStruct.MFSW_Crc1Val = (uint8_t)p.MFSW_Crc1Val;
	//CanDataStruct.MFSW_AlvCnt1Val = (uint8_t)p.MFSW_AlvCnt1Val;
	//CanDataStruct.Lamp_FrFogLmpSwSta = (uint8_t)p.Lamp_FrFogLmpSwSta;
	//CanDataStruct.Lamp_HdLmpHiSwSta = (uint8_t)p.Lamp_HdLmpHiSwSta;
	//CanDataStruct.Lamp_LtSwSta = (uint8_t)p.Lamp_LtSwSta;
	//CanDataStruct.Lamp_PassingLmpSwSta = (uint8_t)p.Lamp_PassingLmpSwSta;
	//CanDataStruct.Lamp_RrFogLmpSwSta = (uint8_t)p.Lamp_RrFogLmpSwSta;
	//CanDataStruct.Lamp_TrnSigLftSwSta = (uint8_t)p.Lamp_TrnSigLftSwSta;
	//CanDataStruct.Lamp_TrnSigRtSwSta = (uint8_t)p.Lamp_TrnSigRtSwSta;
	//CanDataStruct.Lamp_LaneChgTrnSigLftSwSta = (uint8_t)p.Lamp_LaneChgTrnSigLftSwSta;
	//CanDataStruct.Lamp_LaneChgTrnSigRtSwSta = (uint8_t)p.Lamp_LaneChgTrnSigRtSwSta;
}

void CanFrameTimeoutFunc_0x3C1(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3C2(uint8_t *data)
{
 //   MFSW_02_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(MFSW_02_200ms_));
 //   
	//CanDataStruct.MFSW_Crc2Val = (uint8_t)p.MFSW_Crc2Val;
	//CanDataStruct.MFSW_AlvCnt2Val = (uint8_t)p.MFSW_AlvCnt2Val;
	//CanDataStruct.Wiper_FrWiperSwSta = (uint8_t)p.Wiper_FrWiperSwSta;
	//CanDataStruct.Wiper_IntStepSta = (uint8_t)p.Wiper_IntStepSta;
	//CanDataStruct.Wiper_MstSwSta = (uint8_t)p.Wiper_MstSwSta;
	//CanDataStruct.Wiper_RrWiperSwSta = (uint8_t)p.Wiper_RrWiperSwSta;
	//CanDataStruct.Wiper_FrWiperWshSwSta = (uint8_t)p.Wiper_FrWiperWshSwSta;
	//CanDataStruct.Wiper_RrWiperWshSwSta = (uint8_t)p.Wiper_RrWiperWshSwSta;
	//CanDataStruct.MFSW_Info = (uint8_t)p.MFSW_Info;
}

void CanFrameTimeoutFunc_0x3C2(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3E1(uint8_t *data)
{
 //   BCM_03_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_03_200ms_));
 //   
	//CanDataStruct.BCM_Crc3Val = (uint8_t)p.BCM_Crc3Val;
	//CanDataStruct.BCM_AlvCnt3Val = (uint8_t)p.BCM_AlvCnt3Val;
	//CanDataStruct.SBR_StBltWrngBzrSta = (uint8_t)p.SBR_StBltWrngBzrSta;
	//CanDataStruct.SBR_DrvStBltIndSta = (uint8_t)p.SBR_DrvStBltIndSta;
	//CanDataStruct.SBR_RrLftStBltWrngIndSta = (uint8_t)p.SBR_RrLftStBltWrngIndSta;
	//CanDataStruct.SBR_RrRtStBltWrngIndSta = (uint8_t)p.SBR_RrRtStBltWrngIndSta;
	//CanDataStruct.SBR_RrCtrStBltIndSta = (uint8_t)p.SBR_RrCtrStBltIndSta;
}

void CanFrameTimeoutFunc_0x3E1(uint8_t Lv)
{
	/*CanDataStruct.BCM_Crc3Val = (uint8_t)p.BCM_Crc3Val;*/
	/*CanDataStruct.BCM_AlvCnt3Val = (uint8_t)p.BCM_AlvCnt3Val;*/
	/*CanDataStruct.SBR_StBltWrngBzrSta = (uint8_t)p.SBR_StBltWrngBzrSta;*/
	//CanDataStruct.SBR_DrvStBltIndSta = 0u;
	/*CanDataStruct.SBR_RrLftStBltWrngIndSta = (uint8_t)p.SBR_RrLftStBltWrngIndSta;*/
	/*CanDataStruct.SBR_RrRtStBltWrngIndSta = (uint8_t)p.SBR_RrRtStBltWrngIndSta;*/
	/*CanDataStruct.SBR_RrCtrStBltIndSta = (uint8_t)p.SBR_RrCtrStBltIndSta;*/
}

void CanFrameAnlysisFunc_0x3E2(uint8_t *data)
{
 //   BCM_04_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_04_200ms_));
 //   
	//CanDataStruct.BCM_Crc4Val = (uint8_t)p.BCM_Crc4Val;
	//CanDataStruct.BCM_AlvCnt4Val = (uint8_t)p.BCM_AlvCnt4Val;
	//CanDataStruct.Warn_BzrWrngSta = (uint8_t)p.Warn_BzrWrngSta;
	//CanDataStruct.Warn_BCMWrngSta = (uint8_t)p.Warn_BCMWrngSta;
	//CanDataStruct.Warn_RrStRmndOpt = (uint8_t)p.Warn_RrStRmndOpt;
	//CanDataStruct.Warn_RrStRmndAlrmOnReq = (uint8_t)p.Warn_RrStRmndAlrmOnReq;
	//CanDataStruct.Warn_RrStRmndSysSta = (uint8_t)p.Warn_RrStRmndSysSta;
	//CanDataStruct.Warn_RrStRmndAlrmInfo = (uint8_t)p.Warn_RrStRmndAlrmInfo;
	//CanDataStruct.Warn_RoaErr = (uint8_t)p.Warn_RoaErr;
	//CanDataStruct.IBU_RrStRmndAlrmSta = (uint8_t)p.IBU_RrStRmndAlrmSta;
}

void CanFrameTimeoutFunc_0x3E2(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3E5(uint8_t *data)
{
 //   BCM_05_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_05_200ms_));
 //   
	//CanDataStruct.BCM_Crc5Val = (uint8_t)p.BCM_Crc5Val;
	//CanDataStruct.BCM_AlvCnt5Val = (uint8_t)p.BCM_AlvCnt5Val;
	//CanDataStruct.PDW_OptTyp = (uint8_t)p.PDW_OptTyp;
	//CanDataStruct.PDW_SysChkSndSta = (uint8_t)p.PDW_SysChkSndSta;
	//CanDataStruct.PDW_SysOnSta = (uint8_t)p.PDW_SysOnSta;
	//CanDataStruct.PDW_FrCtrWrngLvlDis = (uint8_t)p.PDW_FrCtrWrngLvlDis;
	//CanDataStruct.PDW_FrCtrWrngSndSta = (uint8_t)p.PDW_FrCtrWrngSndSta;
	//CanDataStruct.PDW_FrLftWrngLvlDis = (uint8_t)p.PDW_FrLftWrngLvlDis;
	//CanDataStruct.PDW_FrLftWrngSndSta = (uint8_t)p.PDW_FrLftWrngSndSta;
	//CanDataStruct.PDW_FrRtWrngLvlDis = (uint8_t)p.PDW_FrRtWrngLvlDis;
	//CanDataStruct.PDW_FrRtWrngSndSta = (uint8_t)p.PDW_FrRtWrngSndSta;
	//CanDataStruct.PDW_FrSnsrWrngLvlSta = (uint8_t)p.PDW_FrSnsrWrngLvlSta;
    
}

void CanFrameTimeoutFunc_0x3E5(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3E6(uint8_t *data)
{
 //   BCM_06_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_06_200ms_));
 //   
	//CanDataStruct.BCM_Crc6Val = (uint8_t)p.BCM_Crc6Val;
	//CanDataStruct.BCM_AlvCnt6Val = (uint8_t)p.BCM_AlvCnt6Val;
	//CanDataStruct.PDW_RrCtrWrngLvlDis = (uint8_t)p.PDW_RrCtrWrngLvlDis;
	//CanDataStruct.PDW_RrCtrWrngSndSta = (uint8_t)p.PDW_RrCtrWrngSndSta;
	//CanDataStruct.PDW_RrLftWrngLvlDis = (uint8_t)p.PDW_RrLftWrngLvlDis;
	//CanDataStruct.PDW_RrLftWrngSndSta = (uint8_t)p.PDW_RrLftWrngSndSta;
	//CanDataStruct.PDW_RrRtWrngLvlDis = (uint8_t)p.PDW_RrRtWrngLvlDis;
	//CanDataStruct.PDW_RrRtWrngSndSta = (uint8_t)p.PDW_RrRtWrngSndSta;
	//CanDataStruct.PDW_RrSnsrWrngLvlSta = (uint8_t)p.PDW_RrSnsrWrngLvlSta;
}

void CanFrameTimeoutFunc_0x3E6(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x3EC(uint8_t *data)
{
 //   RCS_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(RCS_01_200ms_));
 //   
	//CanDataStruct.CF_RCS_SwTyp = (uint8_t)p.CF_RCS_SwTyp;
	//CanDataStruct.CF_RCS_DrvMod = (uint8_t)p.CF_RCS_DrvMod;
	//CanDataStruct.CF_RCS_OffRoad = (uint8_t)p.CF_RCS_OffRoad;
	//CanDataStruct.CF_RCS_BtnSta = (uint8_t)p.CF_RCS_BtnSta;
	//CanDataStruct.CF_RCS_RotateEnd = (uint8_t)p.CF_RCS_RotateEnd;
	//CanDataStruct.CF_RCS_4wdLocking = (uint8_t)p.CF_RCS_4wdLocking;
}
void CanFrameAnlysisFunc_0x448(uint8_t data[])
{
	//SWRC_01_200ms_ p = {0};
	//memcpy((void*)&p.Data[0], data, sizeof(SWRC_01_200ms_));

	//CanDataStruct.SWRC_Crc1Val = (uint8_t)p.SWRC_Crc1Val;
	//CanDataStruct.SWRC_AlvCnt1Val = (uint8_t)p.SWRC_AlvCnt1Val;
	//CanDataStruct.Audio_VcRecSwSta = (uint8_t)p.Audio_VcRecSwSta;
	//CanDataStruct.Audio_BluetoothPhnClSwSta = (uint8_t)p.Audio_BluetoothPhnClSwSta;
	//CanDataStruct.Audio_BluetoothPhnHangUpSwSta = (uint8_t)p.Audio_BluetoothPhnHangUpSwSta;
	//CanDataStruct.Audio_ModSwSta = (uint8_t)p.Audio_ModSwSta;
	//CanDataStruct.Audio_MutSwSta = (uint8_t)p.Audio_MutSwSta;
	//CanDataStruct.Audio_SeekDnSwSta = (uint8_t)p.Audio_SeekDnSwSta;
	//CanDataStruct.Audio_SeekUpSwSta = (uint8_t)p.Audio_SeekUpSwSta;
	//CanDataStruct.Audio_VolDnSwSta = (uint8_t)p.Audio_VolDnSwSta;
	//CanDataStruct.Audio_VolUpSwSta = (uint8_t)p.Audio_VolUpSwSta;
}
void CanFrameAnlysisFunc_0x08B(uint8_t data[])
{
	//SWRC_05_200ms_ p = {0};
	//memcpy((void*)&p.Data[0], data, sizeof(SWRC_05_200ms_));

	//CanDataStruct.SWRC_Crc5Val = (uint8_t)p.SWRC_Crc5Val;
	//CanDataStruct.SWRC_AlvCnt5Val = (uint8_t)p.SWRC_AlvCnt5Val;
	//CanDataStruct.SWRC_DriveModCWSwSta = (uint8_t)p.SWRC_DriveModCWSwSta;
	//CanDataStruct.SWRC_DriveModCCWSwSta = (uint8_t)p.SWRC_DriveModCCWSwSta;
	//CanDataStruct.SWRC_BoostSwSta = (uint8_t)p.SWRC_BoostSwSta;
	//CanDataStruct.SWRC_DriveModeSwSta = (uint8_t)p.SWRC_DriveModeSwSta;


}

void CanFrameTimeoutFunc_0x08B(uint8_t Lv)
{
}
void CanFrameTimeoutFunc_0x3EC(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x408(uint8_t *data)
{
 //   IAU_24_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(IAU_24_200ms_));
 //   
	//CanDataStruct.IAU_Year = (uint16_t)p.IAU_Year;
	//CanDataStruct.IAU_Month = (uint8_t)p.IAU_Month;
	//CanDataStruct.IAU_Date = (uint16_t)p.IAU_Date;
	//CanDataStruct.IAU_SWVerMajor1 = (uint8_t)p.IAU_SWVerMajor1;
	//CanDataStruct.IAU_SWVerMinor1 = (uint8_t)p.IAU_SWVerMinor1;
	//CanDataStruct.IAU_SWVerMinor2 = (uint8_t)p.IAU_SWVerMinor2;
}

void CanFrameTimeoutFunc_0x408(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x40C(uint8_t *data)
{
 //   IAU_23_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(IAU_23_200ms_));
 //   
	//CanDataStruct.IAU_Manufacturer = (uint8_t)p.IAU_Manufacturer;
	//CanDataStruct.IAU_VendorCode = (uint32_t)p.IAU_VendorCode;
	//CanDataStruct.IAU_Serial = (uint32_t)p.IAU_Serial;
}

void CanFrameTimeoutFunc_0x40C(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x410(uint8_t *data)
{
 //   ICU_10_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_10_200ms_));
 //   
	//CanDataStruct.ICU_Crc10Val = (uint8_t)p.ICU_Crc10Val;
	//CanDataStruct.ICU_BS2_VSOC = (uint8_t)p.ICU_BS2_VSOC;
	//CanDataStruct.ICU_AlvCnt10Val = (uint8_t)p.ICU_AlvCnt10Val;
	//CanDataStruct.ICU_BS2SoC = (uint8_t)p.ICU_BS2SoC;
	//CanDataStruct.ICU_BS2NCap = (uint8_t)p.ICU_BS2NCap;
	//CanDataStruct.ICU_BS2OpnCirVol = (uint16_t)p.ICU_BS2OpnCirVol;
	//CanDataStruct.ICU_BS2_FSOC = (uint8_t)p.ICU_BS2_FSOC;
	//CanDataStruct.ICU_BS2_FSOH = (uint8_t)p.ICU_BS2_FSOH;
	//CanDataStruct.ICU_BS2_FSOF = (uint8_t)p.ICU_BS2_FSOF;
	//CanDataStruct.ICU_BS2_FQSTAT = (uint8_t)p.ICU_BS2_FQSTAT;
	//CanDataStruct.ICU_BS2SoH = (uint8_t)p.ICU_BS2SoH;
	//CanDataStruct.ICU_BS2SoF = (uint8_t)p.ICU_BS2SoF;
}

void CanFrameTimeoutFunc_0x410(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x411(uint8_t *data)
{
 //   ICU_02_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_02_200ms_));
 //   
	//CanDataStruct.ICU_Crc2Val = (uint8_t)p.ICU_Crc2Val;
	//CanDataStruct.ICU_Haptic_OPT = (uint8_t)p.ICU_Haptic_OPT;
	//CanDataStruct.ICU_MtGearPosRSta = (uint8_t)p.ICU_MtGearPosRSta;
	//CanDataStruct.ICU_AlvCnt2Val = (uint8_t)p.ICU_AlvCnt2Val;
	//CanDataStruct.Autocut_DlvryModSta = (uint8_t)p.Autocut_DlvryModSta;
	//CanDataStruct.DoorLock_AsstDrUnLkSta = (uint8_t)p.DoorLock_AsstDrUnLkSta;
	//CanDataStruct.Warn_DrvDrSwSta = (uint8_t)p.Warn_DrvDrSwSta;
	//CanDataStruct.DoorLock_RrLftDrUnLkSta = (uint8_t)p.DoorLock_RrLftDrUnLkSta;
	//CanDataStruct.DoorLock_RrRtDrUnLkSta = (uint8_t)p.DoorLock_RrRtDrUnLkSta;
	//CanDataStruct.Warn_AsstDrSwSta = (uint8_t)p.Warn_AsstDrSwSta;
	//CanDataStruct.Warn_AsstStBltSwSta = (uint8_t)p.Warn_AsstStBltSwSta;
	//CanDataStruct.Warn_BrkFldSwSta = (uint8_t)p.Warn_BrkFldSwSta;
	//CanDataStruct.Warn_DrvStBltSwSta = (uint8_t)p.Warn_DrvStBltSwSta;
	//CanDataStruct.Warn_HoodSwSta = (uint8_t)p.Warn_HoodSwSta;
	//CanDataStruct.Warn_PassStOccSta = (uint8_t)p.Warn_PassStOccSta;
	//CanDataStruct.Warn_PrkngBrkSwSta = (uint8_t)p.Warn_PrkngBrkSwSta;
	//CanDataStruct.Warn_RrCtrStBltSwSta = (uint8_t)p.Warn_RrCtrStBltSwSta;
	//CanDataStruct.Warn_RrLftDrSwSta = (uint8_t)p.Warn_RrLftDrSwSta;
	//CanDataStruct.Warn_RrLftStBltSwSta = (uint8_t)p.Warn_RrLftStBltSwSta;
	//CanDataStruct.Warn_RrRtDrSwSta = (uint8_t)p.Warn_RrRtDrSwSta;
	//CanDataStruct.Warn_RrRtStBltSwSta = (uint8_t)p.Warn_RrRtStBltSwSta;
	//CanDataStruct.Warn_HoodSwMemorySta = (uint8_t)p.Warn_HoodSwMemorySta;
	//CanDataStruct.Warn_WshrFldSwSta = (uint8_t)p.Warn_WshrFldSwSta;
}

void CanFrameTimeoutFunc_0x411(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x413(uint8_t *data)
{
 //   ICU_04_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_04_200ms_));
 //   
	//CanDataStruct.ICU_Crc4Val = (uint8_t)p.ICU_Crc4Val;
	//CanDataStruct.Lamp_TrnSigLmpLftActiveSt = (uint8_t)p.Lamp_TrnSigLmpLftActiveSt;
	//CanDataStruct.Lamp_TrnSigLmpRtActiveSt = (uint8_t)p.Lamp_TrnSigLmpRtActiveSt;
	//CanDataStruct.ICU_AlvCnt4Val = (uint8_t)p.ICU_AlvCnt4Val;
	//CanDataStruct.ExtLamp_DedicatedDrlBlbSta = (uint8_t)p.ExtLamp_DedicatedDrlBlbSta;
	//CanDataStruct.ExtLamp_FrFgLmpSta = (uint8_t)p.ExtLamp_FrFgLmpSta;
	//CanDataStruct.ExtLamp_TrnSigLmpLftBlnkngSta = (uint8_t)p.ExtLamp_TrnSigLmpLftBlnkngSta;
	//CanDataStruct.ExtLamp_TrnSigLmpRtBlnkngSta = (uint8_t)p.ExtLamp_TrnSigLmpRtBlnkngSta;
	//CanDataStruct.ExtLamp_ExtrnlTailLmpSta = (uint8_t)p.ExtLamp_ExtrnlTailLmpSta;
	//CanDataStruct.ExtLamp_HzrdSwSta = (uint8_t)p.ExtLamp_HzrdSwSta;
	//CanDataStruct.ExtLamp_RrFgLmpSta = (uint8_t)p.ExtLamp_RrFgLmpSta;
	//CanDataStruct.IntLamp_InlTailLmpSta = (uint8_t)p.IntLamp_InlTailLmpSta;
	//CanDataStruct.ExtLamp_StcBendingLmpLftOnSta = (uint8_t)p.ExtLamp_StcBendingLmpLftOnSta;
	//CanDataStruct.ExtLamp_StcBendingLmpRtOnSta = (uint8_t)p.ExtLamp_StcBendingLmpRtOnSta;
	//CanDataStruct.Lamp_LedHdLmpSta = (uint8_t)p.Lamp_LedHdLmpSta;
}

void CanFrameTimeoutFunc_0x413(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x414(uint8_t *data)
{
 //   ICU_05_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_05_200ms_));
 //   
	//CanDataStruct.ICU_Crc5Val = (uint8_t)p.ICU_Crc5Val;
	//CanDataStruct.C_AutoLeverManualSW = (uint8_t)p.C_AutoLeverManualSW;
	//CanDataStruct.ICU_AlvCnt5Val = (uint8_t)p.ICU_AlvCnt5Val;
	//CanDataStruct.Trunk_TrnkTlgtOutReleaseSwSta = (uint8_t)p.Trunk_TrnkTlgtOutReleaseSwSta;
	//CanDataStruct.Trunk_TrnkTlgtSwSta = (uint8_t)p.Trunk_TrnkTlgtSwSta;
	//CanDataStruct.Trunk_TlgtFullOpnSwSta = (uint8_t)p.Trunk_TlgtFullOpnSwSta;
	//CanDataStruct.Trunk_OpnDiagSetSta = (uint8_t)p.Trunk_OpnDiagSetSta;
	//CanDataStruct.USM_OneTouchTrnSigFuncSta = (uint8_t)p.USM_OneTouchTrnSigFuncSta;
	//CanDataStruct.DoorLock_DrvDrUnLkSta = (uint8_t)p.DoorLock_DrvDrUnLkSta;
	//CanDataStruct.DoorLock_LkOutSta = (uint8_t)p.DoorLock_LkOutSta;
	//CanDataStruct.Mirror_FldngOptSta = (uint8_t)p.Mirror_FldngOptSta;
	//CanDataStruct.Trunk_TrnkTlgtOpenOutput = (uint8_t)p.Trunk_TrnkTlgtOpenOutput;
	//CanDataStruct.TwoTrnUnLkOptTyp = (uint8_t)p.TwoTrnUnLkOptTyp;
	//CanDataStruct.Defog_DfgrRlySta = (uint8_t)p.Defog_DfgrRlySta;
	//CanDataStruct.C_CrashUnlockState = (uint8_t)p.C_CrashUnlockState;
	//CanDataStruct.CF_Gway_ADrLOptInfo = (uint8_t)p.CF_Gway_ADrLOptInfo;
}

void CanFrameTimeoutFunc_0x414(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x416(uint8_t *data)
{
 //   ICU_06_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_06_200ms_));
 //   
	//CanDataStruct.ICU_Crc6Val = (uint8_t)p.ICU_Crc6Val;
	//CanDataStruct.ICU_AlvCnt6Val = (uint8_t)p.ICU_AlvCnt6Val;
	//CanDataStruct.Lamp_StpLmpLftOpnSta = (uint8_t)p.Lamp_StpLmpLftOpnSta;
	//CanDataStruct.Lamp_StpLmpRtOpnSta = (uint8_t)p.Lamp_StpLmpRtOpnSta;
	//CanDataStruct.Lamp_RrTrnSigLmpLftOpnSta = (uint8_t)p.Lamp_RrTrnSigLmpLftOpnSta;
	//CanDataStruct.Lamp_RrTrnSigLmpRtOpnSta = (uint8_t)p.Lamp_RrTrnSigLmpRtOpnSta;
	//CanDataStruct.Lamp_FrTrnSigLmpLftOpnSta = (uint8_t)p.Lamp_FrTrnSigLmpLftOpnSta;
	//CanDataStruct.Lamp_FrTrnSigLmpRtOpnSta = (uint8_t)p.Lamp_FrTrnSigLmpRtOpnSta;
}

void CanFrameTimeoutFunc_0x416(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x417(uint8_t *data)
{
 //   ICU_07_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_07_200ms_));
 //   
	//CanDataStruct.ICU_Crc7Val = (uint8_t)p.ICU_Crc7Val;
	//CanDataStruct.HeatedSteerWheel_AutoOffSta = (uint8_t)p.HeatedSteerWheel_AutoOffSta;
	//CanDataStruct.ICU_ADASHapticAutoOnSetReq = (uint8_t)p.ICU_ADASHapticAutoOnSetReq;
 //   CanDataStruct.ICU_AlvCnt7Val = (uint8_t)p.ICU_AlvCnt7Val;
	//CanDataStruct.SEA_ActvSta = (uint8_t)p.SEA_ActvSta;
	//CanDataStruct.ChildLock_ActnFlSta = (uint8_t)p.ChildLock_ActnFlSta;
	//CanDataStruct.USM_FuncForMdLmpClrSta = (uint8_t)p.USM_FuncForMdLmpClrSta;
	//CanDataStruct.USM_FuncForMdLmpBrgtSta = (uint8_t)p.USM_FuncForMdLmpBrgtSta;
	//CanDataStruct.USM_AutoDrLkReq = (uint8_t)p.USM_AutoDrLkReq;
	//CanDataStruct.USM_AutoDrUnLkReq = (uint8_t)p.USM_AutoDrUnLkReq;
	//CanDataStruct.USM_HapticCurrentSta = (uint8_t)p.USM_HapticCurrentSta;
	//CanDataStruct.USM_TwoTrnUnLkCurrentSta = (uint8_t)p.USM_TwoTrnUnLkCurrentSta;
	//CanDataStruct.Lamp_HdLmpHiSta = (uint8_t)p.Lamp_HdLmpHiSta;
	//CanDataStruct.Lamp_HdLmpLoSta = (uint8_t)p.Lamp_HdLmpLoSta;
	//CanDataStruct.ExtLamp_TrnSigLmpLftSwSta = (uint8_t)p.ExtLamp_TrnSigLmpLftSwSta;
	//CanDataStruct.ExtLamp_TrnSigLmpRtSwSta = (uint8_t)p.ExtLamp_TrnSigLmpRtSwSta;
	//CanDataStruct.Lamp_LaneChgTrnSigLftSwSta_ICU = (uint8_t)p.Lamp_LaneChgTrnSigLftSwSta_ICU;
	//CanDataStruct.Lamp_LaneChgTrnSigRtSwSta_ICU = (uint8_t)p.Lamp_LaneChgTrnSigRtSwSta_ICU;
}

void CanFrameTimeoutFunc_0x417(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x418(uint8_t *data)
{
 //   ICU_08_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_08_200ms_));
 //   
	//CanDataStruct.ICU_Crc8Val = (uint8_t)p.ICU_Crc8Val;
	//CanDataStruct.HSWS_SysWrngSta_ICU = (uint8_t)p.HSWS_SysWrngSta_ICU;
	//CanDataStruct.HeatedSteerWheel_StrWhlHtrSwSta = (uint8_t)p.HeatedSteerWheel_StrWhlHtrSwSta;
	//CanDataStruct.ICU_AlvCnt8Val = (uint8_t)p.ICU_AlvCnt8Val;
	//CanDataStruct.DriveTypeOption = (uint8_t)p.DriveTypeOption;
	//CanDataStruct.Warn_RrLftSBRMATSwSta = (uint8_t)p.Warn_RrLftSBRMATSwSta;
	//CanDataStruct.Warn_RrRhtSBRMATSwSta = (uint8_t)p.Warn_RrRhtSBRMATSwSta;
	//CanDataStruct.Warn_LftSEA = (uint8_t)p.Warn_LftSEA;
	//CanDataStruct.Warn_RhtSEA = (uint8_t)p.Warn_RhtSEA;
	//CanDataStruct.Lamp_MoodLampOnReq = (uint8_t)p.Lamp_MoodLampOnReq;
	//CanDataStruct.ICU_PowerAutoCutModSta = (uint8_t)p.ICU_PowerAutoCutModSta;
	//CanDataStruct.ICU_SoCBattStaMsgReq = (uint8_t)p.ICU_SoCBattStaMsgReq;
	//CanDataStruct.FRWndShldHtInd = (uint8_t)p.FRWndShldHtInd;
	//CanDataStruct.C_ICUPowerAutoCutType = (uint8_t)p.C_ICUPowerAutoCutType;
	//CanDataStruct.Brake_SwSta_ICU = (uint8_t)p.Brake_SwSta_ICU;
}

void CanFrameTimeoutFunc_0x418(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x41A(uint8_t *data)
{
 //   BCM_07_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_07_200ms_));
 //   
	//CanDataStruct.BCM_Crc7Val = (uint8_t)p.BCM_Crc7Val;
	//CanDataStruct.BCM_AlvCnt7Val = (uint8_t)p.BCM_AlvCnt7Val;
	//CanDataStruct.Lamp_HiPrioHzrdReq = (uint8_t)p.Lamp_HiPrioHzrdReq;
	//CanDataStruct.Lamp_LoPrioHzrdReq = (uint8_t)p.Lamp_LoPrioHzrdReq;
	//CanDataStruct.Lamp_DedicatedDrlOnReq = (uint8_t)p.Lamp_DedicatedDrlOnReq;
	//CanDataStruct.Lamp_DedicatedDrlOnLRReq = (uint8_t)p.Lamp_DedicatedDrlOnLRReq;
	//CanDataStruct.Lamp_IntTailLmpOnReq = (uint8_t)p.Lamp_IntTailLmpOnReq;
	//CanDataStruct.Lamp_ExtrnlTailLmpOnReq = (uint8_t)p.Lamp_ExtrnlTailLmpOnReq;
	//CanDataStruct.Lamp_HdLmpLoOnReq = (uint8_t)p.Lamp_HdLmpLoOnReq;
	//CanDataStruct.Lamp_HdLmpHiOnReq = (uint8_t)p.Lamp_HdLmpHiOnReq;
}

void CanFrameTimeoutFunc_0x41A(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x41C(uint8_t *data)
{
 //   BCM_09_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_09_200ms_));
 //   
	//CanDataStruct.BCM_Crc9Val = (uint8_t)p.BCM_Crc9Val;
	//CanDataStruct.BCM_AlvCnt9Val = (uint8_t)p.BCM_AlvCnt9Val;
}

void CanFrameTimeoutFunc_0x41C(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x422(uint8_t *data)
{
 //   BCM_10_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_10_200ms_));
 //   
	//CanDataStruct.BCM_Crc10Val = (uint8_t)p.BCM_Crc10Val;
	//CanDataStruct.BCM_AlvCnt10Val = (uint8_t)p.BCM_AlvCnt10Val;
	//CanDataStruct.Wiper_PrkngPosSta = (uint8_t)p.Wiper_PrkngPosSta;
	//CanDataStruct.Wiper_RainSnsrOptionTyp = (uint8_t)p.Wiper_RainSnsrOptionTyp;
	//CanDataStruct.Wiper_RainSnsrSta = (uint8_t)p.Wiper_RainSnsrSta;
	//CanDataStruct.BCM_RVMSw = (uint8_t)p.BCM_RVMSw;
	//CanDataStruct.BCM_GearPosPSta = (uint8_t)p.BCM_GearPosPSta;
	//CanDataStruct.BCM_SunRoofOpnSta = (uint8_t)p.BCM_SunRoofOpnSta;
}

void CanFrameTimeoutFunc_0x422(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x425(uint8_t *data)
{
 //   SMK_04_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SMK_04_200ms_));
 //   
	//CanDataStruct.SMK_Crc4Val = (uint8_t)p.SMK_Crc4Val;
	//CanDataStruct.SMK_AlvCnt4Val = (uint8_t)p.SMK_AlvCnt4Val;
	//CanDataStruct.Warn_StrtStpBtnWrngSta = (uint8_t)p.Warn_StrtStpBtnWrngSta;
	//CanDataStruct.Warn_DeActvWrngSta = (uint8_t)p.Warn_DeActvWrngSta;
	//CanDataStruct.Warn_ExtrnlBuzWrngSta = (uint8_t)p.Warn_ExtrnlBuzWrngSta;
 //   
	//CanDataStruct.Warn_GearPosPWrngReq = (uint8_t)p.Warn_GearPosPWrngReq;
	//CanDataStruct.Warn_IdOutWrngSta = (uint8_t)p.Warn_IdOutWrngSta;
	//CanDataStruct.Warn_KeyBattLoWrngSta = (uint8_t)p.Warn_KeyBattLoWrngSta;
	//CanDataStruct.Warn_KeyOutLmpOnReq = (uint8_t)p.Warn_KeyOutLmpOnReq;
	//CanDataStruct.Warn_NotGearPosPWrngSta = (uint8_t)p.Warn_NotGearPosPWrngSta;
	//CanDataStruct.Warn_EsclFlWrngSta = (uint8_t)p.Warn_EsclFlWrngSta;
	//CanDataStruct.Warn_EsclNotLkWrngSta = (uint8_t)p.Warn_EsclNotLkWrngSta;
	//CanDataStruct.Warn_EsclNotUnLkWrngSta = (uint8_t)p.Warn_EsclNotUnLkWrngSta;
	//CanDataStruct.Warn_ImmoLmpOnReq = (uint8_t)p.Warn_ImmoLmpOnReq;
}

void CanFrameTimeoutFunc_0x425(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x432(uint8_t *data)
{
 //   BCM_11_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_11_200ms_));
 //   
	//CanDataStruct.BCM_Crc11Val = (uint8_t)p.BCM_Crc11Val;
	//CanDataStruct.USM_UipSta = (uint8_t)p.USM_UipSta;
	//CanDataStruct.BCM_AlvCnt11Val = (uint8_t)p.BCM_AlvCnt11Val;
	//CanDataStruct.USM_EscrtHdLmpSta = (uint8_t)p.USM_EscrtHdLmpSta;
	//CanDataStruct.USM_ArmBzrSta = (uint8_t)p.USM_ArmBzrSta;
	//CanDataStruct.USM_WlcmMirLtSystTitleOpt = (uint8_t)p.USM_WlcmMirLtSystTitleOpt;
	//CanDataStruct.USM_UnlockWlcmSta = (uint8_t)p.USM_UnlockWlcmSta;
	//CanDataStruct.USM_SmrtWlcmSta = (uint8_t)p.USM_SmrtWlcmSta;
	//CanDataStruct.USM_RrWiperByGearPosRSta = (uint8_t)p.USM_RrWiperByGearPosRSta;
	//CanDataStruct.USM_RrStRmndSta = (uint8_t)p.USM_RrStRmndSta;
	//CanDataStruct.USM_PDWAutoOnSta = (uint8_t)p.USM_PDWAutoOnSta;
}

void CanFrameTimeoutFunc_0x432(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x434(uint8_t *data)
{
 //   IAU_16_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(IAU_16_200ms_));
 //   
	//CanDataStruct.IAU_DigitalKeyOpt = (uint8_t)p.IAU_DigitalKeyOpt;
	//CanDataStruct.IAU_ProfileIDParingRVal = (uint8_t)p.IAU_ProfileIDParingRVal;
	//CanDataStruct.IAU_ProfileIDRVal = (uint8_t)p.IAU_ProfileIDRVal;
	//CanDataStruct.IAU_ISKLearnState = (uint8_t)p.IAU_ISKLearnState;
	//CanDataStruct.IAU_DigitalKeyProcessingSta = (uint8_t)p.IAU_DigitalKeyProcessingSta;
	//CanDataStruct.IAU_DigitalKeyExit = (uint8_t)p.IAU_DigitalKeyExit;
	//CanDataStruct.IAU_DigitalKeyEnblRVal = (uint8_t)p.IAU_DigitalKeyEnblRVal;
	//CanDataStruct.IAU_OwnerPhnRegRVal = (uint8_t)p.IAU_OwnerPhnRegRVal;
	//CanDataStruct.IAU_NFCCard1RegRVal = (uint8_t)p.IAU_NFCCard1RegRVal;
	//CanDataStruct.IAU_RdyToSendAuthDataSta = (uint8_t)p.IAU_RdyToSendAuthDataSta;
	//CanDataStruct.IAU_OptTyp = (uint8_t)p.IAU_OptTyp;
	//CanDataStruct.IAU_NFCKeyReminder = (uint8_t)p.IAU_NFCKeyReminder;
	//CanDataStruct.IAU_NFCDeactivation = (uint8_t)p.IAU_NFCDeactivation;
	//CanDataStruct.IAU_DISPWrng = (uint8_t)p.IAU_DISPWrng;
	//CanDataStruct.IAU_ConStat = (uint8_t)p.IAU_ConStat;
	//CanDataStruct.IAU_LftDrHndLockDetected = (uint8_t)p.IAU_LftDrHndLockDetected;
	//CanDataStruct.IAU_LftDrHndUnlockDetected = (uint8_t)p.IAU_LftDrHndUnlockDetected;
	//CanDataStruct.IAU_RtDrHndLockDetected = (uint8_t)p.IAU_RtDrHndLockDetected;
	//CanDataStruct.IAU_RtDrHndUnlockDetected = (uint8_t)p.IAU_RtDrHndUnlockDetected;
}

void CanFrameTimeoutFunc_0x434(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x437(uint8_t *data)
{
 //   CTM_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(CTM_01_200ms_));
 //   
	//CanDataStruct.CTM_TrailerAct = (uint8_t)p.CTM_TrailerAct;
	//CanDataStruct.CTM_RearfogAct = (uint8_t)p.CTM_RearfogAct;
	//CanDataStruct.CTM_StpLmpOpnSta = (uint8_t)p.CTM_StpLmpOpnSta;
	//CanDataStruct.CTM_TrnSigLmpLftOpnSta = (uint8_t)p.CTM_TrnSigLmpLftOpnSta;
	//CanDataStruct.CTM_TrnSigLmpRtOpnSta = (uint8_t)p.CTM_TrnSigLmpRtOpnSta;
	//CanDataStruct.CTM_ExtTailLmpLftOpnSta = (uint8_t)p.CTM_ExtTailLmpLftOpnSta;
	//CanDataStruct.CTM_ExtTailLmpRtOpnSta = (uint8_t)p.CTM_ExtTailLmpRtOpnSta;
}

void CanFrameTimeoutFunc_0x437(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x442(uint8_t *data)
{
 //   BCM_12_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(BCM_12_200ms_));
 //   
	//CanDataStruct.BCM_Crc12Val = (uint8_t)p.BCM_Crc12Val;
	//CanDataStruct.BCM_AlvCnt12Val = (uint8_t)p.BCM_AlvCnt12Val;
	//CanDataStruct.BCM_CntryConfgTyp = (uint8_t)p.BCM_CntryConfgTyp;
	//CanDataStruct.BCM_BodyOptTyp = (uint8_t)p.BCM_BodyOptTyp;
	//CanDataStruct.BCM_SmkOptTyp = (uint8_t)p.BCM_SmkOptTyp;
	//CanDataStruct.BCM_SunRoofOptTyp = (uint8_t)p.BCM_SunRoofOptTyp;
	//CanDataStruct.BCM_SafetyWdwOptTyp = (uint8_t)p.BCM_SafetyWdwOptTyp;
	//CanDataStruct.Window_DrvrSdWdwSta_BCM = (uint8_t)p.Window_DrvrSdWdwSta_BCM;
	//CanDataStruct.Window_AsstSdWdwSta_BCM = (uint8_t)p.Window_AsstSdWdwSta_BCM;
	//CanDataStruct.Window_RrLftWdwSta_BCM = (uint8_t)p.Window_RrLftWdwSta_BCM;
	//CanDataStruct.Window_RrRtWdwSta_BCM = (uint8_t)p.Window_RrRtWdwSta_BCM;
 //   CanDataStruct.PHEV_FuelDrDis = (uint8_t)p.PHEV_FuelDrDis;
	//CanDataStruct.SunRoof_GlassPosSta = (uint8_t)p.SunRoof_GlassPosSta;
	//CanDataStruct.SunRoof_BlindPosSta = (uint8_t)p.SunRoof_BlindPosSta;
	//CanDataStruct.Mirror_OSMirFldDis_BCM = (uint8_t)p.Mirror_OSMirFldDis_BCM;
	//CanDataStruct.SunRoof_GlassErrSta = (uint8_t)p.SunRoof_GlassErrSta;
	//CanDataStruct.SunRoof_BlindErrSta = (uint8_t)p.SunRoof_BlindErrSta;
}

void CanFrameTimeoutFunc_0x442(uint8_t Lv)
{
}

void CanFrameAnlysisFunc_0x444(uint8_t *data)
{
 //   SMK_02_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SMK_02_200ms_));
 //   
	//CanDataStruct.SMK_Crc2Val = (uint8_t)p.SMK_Crc2Val;
	//CanDataStruct.SMK_AlvCnt2Val = (uint8_t)p.SMK_AlvCnt2Val;
	//CanDataStruct.SSB_StrtStpBtnSw1Sta = (uint8_t)p.SSB_StrtStpBtnSw1Sta;
	//CanDataStruct.SSB_StrtStpBtnSw2Sta = (uint8_t)p.SSB_StrtStpBtnSw2Sta;
	//CanDataStruct.SMK_TrmnlCtrlSta = (uint8_t)p.SMK_TrmnlCtrlSta;
	//CanDataStruct.SMK_TrmnlMngrSta = (uint8_t)p.SMK_TrmnlMngrSta;
	//CanDataStruct.SMK_AuthSta = (uint8_t)p.SMK_AuthSta;
	//CanDataStruct.SMK_Ign1InSta = (uint8_t)p.SMK_Ign1InSta;
	//CanDataStruct.SMK_Ign1RlySta = (uint8_t)p.SMK_Ign1RlySta;
	//CanDataStruct.SMK_Ign2InSta = (uint8_t)p.SMK_Ign2InSta;
	//CanDataStruct.SMK_Ign2RlySta = (uint8_t)p.SMK_Ign2RlySta;
	//CanDataStruct.SMK_StrtFdbckSta = (uint8_t)p.SMK_StrtFdbckSta;
	//CanDataStruct.SMK_StrtrRlyOutSta = (uint8_t)p.SMK_StrtrRlyOutSta;
	//CanDataStruct.SMK_AccInSta = (uint8_t)p.SMK_AccInSta;
	//CanDataStruct.SMK_AccRlySta = (uint8_t)p.SMK_AccRlySta;
	//CanDataStruct.SMK_CLUAccIndOnReq = (uint8_t)p.SMK_CLUAccIndOnReq;
	//CanDataStruct.SMK_TlEngRunSta = (uint8_t)p.SMK_TlEngRunSta;
	//CanDataStruct.SMK_TlCrnkModSta = (uint8_t)p.SMK_TlCrnkModSta;
	//CanDataStruct.SMK_RmtKeyEngRunSta = (uint8_t)p.SMK_RmtKeyEngRunSta;
	//CanDataStruct.SMK_RmtKeyCrnkModSta = (uint8_t)p.SMK_RmtKeyCrnkModSta;
}

void CanFrameTimeoutFunc_0x444(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x445(uint8_t *data)
{
 //   SMK_06_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SMK_06_200ms_));
 //   
	//CanDataStruct.SMK_Crc6Val = (uint8_t)p.SMK_Crc6Val;
	//CanDataStruct.SMK_AlvCnt6Val = (uint8_t)p.SMK_AlvCnt6Val;
	//CanDataStruct.Lamp_HzrdBlnkngSta = (uint8_t)p.Lamp_HzrdBlnkngSta;
	//CanDataStruct.RSPA_LearntSta = (uint8_t)p.RSPA_LearntSta;
	//CanDataStruct.Lamp_SmrtWlcmLtOnReq = (uint8_t)p.Lamp_SmrtWlcmLtOnReq;
	//CanDataStruct.Fob_BattStaInfo = (uint8_t)p.Fob_BattStaInfo;
	//CanDataStruct.Fob_FoundDrvWlcmArea = (uint8_t)p.Fob_FoundDrvWlcmArea;
	//CanDataStruct.Fob_FoundAsstWlcmArea = (uint8_t)p.Fob_FoundAsstWlcmArea;
	//CanDataStruct.Fob_FoundExtrnlArea = (uint8_t)p.Fob_FoundExtrnlArea;
	//CanDataStruct.Fob_FoundIntArea = (uint8_t)p.Fob_FoundIntArea;
	//CanDataStruct.Fob_LearntSta = (uint8_t)p.Fob_LearntSta;
	//CanDataStruct.RSPA_RFSigErrSta = (uint8_t)p.RSPA_RFSigErrSta;
	//CanDataStruct.RSPA_CanErrSta = (uint8_t)p.RSPA_CanErrSta;
	//CanDataStruct.LFAnt_FltSta = (uint8_t)p.LFAnt_FltSta;
	//CanDataStruct.LFAnt_SrchSta = (uint8_t)p.LFAnt_SrchSta;
	//CanDataStruct.Auth_ISKLearnSta = (uint8_t)p.Auth_ISKLearnSta;
	//CanDataStruct.RSPA_ModSta_SMK = (uint8_t)p.RSPA_ModSta_SMK;
	//CanDataStruct.RSPA_FobBattSta = (uint8_t)p.RSPA_FobBattSta;
	//CanDataStruct.Fob_BtnReleasedSta = (uint8_t)p.Fob_BtnReleasedSta;
	//CanDataStruct.USM_SmrtTrnkTlgtModSta = (uint8_t)p.USM_SmrtTrnkTlgtModSta;
}

void CanFrameTimeoutFunc_0x445(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x44B(uint8_t *data)
{
 //   WPC_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(WPC_01_200ms_));
 //   
	//CanDataStruct.USM_CmdWPCSta = (uint8_t)p.USM_CmdWPCSta;
	//CanDataStruct.WPC_PhnLftWrngSta = (uint8_t)p.WPC_PhnLftWrngSta;
	//CanDataStruct.WPC_SWVerMajor1 = (uint8_t)p.WPC_SWVerMajor1;
	//CanDataStruct.WPC_SWVerMinor1 = (uint8_t)p.WPC_SWVerMinor1;
	//CanDataStruct.WPC_SWVerMinor2 = (uint8_t)p.WPC_SWVerMinor2;
}

void CanFrameTimeoutFunc_0x44B(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x455(uint8_t *data)
{
 //   MLM_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(MLM_01_200ms_));
 //   
	//CanDataStruct.MLM_MdLmpBrgtnsVal = (uint8_t)p.MLM_MdLmpBrgtnsVal;
	//CanDataStruct.MLM_MdLmpDrvngVal = (uint8_t)p.MLM_MdLmpDrvngVal;
	//CanDataStruct.MLM_MdLmpClrVal = (uint8_t)p.MLM_MdLmpClrVal;
	//CanDataStruct.MLM_MdLmpRedVal = (uint16_t)p.MLM_MdLmpRedVal;
	//CanDataStruct.MLM_MdLmpGreenVal = (uint16_t)p.MLM_MdLmpGreenVal;
	//CanDataStruct.MLM_MdLmpBlueVal = (uint16_t)p.MLM_MdLmpBlueVal;
	//CanDataStruct.MLM_MdLmpDrvngModRValue = (uint8_t)p.MLM_MdLmpDrvngModRValue;
}

void CanFrameTimeoutFunc_0x455(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x476(uint8_t *data)
{
 //   SVM_01_600ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SVM_01_600ms_));
 //   
	//CanDataStruct.BVM_ViewSta = (uint8_t)p.BVM_ViewSta;
	//CanDataStruct.SVM_TopViewInfoA = (uint8_t)p.SVM_TopViewInfoA;
	//CanDataStruct.SVM_TopViewInfoB = (uint8_t)p.SVM_TopViewInfoB;
	//CanDataStruct.SVM_TopViewInfoC = (uint8_t)p.SVM_TopViewInfoC;
	//CanDataStruct.SVM_TopViewInfoD = (uint8_t)p.SVM_TopViewInfoD;
}

void CanFrameTimeoutFunc_0x476(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x477(uint8_t *data)
{
 //   SVM_02_600ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SVM_02_600ms_));
 //   
	//CanDataStruct.SVM_ViewSta = (uint8_t)p.SVM_ViewSta;
	//CanDataStruct.SVM_TopViewDefSta = (uint8_t)p.SVM_TopViewDefSta;
	//CanDataStruct.SVM_MsgSta = (uint8_t)p.SVM_MsgSta;
	//CanDataStruct.BVM_OptSta = (uint8_t)p.BVM_OptSta;
	//CanDataStruct.SVM_TopviewGdLnSta = (uint8_t)p.SVM_TopviewGdLnSta;
	//CanDataStruct.SVM_GdLnSta = (uint8_t)p.SVM_GdLnSta;
	//CanDataStruct.SVM_Btn_Sta = (uint8_t)p.SVM_Btn_Sta;
	//CanDataStruct.SVM_AutoOnSta = (uint8_t)p.SVM_AutoOnSta;
	//CanDataStruct.SVM_RrViewDefSta = (uint8_t)p.SVM_RrViewDefSta;
	//CanDataStruct.SVM_FrViewDefSta = (uint8_t)p.SVM_FrViewDefSta;
	//CanDataStruct.SVM_Ver_Typ = (uint16_t)p.SVM_Ver_Typ;
}

void CanFrameTimeoutFunc_0x477(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x488(uint8_t *data)
{
 //   IBU_MFSW_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(IBU_MFSW_01_200ms_));
 //   
	//CanDataStruct.IBU_MFSW_Crc1Val = (uint8_t)p.IBU_MFSW_Crc1Val;
	//CanDataStruct.IBU_MFSW_AlvCnt1Val = (uint8_t)p.IBU_MFSW_AlvCnt1Val;
	//CanDataStruct.Lamp_FrFogLmpSwSta_IBU = (uint8_t)p.Lamp_FrFogLmpSwSta_IBU;
	//CanDataStruct.Lamp_HdLmpHiSwSta_IBU = (uint8_t)p.Lamp_HdLmpHiSwSta_IBU;
	//CanDataStruct.Lamp_LtSwSta_IBU = (uint8_t)p.Lamp_LtSwSta_IBU;
	//CanDataStruct.Lamp_PassingLmpSwSta_IBU = (uint8_t)p.Lamp_PassingLmpSwSta_IBU;
	//CanDataStruct.Lamp_RrFogLmpSwSta_IBU = (uint8_t)p.Lamp_RrFogLmpSwSta_IBU;
}

void CanFrameTimeoutFunc_0x488(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x489(uint8_t *data)
{
 //   IBU_MFSW_02_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(IBU_MFSW_02_200ms_));
 //   
	//CanDataStruct.IBU_MFSW_Crc2Val = (uint8_t)p.IBU_MFSW_Crc2Val;
	//CanDataStruct.IBU_MFSW_AlvCnt2Val = (uint8_t)p.IBU_MFSW_AlvCnt2Val;
	//CanDataStruct.Wiper_FrWiperSwSta_IBU = (uint8_t)p.Wiper_FrWiperSwSta_IBU;
	//CanDataStruct.Wiper_IntStepSta_IBU = (uint8_t)p.Wiper_IntStepSta_IBU;
	//CanDataStruct.Wiper_MstSwSta_IBU = (uint8_t)p.Wiper_MstSwSta_IBU;
	//CanDataStruct.Wiper_RrWiperSwSta_IBU = (uint8_t)p.Wiper_RrWiperSwSta_IBU;
	//CanDataStruct.Wiper_FrWiperWshSwSta_IBU = (uint8_t)p.Wiper_FrWiperWshSwSta_IBU;
	//CanDataStruct.Wiper_RrWiperWshSwSta_IBU = (uint8_t)p.Wiper_RrWiperWshSwSta_IBU;
}

void CanFrameTimeoutFunc_0x489(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x48F(uint8_t *data)
{
 //   ICU_11_1000ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(ICU_11_1000ms_));
 //   
	//CanDataStruct.ICU_Crc11Val = (uint8_t)p.ICU_Crc11Val;
	//CanDataStruct.Bat_dischrg = (uint8_t)p.Bat_dischrg;
	//CanDataStruct.ICU_AlvCnt11Val = (uint8_t)p.ICU_AlvCnt11Val;
	//CanDataStruct.Batt_SoCWarningValue = (uint8_t)p.Batt_SoCWarningValue;
	//CanDataStruct.C_StrgWhlHeatingOpt = (uint8_t)p.C_StrgWhlHeatingOpt;
}

void CanFrameTimeoutFunc_0x48F(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x4CB(uint8_t *data)
{
 //   PSM_01_00ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(PSM_01_00ms_));
 //   
	//CanDataStruct.DrvIMS_MemoryP1Req = (uint8_t)p.DrvIMS_MemoryP1Req;
	//CanDataStruct.DrvIMS_MemoryP2Req = (uint8_t)p.DrvIMS_MemoryP2Req;
	//CanDataStruct.DrvIMS_MemorySetEnaSta = (uint8_t)p.DrvIMS_MemorySetEnaSta;
	//CanDataStruct.DrvIMS_PlyBckP1Req = (uint8_t)p.DrvIMS_PlyBckP1Req;
	//CanDataStruct.DrvIMS_PlyBckP2Req = (uint8_t)p.DrvIMS_PlyBckP2Req;
	//CanDataStruct.DrvIMS_PlyBckStpReq = (uint8_t)p.DrvIMS_PlyBckStpReq;
	//CanDataStruct.DrvIMS_BzrReq = (uint8_t)p.DrvIMS_BzrReq;
	//CanDataStruct.DrvIMS_ErrConWmgDis = (uint8_t)p.DrvIMS_ErrConWmgDis;
}

void CanFrameTimeoutFunc_0x4CB(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x4CF(uint8_t *data)
{
 //   IFS_01_200ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(IFS_01_200ms_));
 //   
	//CanDataStruct.CF_IFS_TrfChgStat = (uint8_t)p.CF_IFS_TrfChgStat;
	//CanDataStruct.CF_IFS_Opt = (uint8_t)p.CF_IFS_Opt;
	//CanDataStruct.CF_IFS_Lamp = (uint8_t)p.CF_IFS_Lamp;
	//CanDataStruct.CF_IFS_SysState = (uint8_t)p.CF_IFS_SysState;
	//CanDataStruct.CF_IFS_Warning = (uint8_t)p.CF_IFS_Warning;
	//CanDataStruct.CF_IFS_TrfchgStat_USM = (uint8_t)p.CF_IFS_TrfchgStat_USM;
	//CanDataStruct.CF_IFSActVehSpd_State = (uint8_t)p.CF_IFSActVehSpd_State;
}

void CanFrameTimeoutFunc_0x4CF(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x4E4(uint8_t *data)
{
 //   RKE_01_00ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(RKE_01_00ms_));
 //   
	//CanDataStruct.RKE_Crc1Val = (uint8_t)p.RKE_Crc1Val;
	//CanDataStruct.RKE_AlvCnt1Val = (uint8_t)p.RKE_AlvCnt1Val;
	//CanDataStruct.RKE_BtnReq = (uint8_t)p.RKE_BtnReq;
	//CanDataStruct.RKE_WdwUpDnReq = (uint8_t)p.RKE_WdwUpDnReq;
	//CanDataStruct.RKE_TrnkTlgtBtnReq = (uint8_t)p.RKE_TrnkTlgtBtnReq;
	//CanDataStruct.RKE_ID = (uint8_t)p.RKE_ID;
}

void CanFrameTimeoutFunc_0x4E4(uint8_t Lv)
{

}

void CanFrameAnlysisFunc_0x4E5(uint8_t *data)
{
 //   SMK_01_00ms_ p = {0};
 //   memcpy((void*)&p.Data[0], data, sizeof(SMK_01_00ms_));
 //   
	//CanDataStruct.SMK_Crc1Val = (uint8_t)p.SMK_Crc1Val;
	//CanDataStruct.SMK_AlvCnt1Val = (uint8_t)p.SMK_AlvCnt1Val;
	//CanDataStruct.DoorLock_PsvDrLkReq = (uint8_t)p.DoorLock_PsvDrLkReq;
	//CanDataStruct.DoorLock_PsvDrUnLkReq = (uint8_t)p.DoorLock_PsvDrUnLkReq;
	//CanDataStruct.DoorLock_DrvDrPsvAcsReq = (uint8_t)p.DoorLock_DrvDrPsvAcsReq;
	//CanDataStruct.DoorLock_AsstDrPsvAcsReq = (uint8_t)p.DoorLock_AsstDrPsvAcsReq;
	//CanDataStruct.DoorLock_TrnkTlgtPsvAcsReq = (uint8_t)p.DoorLock_TrnkTlgtPsvAcsReq;
	//CanDataStruct.Auth_Req = (uint8_t)p.Auth_Req;
	//CanDataStruct.RSPA_DigitalKeyAuth = (uint8_t)p.RSPA_DigitalKeyAuth;
	//CanDataStruct.Auth_Method = (uint8_t)p.Auth_Method;
	//CanDataStruct.RSPA_CanTmotFlagSta = (uint8_t)p.RSPA_CanTmotFlagSta;
	//CanDataStruct.Auth_ISKLearnFdbck = (uint8_t)p.Auth_ISKLearnFdbck;
	//CanDataStruct.Mirror_SmrtWlcmMirrReq = (uint8_t)p.Mirror_SmrtWlcmMirrReq;
	//CanDataStruct.SecureCom_Req = (uint8_t)p.SecureCom_Req;
}

void CanFrameTimeoutFunc_0x4E5(uint8_t Lv)
{

}





/*-----------------------------NQ5_Fuel_HSCan_DB_NO.1-------------------------*/
void CanFrameAnlysisFunc_0x180(uint8_t data[])
{
    CLU_17_20ms_ p = {0};
    memcpy((void*)&p.Data[0], data, sizeof(CLU_17_20ms_));
    
    CLU_17_20ms.CLU_Crc17Val = (uint8_t)p.CLU_Crc17Val;
    CLU_17_20ms.CLU_AlvCnt17Val = (uint8_t)p.CLU_AlvCnt17Val;
    CLU_17_20ms.CLU_PddlUpSwSta = (uint8_t)p.CLU_PddlUpSwSta;
    CLU_17_20ms.CLU_PddlDnSwSta = (uint8_t)p.CLU_PddlDnSwSta;

}
void CanFrameTimeoutFunc_0x180(uint8_t Lv)
{
    


}


void CanFrameAnlysisFunc_0x1AA(uint8_t data[])
{
    CLU_01_20ms_ p = {0};
    memcpy((void*)&p.Data[0], data, sizeof(CLU_01_20ms_));
    
    CLU_01_20ms.CLU_Crc1Val = p.CLU_Crc1Val;
	CLU_01_20ms.CLU_AlvCnt1Val = p.CLU_AlvCnt1Val;
	CLU_01_20ms.CLU_PrtyBitSta = p.CLU_PrtyBitSta;
	CLU_01_20ms.CLU_DtntOutSta = p.CLU_DtntOutSta;
	CLU_01_20ms.CLU_SpdUnitTyp = p.CLU_SpdUnitTyp;
	CLU_01_20ms.CLU_DisSpdDcmlVal = p.CLU_DisSpdDcmlVal;
	CLU_01_20ms.CLU_SWRCCrsMainSwSta = p.CLU_SWRCCrsMainSwSta;
	CLU_01_20ms.CLU_SWRCCrsSwSta = p.CLU_SWRCCrsSwSta;
	CLU_01_20ms.CLU_SWRCLFASwSta = p.CLU_SWRCLFASwSta;
	CLU_01_20ms.CLU_SWRCSldMainSwSta = p.CLU_SWRCSldMainSwSta;
	CLU_01_20ms.CLU_RhstaLvlSta = p.CLU_RhstaLvlSta;
	CLU_01_20ms.CLU_DisSpdVal = p.CLU_DisSpdVal;
	CLU_01_20ms.CLU_DisTyp = p.CLU_DisTyp;
	CLU_01_20ms.CLU_OKSwSta = p.CLU_OKSwSta;
	CLU_01_20ms.CLU_DisSpdVal_KPH = p.CLU_DisSpdVal_KPH;
}

void CanFrameTimeoutFunc_0x1AA(uint8_t Lv)
{

}


void CanFrameAnlysisFunc_0x636(uint8_t data[])
{
    //SOUND_TEST_ p = {0};
    //memcpy((void*)&p.Data[0], data, sizeof(SOUND_TEST_));
    //
    //CanDataStruct.CH1_Phrase = (uint8_t)p.CH1_Phrase;
    //CanDataStruct.CH2_Phrase = (uint8_t)p.CH2_Phrase;
    //CanDataStruct.CH3_Phrase = (uint8_t)p.CH3_Phrase;
    //CanDataStruct.CH4_Phrase = (uint8_t)p.CH4_Phrase;
    //CanDataStruct.CH1_Volume = (uint8_t)p.CH1_Volume;
    //CanDataStruct.CH2_Volume = (uint8_t)p.CH2_Volume;
    //CanDataStruct.CH3_Volume = (uint8_t)p.CH3_Volume;
    //CanDataStruct.CH4_Volume = (uint8_t)p.CH4_Volume;
}

void CanFrameTimeoutFunc_0x636(uint8_t Lv)
{
    //CanDataStruct.CH1_Phrase = 0;
    //CanDataStruct.CH2_Phrase = 0;
    //CanDataStruct.CH3_Phrase = 0;
    //CanDataStruct.CH4_Phrase = 0;
    //CanDataStruct.CH1_Volume = 0;
    //CanDataStruct.CH2_Volume = 0;
    //CanDataStruct.CH3_Volume = 0;
    //CanDataStruct.CH4_Volume = 0;
}

#endif
