first commit

Application/BackLight.c

+#include "Backlight.h"
+#include "Components.h"
+Backlight_User_OPT3004_st_t opt3004;
+typedef struct
+{
+    Light_uint16_t Temperature; /* 温度 */
+    Light_uint16_t Resistance;  /* 阻值 */
+} _st_Backlight;
+
+typedef struct
+{
+    Light_uint16_t BacklightLevel; /* 背光等级 */
+    Light_uint16_t BacklightDuty;  /* 背光占空比 */
+} _st_BacklightLevel;
+#define AD_AVE_BUFF_LEN (5)
+
+typedef struct
+{
+    uint16_t Voltage;    // AD采集电压值
+    uint8_t  Degree;     //温度值
+} NTCStaticAttrStruct;
+
+//温度数组长度
+#define NTC_TEMP_ARRAY_LEN (11)
+/*** 温度升表格 ***/
+static const NTCStaticAttrStruct NTCStaticAttrs [ NTC_TEMP_ARRAY_LEN ] = {
+    {2312, 75},
+    {2359, 76},
+    {2405, 77},
+    {2452, 78},
+    {2498, 79},
+    {2544, 80},
+    {2589, 81},
+    {2634, 82},
+    {2679, 83},
+    {2724, 84},
+    {2770, 85},
+};
+
+#define Backlight_Max 10
+#define BacklightLevel_Max 5
+uint8_t NTCDegree;
+#define NTCDEGREE NTCDegree
+uint8_t Backlight_Cnt = 0;
+uint16_t NTC_Time_Count = 0u;
+uint8_t NTC_DstSeg = 0u;
+uint16_t NTC_Last = 0u;
+uint16_t Luminous_Time = 0u;
+uint32_t Luminous_Value_Pwm = 0u;
+uint16_t Luminous_Value_time = 0u;
+uint16_t Luminous_Value_Old = 0u;
+uint16_t Luminous_Value_Last = 0u;
+uint16_t Luminous_Value_recovery = 0u;
+
+Light_uint16_t GetBacklightDutyByLevel(Light_uint16_t level)
+{
+    return 0;
+}
+
+typedef void (*SetPwm)(Light_uint16_t Pwm);
+typedef Light_uint8_t (*SetPwmEnable)(void);
+typedef Light_uint8_t (*SetPwmLevel)(void);
+typedef Light_uint16_t (*NtcRes)(void);
+
+typedef struct
+{
+    SetPwm SetPwmCbk;           /* 设置PWM回调函数 */
+    SetPwmEnable SetPwmEnCbk;   /* 设置PWM使能回调函数 */
+    SetPwmLevel SetPwmLevelCbk; /* 背光等级回调函数 */
+    NtcRes NtcResCbk;           /* 获取电阻值回调函数 */
+} BackLightExtPara;
+
+typedef struct
+{
+    SetPwm SetPwmCbk;           /* 设置PWM回调函数 */
+    SetPwmEnable SetPwmEnCbk;   /* 设置PWM使能回调函数 */
+    SetPwmLevel SetPwmLevelCbk; /* 背光等级回调函数 */
+    NtcRes NtcResCbk;
+    Light_uint8_t BacklightEn;     /* 背光使能 */
+    Light_uint16_t BacklightPwm;   /* 背光PWM */
+    Light_uint16_t BacklightLevel; /* 背光等级 */
+} _Backlight_Op;
+
+_Backlight_Op Backlight_Operate;
+
+
+/* 设置PWM回调函数 */
+void Backlight_SetPwm(Light_uint16_t Pwm)
+{
+    // TimerM_PWM_set_duty(TIMERM_COUNTER1, TIMERM_CHB, Pwm);
+}
+/*背光控制函数，此函数需放在50ms调用*/
+void Backlight_SetPwm_cotrol(void)
+{
+    uint32_t Luminous_Value = 0u;
+    uint32_t NTC_Value = 0u;
+    uint16_t NTC_Valid = 0u;
+    OPT3004_Read_Result(&opt3004.u32Result);
+    NTC_Value = ADC_Read_Signal(ADC_CH_NTC);
+    Luminous_Value = opt3004.u32Result / 10u;//获取光感值
+    Luminous_Value_recovery = Luminous_Value;
+    if(GetLcdInitSt() == 1)//630初始化
+    {
+        if(Luminous_Time <= 200u)
+        {
+            Luminous_Time += 50u;
+        }
+        else
+        {
+            if (Backlight_Cnt == 0) // 背光初始化
+            {
+                Backlight_Cnt = 1;
+                TimerM_PWM_counter_Output_Init(TIMERM_COUNTER1, 20000u, 64000000u);
+                TimerM_PWM_CH_Output_init(TIMERM_COUNTER1, TIMERM_CHB, ActiveLevel_Low);
+            }
+            if (Common_Get_IG_Sts() == COMMON_POWER_ON)
+            {
+                if ((Get_Uptime_Staus() == 0u) || (Get_Self() == 1u))
+                {
+                    TimerM_PWM_set_duty(TIMERM_COUNTER1, TIMERM_CHB, 300u); // 背光控制
+                }
+                else
+                {
+                    if (Luminous_Value <= 300)
+                    {
+                        Luminous_Value_Old = 1u;
+                    }
+                    else if ((Luminous_Value <= 400))
+                    {
+                        Luminous_Value_Old = 2u;
+                    }
+                    else if ((Luminous_Value <= 600))
+                    {
+                        Luminous_Value_Old = 3u;
+                    }
+                    else if ((Luminous_Value <= 700))
+                    {
+                        Luminous_Value_Old = 4u;
+                    }
+                    else
+                    {
+                        Luminous_Value_Old = 5u;
+                    }
+                    if (Luminous_Value_Last == Luminous_Value_Old) // 持续3s维持同一光感值
+                    {
+                        if (Luminous_Value_time < 60u)
+                        {
+                            Luminous_Value_time++;
+                        }
+                        else
+                        {
+                            Luminous_Value_Pwm = Luminous_Value_Last;
+                        }
+                    }
+                    else
+                    {
+                        Luminous_Value_Last = Luminous_Value_Old;
+                        Luminous_Value_time = 0u;
+                    }
+                    if (Luminous_Value_Pwm == 1u) // 根据光感输出背光
+                    {
+                        Luminous_Value_Pwm = 800u;
+                    }
+                    else if (Luminous_Value_Pwm == 2u)
+                    {
+                        Luminous_Value_Pwm = 700u;
+                    }
+                    else if (Luminous_Value_Pwm == 3u)
+                    {
+                        Luminous_Value_Pwm = 600u;
+                    }
+                    else if (Luminous_Value_Pwm == 4u)
+                    {
+                        Luminous_Value_Pwm = 500u;
+                    }
+                    else if (Luminous_Value_Pwm == 5u)
+                    {
+                        Luminous_Value_Pwm = 300u;
+                    }
+                /*NTC控制背光，优先级高于光感*/
+                if (NTCDegree < 75)
+                {
+                }
+                else if ((NTCDegree <= 80))
+                {
+                  Luminous_Value_Pwm = ( 1000u - ((1000u - Luminous_Value_Pwm) * 8u / 10u )); 
+                  Luminous_Value_time = 60u;
+                }
+                else if ((NTCDegree <= 85))
+                {
+                  Luminous_Value_Pwm = ( 1000u - (( 1000u - Luminous_Value_Pwm) * 7u / 10u ));
+                  Luminous_Value_time = 60u;
+                }
+                else
+                {
+                  Luminous_Value_Pwm = ( 1000u - (( 1000u - Luminous_Value_Pwm) * 2u / 10u ));
+                  Luminous_Value_time = 60u;
+                }
+                TimerM_PWM_set_duty(TIMERM_COUNTER1, TIMERM_CHB, Luminous_Value_Pwm); // 背光控制
+                }
+
+            }
+            else
+            {
+                TimerM_PWM_set_duty(TIMERM_COUNTER1, TIMERM_CHB, 0u); // 下15电置零
+                Luminous_Value_time = 60u;
+                Luminous_Value = 0u;
+                Luminous_Value_Old = 0u;
+                Luminous_Value_Last = 0u;
+                Backlight_Cnt = 0;
+                Luminous_Time = 0;
+                NTCDegree = 0u;
+            }
+        }
+    }
+}
+/* 设置PWM使能回调函数 */
+Light_uint8_t Backlight_SetPwmEn(void)
+{
+    
+    return 1;
+}
+
+/* 背光等级回调函数 */
+Light_uint8_t Backlight_SetPwmLevel(void)
+{
+
+    return 1;
+}
+
+/* 获取电阻值回调函数 */
+Light_uint8_t Backlight_NtcRes(void)
+{
+
+    return 1;
+}
+
+void Backlight_Init(BackLightExtPara *backlightInit)
+{
+    Backlight_Operate.SetPwmCbk = backlightInit->SetPwmCbk;
+    Backlight_Operate.SetPwmEnCbk = backlightInit->SetPwmEnCbk;
+    Backlight_Operate.SetPwmLevelCbk = backlightInit->SetPwmLevelCbk;
+    Backlight_Operate.NtcResCbk = backlightInit->NtcResCbk;
+}
+
+void Backlight_KL30_Wakeup_Init(void)
+{
+    Backlight_Cnt = 0;
+    Luminous_Time = 0u;
+    Luminous_Value_time = 60u;
+    Luminous_Value_Old = 0u;
+    Luminous_Value_Last = 0u;
+    Luminous_Value_recovery = 0u;
+    NTC_Time_Count = 0u;
+    NTC_DstSeg = 0u;
+    NTC_Last = 0u;
+    NTCDegree = 0u;
+}
+
+
+
+/**
+ * 根据给定的背光表和输入电阻值，获取对应的温度值。
+ * 这个函数通过线性插值方法在背光表中查找与输入电阻最接近的温度值。
+ * @param backlightTable 背光表，包含电阻和对应温度的数组。
+ * @param size 背光表的大小，即数组的元素个数。
+ * @param input 输入的电阻值。
+ * @return 返回对应的温度值。
+ */
+Light_uint16_t Get_Ntc_Temp(_st_Backlight *backlightTable, Light_uint8_t size, Light_uint16_t input)
+{
+    Light_uint16_t result = 0;
+    Light_uint32_t temp = 0;
+    Light_uint8_t i = 0;
+
+    if (input >= backlightTable[0].Resistance)
+    {
+        result = backlightTable[0].Temperature;
+    }
+    else if (input <= backlightTable[size - 1].Resistance)
+    {
+        result = backlightTable[size - 1].Temperature;
+    }
+    else
+    {
+        for (i = 0; i < size - 1; i++)
+        {
+            if ((input < backlightTable[i].Resistance) && (input >= backlightTable[i + 1].Resistance))
+            {
+                temp = backlightTable[i + 1].Temperature - backlightTable[i].Temperature;
+                temp *= (backlightTable[i].Resistance - input);
+                temp /= (backlightTable[i].Resistance - backlightTable[i + 1].Resistance);
+                temp += backlightTable[i].Temperature;
+                result = (Light_uint16_t)temp;
+                break;
+            }
+        }
+    }
+
+    return result;
+}
+
+Light_uint16_t Get_Pwm_Factor_Optimized(Light_uint16_t CurrentTemp)
+{
+}
+
+typedef struct
+{
+    Light_uint8_t destFactor;
+    Light_uint8_t curFactor;
+    Light_uint16_t NtcDelayTimer;
+    Light_uint16_t u16DialcurDuty;
+    Light_uint16_t u16DialdestDuty;
+    Light_uint16_t u16DialDampingTimer;
+} _st_BacklightFactor_Ctrl;
+
+_st_BacklightFactor_Ctrl BacklightFactorCtrl;
+
+/**
+ * @brief 实现数据的渐变效果
+ * 该函数用于更新当前值，使其逐渐接近目标值，渐变的步长由step参数控制。同时，通过timer参数来实现一定的延迟效果，
+ * 仅当计时器达到或超过预设的timedelay时，才会进行一次渐变操作。这有助于平滑数据的变化，避免突变。
+ * @param cur 当前值的指针，函数将更新这个值
+ * @param dest 目标值，当前值将逐渐变化到这个值
+ * @param step 每次变化的步长
+ * @param timer 计时器的指针，用于实现变化的延迟
+ * @param timedelay 延迟的时间阈值，当计时器达到或超过这个值时，才会进行变化
+ */
+void U16_Data_Gradient(Light_uint16_t *cur, Light_uint16_t dest, Light_uint16_t step, Light_uint16_t *timer, const Light_uint16_t timedelay)
+{
+    if (*cur > dest)
+    {
+        if ((*cur - dest) > step)
+        {
+            if (*timer >= timedelay)
+            {
+                (*cur) -= step;
+                (*timer) = 0;
+            }
+            else
+            {
+                (*timer)++;
+            }
+        }
+        else
+        {
+            *cur = dest;
+            *timer = 0;
+        }
+    }
+    else
+    {
+        if ((dest - *cur) > step)
+        {
+            if (*timer >= timedelay)
+            {
+                (*cur) += step;
+                (*timer) = 0;
+            }
+            else
+            {
+                (*timer)++;
+            }
+        }
+        else
+        {
+            *cur = dest;
+            *timer = 0;
+        }
+    }
+}
+
+//根据电压值，确定热敏电阻的温度(摄氏度)
+uint8_t ADProcess_NTC_Temp_Get(uint16_t NTCVoltage)
+{
+    uint8_t i;
+
+    if ( NTCVoltage < 2312 )
+        return 0;
+
+    if ( NTCVoltage > 5000 )
+        return 0;
+
+    if ( (NTCVoltage > 2770) && (NTCVoltage < 5000) )
+        return 85;
+
+    //寻找所在的温度段
+    for ( i = 0; i < NTC_TEMP_ARRAY_LEN; i++ )
+    {
+        if ( NTCVoltage <= NTCStaticAttrs [ i ].Voltage )
+            return NTCStaticAttrs [ i ].Degree;
+    }
+    return 0;
+}
+
+//获取热敏电阻采集温度服务
+//周期：20ms
+void ADProcess_NTC_Temp_Service(void)
+{
+    //热敏电阻电压采集消抖
+    static uint8_t  CalcCnt          = 0;
+    static uint32_t Calc             = 0;
+    uint32_t        AnalogNtcVoltage = 0;
+
+    if ( ADC_Read_Signal_Valid(ADC_CH_NTC_R) == 1 )
+    {
+        AnalogNtcVoltage = ADC_Read_Signal(ADC_CH_NTC);
+        AnalogNtcVoltage *= 5000;
+        AnalogNtcVoltage /= 4096;
+        if ( AnalogNtcVoltage < 5000 )
+        {
+
+            //采集次数增加
+            CalcCnt++;
+            //采集值累计
+            Calc += AnalogNtcVoltage;
+
+            //采集次数超过50次，取平均值（50*20ms=1S）
+            if ( CalcCnt >= 50 )
+            {
+                //热敏电阻的采集电压有效，获取对应的温度值
+                NTCDegree = ADProcess_NTC_Temp_Get(Calc / 50);
+                //重新采集50次
+                CalcCnt = 0;
+                Calc    = 0;
+            }
+        }
+        // end
+    }
+    //采集的电压异常
+}
+
+void Luminous_Time_Alter(uint16_t Val)
+{
+    Luminous_Time = Val;
+}
+
+void Luminous_Value_Pwm_Alter(uint16_t Val)
+{
+    Luminous_Value_Pwm = Val;
+}
+uint16_t Get_Luminous_Value_Pwm(void)
+{
+    return Luminous_Value_Pwm;
+}
+uint16_t Get_Luminous_Value_recovery(void)
+{
+    return Luminous_Value_recovery;
+}
+

Application/BackLight.h

+#ifndef _BACKLIGHT_H_
+#define _BACKLIGHT_H_
+
+#include "common.h"
+#include "Components.h"
+#ifdef Platform_16Bit
+    #define Light_uint8_t  unsigned char
+    #define Light_uint16_t unsigned int
+    #define Light_uint32_t unsigned long
+
+#else
+    #define Light_uint8_t  unsigned char
+    #define Light_uint16_t unsigned short
+    #define Light_uint32_t unsigned int
+    #define Light_uint64_t unsigned long long
+
+#endif
+
+
+#ifndef Backlight_NULL
+    #define Backlight_NULL ( void * )0u
+#endif /* NULL */
+/*光感数据存储结构体*/
+typedef struct 
+{
+    uint32_t u32Result;
+    uint8_t u8DayandNightSts; 
+
+}Backlight_User_OPT3004_st_t;
+
+extern Backlight_User_OPT3004_st_t opt3004;
+void Backlight_KL30_Wakeup_Init(void);
+void Backlight_SetPwm_cotrol(void);
+void ADProcess_NTC_Temp_Service(void);
+void Luminous_Time_Alter(uint16_t Val);
+void Luminous_Value_Pwm_Alter(uint16_t Val);
+uint16_t Get_Luminous_Value_Pwm(void);
+uint16_t Get_Luminous_Value_recovery(void);
+
+#endif

Application/Battery_Voltage.c

+#include "Battery_Voltage.h"
+#include "Components.h"
+
+
+BatteryVoltage BatteryVoltageCtrl;
+uint16_t Digital_Voltage = 0u;
+uint16_t DigitalVoltage_Timer = 0u;
+/******************************************************************************
+函数名：Duty_Cycle_Delta
+�?  能：阻尼处理
+�?  数：�?
+返回值：�?
+******************************************************************************/
+void Duty_Cycle_Delta(uint16_t Goal, uint16_t *Current, uint16_t *DampingTimer)
+{
+
+    uint16_t Delta  = 0;
+    uint16_t Delta1 = 0;
+
+    if ( Goal > (*Current) )    //�?标值大于当前�?
+    {
+        Delta  = Goal - (*Current);
+        Delta1 = Goal - (*Current);
+
+        (*DampingTimer)++;
+
+        if ( (*DampingTimer) >= 5 )
+        {
+            (*DampingTimer) = 0;
+
+            Delta /= 10;
+
+            if ( Delta == 0 )
+            {
+                Delta = 1;
+            }
+
+            if ( (*Current) < Goal )
+            {
+                (*Current) += Delta;
+            }
+            if ( (*Current) > Goal )
+            {
+                (*Current)      = Goal;
+                (*DampingTimer) = 0;
+            }
+        }
+    }
+    else if ( Goal < (*Current) )    //�?标值小于当前�?
+    {
+        Delta = (*Current) - Goal;
+
+        (*DampingTimer)++;
+
+        if ( (*DampingTimer) >= 5 )
+        {
+            (*DampingTimer) = 0;
+
+            Delta /= 10;
+
+            if ( Delta == 0 )
+            {
+                Delta = 1;
+            }
+            if ( (*Current) > Goal )
+            {
+                (*Current) -= Delta;
+            }
+            if ( (*Current) < Goal )
+            {
+                (*Current)      = Goal;
+                (*DampingTimer) = 0;
+            }
+        }
+    }
+}
+
+void Display_Battery_Voltage(void)
+{
+    if(DigitalVoltage_Timer >= 30)//3秒采集一次
+    {
+        DigitalVoltage_Timer = 0;
+        Digital_Voltage = ADC_Read_Signal(ADC_CH_KL30_VOLTAGE) / 100U;
+    }
+    else
+    {
+       DigitalVoltage_Timer++;
+    } 
+    BatteryVoltageCtrl.BatteryVoltageCurrent = Digital_Voltage;
+}
+uint16_t Get_Battery_Voltage_Display(void)              //获取电池电压表数值
+{
+    return BatteryVoltageCtrl.BatteryVoltageCurrent;
+}
\ No newline at end of file

Application/Battery_Voltage.h

+#ifndef _BATTERY_VOLTAGE_H_
+#define _BATTERY_VOLTAGE_H_
+
+#include "common.h"
+#include "Components.h"
+
+typedef struct
+{
+    uint16_t Goal;
+    uint16_t BatteryVoltageCurrent;
+    uint16_t Time;
+} BatteryVoltage;
+
+
+extern void Duty_Cycle_Delta(uint16_t Goal, uint16_t *Current, uint16_t *DampingTimer);
+extern void Display_Battery_Voltage(void);
+extern uint16_t Get_Battery_Voltage_Display(void);              //获取电池电压表数值
+
+
+
+
+#endif
\ No newline at end of file

Application/CAN_APP.c

+#include "CAN_Lib.h"
+#include "CAN_APP.h"
+#include "CAN_APP_TX.h"
+#include "CommonInterface.h"
+#include "CAN_CH0_CAN_Communication_Matrix.h"
+#include "Data_VSpeed.h"
+#include "Components.h"
+#include "CommonInterface.h"
+
+void Data_CAN_APP_Init(void)
+{
+}
+
+uint8_t CRC8_SAE_J1850(uint8_t *u8_data, uint8_t u8_len)
+{
+    // uint8_t i, j;
+    uint8_t u8_crc8 = 0u;
+    // uint8_t u8_poly;
+
+    // u8_crc8 = 0xFF;
+    // u8_poly = 0x1D;
+
+    // for ( i = 0; i < u8_len; i++ )
+    // {
+    //     u8_crc8 ^= u8_data [ i ];
+
+    //     for ( j = 0; j < 8; j++ )
+    //     {
+    //         if ( u8_crc8 & 0x80 )
+    //         {
+    //             u8_crc8 = (( uint8_t )((u8_crc8 << 1) ^ u8_poly));
+    //         }
+    //         else
+    //         {
+    //             u8_crc8 <<= 1;
+    //         }
+    //     }
+    // }
+
+    // u8_crc8 ^= ( uint8_t )0xFF;
+    return u8_crc8;
+}
+void Can_Write_Fun_APP(void)
+{
+}
+
+void Can_Abort_Confirm(uint32_t Identifier, uint8_t TransferStatus)
+{
+}
+
+void Can_QuickTimer_Init(void)
+{
+    uint32_t i = 0u;
+
+    for ( i = 0u; i < CAN_CH0_ID_SEND_TOTAL; i++ )
+    {
+        Can_Msg_TX_FastInitCycle(&CAN_CH0_CanMsgTxOp, i, CAN_CH0_CANSendAttr [ i ].u32MsgCycleOffset);
+    }
+}
+
+void NODE_26D_SET_Confirm(void)
+{
+}
+
+void Can_BusOff_Fun(void)
+{
+}
+
+void Set_CarWashModeFeedback(uint8_t status)
+{
+}
+
+void Can_Set_Buff_100(uint8_t CopyData[])
+{
+    CANMsg100Union *pCANMsg100;
+    uint8_t i = 0u;
+    uint16_t Actual = 0u;
+    uint16_t Actual1 = 0u;
+    pCANMsg100 = (CANMsg100Union *)CopyData;
+    Actual = (Get_ActualVechileSpeed());
+    Actual1 = (Get_ActualVechileSpeed());
+    Actual = (Actual * 18 / 10);
+    if(Actual1 >= 1975)
+    {
+        Actual = 3560u;
+    }
+    if (pCANMsg100 != (void *)0)
+    {
+        for (i = 0u; i < 8u; i++)
+        {
+            pCANMsg100->Msg[i] = 0u;
+        }
+        if (Common_Get_IG_Sts() == COMMON_POWER_ON)
+        {
+            if (Common_GetIgnOnTimeL() > 500)
+            {
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Front_L = (uint8_t)((Actual>>5) & 0x00FF);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Front_H = (uint8_t)((Actual) & 0x001F);
+				pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Rear_L = (uint8_t)((Actual>>11) & 0x0003);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Rear_M = (uint8_t)((Actual>>3) & 0x00FF);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Rear_H = (uint8_t)((Actual) & 0x0007);
+            }
+            else
+            {
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Front_L = (0x00FF);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Front_H = (0x001F);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Rear_L = (0x0003);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Rear_M = (0x00FF);
+                pCANMsg100->Sig.IP_ABS1_N_wheelSpeed_Rear_H = (0x0007);
+            }
+        }
+        else
+        {
+        }
+    }
+}
+
+void Can_Set_Buff_213(uint8_t CopyData[])
+{
+    CANMsg213Union *pCANMsg213;
+    uint8_t i = 0u;
+    uint8_t Signal1 = 0u;
+    uint8_t Signal2 = 0u;
+    uint8_t Signal3 = 0u;
+    uint8_t Signal4 = 0u;
+    uint8_t Signal5 = 0u;
+    uint8_t Error = 0u;
+    pCANMsg213 = (CANMsg213Union *)CopyData;
+    if (pCANMsg213 != (void *)0)
+    {
+        for (i = 0u; i < 8u; i++)
+        {
+            pCANMsg213->Msg[i] = 0u;
+        }
+    //挡位指示
+        Signal1 = Get_CAN_CH0_ID_402_Sig_Rear_Gear_State();
+        Signal2 = Get_CAN_CH0_ID_402_Sig_Low_Gear_State();
+        Signal3 = Get_CAN_CH0_ID_402_Sig_High_Gear_State();
+        Signal4 = Get_CAN_CH0_ID_400_Sig_Park_Switch();
+        Signal5 = Get_CAN_CH0_ID_400_Sig_Neutral_Switch();
+        if (CAN_RX_Get_TimeStamp(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_402_Msg_Count) >= 3000u)
+        {
+            Signal1 = 0u;
+            Signal2 = 0u;
+            Signal3 = 0u;
+        }
+        if (CAN_RX_Get_TimeStamp(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_400_Msg_Count) >= 3000u)
+        {
+            Signal4 = 0u;
+            Signal5 = 0u;
+        }
+        Error = (Signal1 + Signal2 + Signal3 + Signal4 + Signal5);
+
+        if (Common_Get_IG_Sts() == COMMON_POWER_ON)
+        {
+            if (Error > 1u)
+            {
+                pCANMsg213->Sig.IP_shift = 0xFF;
+            }
+            else
+            {
+                if (Common_GetIgnOnTimeL() > 500)
+                {
+                    if (Signal5 == 1)
+                    {
+                        pCANMsg213->Sig.IP_shift = 0x00;
+                    }
+                    else if (Signal4 == 1)
+                    {
+                        pCANMsg213->Sig.IP_shift = 0x0B;
+                    }
+                    else if (Signal2 == 1)
+                    {
+                        pCANMsg213->Sig.IP_shift = 0x0C;
+                    }
+                    else if (Signal3 == 1)
+                    {
+                        pCANMsg213->Sig.IP_shift = 0x0D;
+                    }
+                    else if (Signal1 == 1)
+                    {
+                        pCANMsg213->Sig.IP_shift = 0x0A;
+                    }
+                    else
+                    {
+                        pCANMsg213->Sig.IP_shift = 0xFF;
+                    }
+                }
+                else
+                {
+                    pCANMsg213->Sig.IP_shift = 0xFF;
+                }
+            }
+        }
+        else
+        {
+        }
+    }
+}
+
+void Can_Set_Buff_50A(uint8_t CopyData [])
+{
+    // uint8_t         i          = 0u;
+    // CANMsg214Union *pCANMsg50A;
+
+    // pCANMsg50A = ( CANMsg214Union * )CopyData;
+    // if ( pCANMsg50A != ( void * )0 )
+    // {
+    //     for ( i = 0u; i < 8u; i++ )
+    //     {
+    //         pCANMsg50A->Msg [ i ] = 0u;
+    //     }
+
+    // }
+}
+
+void Can_Set_Buff_530(uint8_t CopyData [])
+{
+    // uint8_t         i             = 0u;
+    // CANMsg530Union *pCANMsg530;
+    // pCANMsg530 = ( CANMsg530Union * )CopyData;
+    // if ( pCANMsg530 != ( void * )0 )
+    // {
+    //     for ( i = 0u; i < 8u; i++ )
+    //     {
+    //         pCANMsg530->Msg [ i ] = 0u;
+    //     }
+    // }
+}
+
+void Can_Set_Buff_385(uint8_t CopyData [])
+{
+    uint8_t         i         = 0u;
+    CANMsg385Union *pCANMsg385;
+
+    pCANMsg385 = ( CANMsg385Union * )CopyData;
+    if ( pCANMsg385 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg385->Msg [ i ] = 0u;
+        }
+
+    }
+}
+
+void Can_Set_Buff_52E(uint8_t CopyData [])
+{
+    uint8_t         i = 0u;
+    CANMsg52EUnion *pCANMsg52E;
+
+    pCANMsg52E = ( CANMsg52EUnion * )CopyData;
+    if ( pCANMsg52E != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg52E->Msg [ i ] = 0u;
+        }
+    }
+}
+
+void Can_Set_Buff_69B(uint8_t CopyData [])
+{
+    CANMsg69BUnion *pCANMsg69B;
+
+    pCANMsg69B = ( CANMsg69BUnion * )CopyData;
+    if ( pCANMsg69B != ( void * )0 )
+    {
+    }
+}
+
+void Can_Set_Buff_28A(uint8_t CopyData [])
+{
+    uint8_t         i = 0u;
+    CANMsg28AUnion *pCANMsg28A;
+
+    pCANMsg28A = ( CANMsg28AUnion * )CopyData;
+    if ( pCANMsg28A != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg28A->Msg [ i ] = 0u;
+        }
+    }
+}
+
+void Can_Set_Buff_2DE(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg2DEUnion *pCANMsg2DE;
+
+    pCANMsg2DE = ( CANMsg2DEUnion * )CopyData;
+    if ( pCANMsg2DE != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg2DE->Msg [ i ] = 0u;
+        }
+
+    }
+}
+
+void Can_Set_Buff_640(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg640Union *pCANMsg640;
+
+    pCANMsg640 = ( CANMsg640Union * )CopyData;
+    if ( pCANMsg640 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg640->Msg [ i ] = 0u;
+        }
+    }
+}
+
+void Can_Set_Buff_6F1(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg6F1Union *pCANMsg6F1;
+
+    pCANMsg6F1 = ( CANMsg6F1Union * )CopyData;
+    if ( pCANMsg6F1 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg6F1->Msg [ i ] = 0u;
+        }
+    }
+}
+
+void Can_Set_Buff_6F2(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg6F2Union *pCANMsg6F2;
+
+    pCANMsg6F2 = ( CANMsg6F2Union * )CopyData;
+    if ( pCANMsg6F2 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg6F2->Msg [ i ] = 0u;
+        }
+    }
+}
+
+void Can_Set_Buff_6F3(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg6F3Union *pCANMsg6F3;
+
+    pCANMsg6F3 = ( CANMsg6F3Union * )CopyData;
+    if ( pCANMsg6F3 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg6F3->Msg [ i ] = 0u;
+        }
+    }
+}
+
+void Can_Set_Buff_6F5(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg6F5Union *pCANMsg6F5;
+
+    pCANMsg6F5 = ( CANMsg6F5Union * )CopyData;
+    if ( pCANMsg6F5 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg6F5->Msg [ i ] = 0u;
+        }
+
+    }
+}
+
+void Can_Set_Buff_6F7(uint8_t CopyData [])
+{
+    uint8_t         i                    = 0u;
+    CANMsg6F7Union *pCANMsg6F7;
+
+    pCANMsg6F7 = ( CANMsg6F7Union * )CopyData;
+    if ( pCANMsg6F7 != ( void * )0 )
+    {
+        for ( i = 0u; i < 8u; i++ )
+        {
+            pCANMsg6F7->Msg [ i ] = 0u;
+        }
+
+    }
+}
+

Application/CAN_APP.h

+#ifndef _CAN_APP_H_
+#define _CAN_APP_H_
+#include "Components.h"
+
+void Can_Abort_All(void);
+void Can_QuickTimer_Init(void);
+void Can_Write_Fun_APP(void);
+void Can_BusOff_Fun(void);
+
+void Data_CAN_APP_Init(void);
+
+void Can_Set_Buff_100(uint8_t CopyData[]);
+void Can_Set_Buff_213(uint8_t CopyData[]);
+/*void Can_Set_Buff_260(uint8_t CopyData []);*/
+void Can_Set_Buff_0CFE6C17(uint8_t CopyData []);
+void Can_Set_Buff_50A(uint8_t CopyData []);
+void Can_Set_Buff_530(uint8_t CopyData []);
+void Can_Set_Buff_385(uint8_t CopyData []);
+void Can_Set_Buff_52E(uint8_t CopyData []);
+void Can_Set_Buff_69B(uint8_t CopyData []);
+void Can_Set_Buff_28A(uint8_t CopyData []);
+void Can_Set_Buff_2DE(uint8_t CopyData []);
+void Can_Set_Buff_640(uint8_t CopyData []);
+void Can_Set_Buff_6F1(uint8_t CopyData []);
+void Can_Set_Buff_6F2(uint8_t CopyData []);
+void Can_Set_Buff_6F3(uint8_t CopyData []);
+void Can_Set_Buff_6F5(uint8_t CopyData []);
+void Can_Set_Buff_6F7(uint8_t CopyData []);
+
+void CAN_ID_326_CountClear(void);
+void CAN_ID_295_CountClear(void);
+void CAN_ID_326_Count(void);
+void CAN_ID_295_Count(void);
+void CAN_MSG_COUNTER_PLUS(void);
+
+uint8_t CRC8_SAE_J1850(uint8_t *u8_data, uint8_t u8_len);
+void    Set_CarWashModeFeedback(uint8_t status);
+
+void Set_ShortTermClrFlg(uint8_t Flag);
+void Set_LongTermClrFlg(uint8_t Flag);
+void Set_RefuelEndClrFlg(uint8_t Flag);
+void Set_WholeTermClrFlg(uint8_t Flag);
+
+
+#endif

Application/CAN_APP_TX.h

+#ifndef _CAN_APP_TX_H_
+#define _CAN_APP_TX_H_
+
+#include "stdint.h"
+#include "Components.h"
+//#pragma MESSAGE DISABLE C1106
+
+/*****************************************************************************************************
+ID  :  0x50A
+报文： IP_50A
+信号：
+       |- IP_QDashACCFail
+       |- IP_DISFail
+       |-
+       |-
+       |-
+       |- IP_FuelLeftoverVD
+       |-
+       |- IP_DisAfterIgnOn
+       |-
+       |- IP_PassengerLCDALEDSts
+       |- IP_DriverLCDALEDSts
+       |- IP_ModeSeting
+       |- IP_FuelLeftover
+       |- IP_FuelLeftover_AD
+       |- IP_FuelLevelPercent
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t  IP_ABS1_N_wheelSpeed_Front_L: 8;
+
+        uint8_t  IP_ABS1_N_wheelSpeed_Rear_L: 2;
+        uint8_t  : 1;
+        uint8_t  IP_ABS1_N_wheelSpeed_Front_H: 5;
+
+        uint8_t  IP_ABS1_N_wheelSpeed_Rear_M: 8;
+
+        uint8_t  : 5;
+        uint8_t  IP_ABS1_N_wheelSpeed_Rear_H: 3;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+
+    } Sig;
+} CANMsg100Union;
+
+/*****************************************************************************************************
+ID  :  0x530
+报文： IP_530
+信号：
+       |- IP_AvgFuelConsumption
+       |- IP_FuelLevel
+       |- IP_FuelGageType
+       |- IP_EngineOffTime
+       |- IP_TotalOdometer
+       |- IP_AfeAfterIgnOn
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint16_t IP_EngineOffTime_H : 8;    // IP_EngineOffTime
+        uint16_t IP_EngineOffTime_L : 8;    // IP_EngineOffTime
+
+        uint32_t IP_TotalOdometer_H : 8;    // IP_TotalOdometer
+        uint32_t IP_TotalOdometer_M : 8;    // IP_TotalOdometer
+        uint32_t IP_TotalOdometer_L : 8;    // IP_TotalOdometer
+
+        uint8_t IP_FuelGageType : 2;    // IP_FuelGageType
+        uint8_t IP_FuelLevel    : 4;    // IP_FuelLevel
+        uint8_t                 : 2;
+
+        uint8_t IP_AllAvgFuelConsumption : 8;    // IP_AvgFuelConsumption
+        uint8_t IP_AfeAfterIgnOn      : 8;    // IP_AfeAfterIgnOn
+    } Sig;
+
+} CANMsg530Union;
+
+/*****************************************************************************************************
+ID  :  0x210
+报文： IP_210
+信号：
+       |- IC_BrkOilLowWarn
+       |- IC_SafetyBeltDRVSide
+       |- IC_VehSpdDisplayVd
+       |- IC_VehSpdDisplay_H
+       |- IC_VehSpdDisplay_L
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg[8];
+    struct
+    {
+
+        uint8_t IC_TripDistance_1  : 8;
+
+        uint8_t IC_TripDistance_2  : 8;
+
+        uint8_t IC_TripDistance_3  : 8;
+
+        uint8_t IC_TripDistance_4  : 8;
+
+        uint8_t IC_TotalVehicleDistance1 : 8;
+
+        uint8_t IC_TotalVehicleDistance2 : 8;
+
+        uint8_t IC_TotalVehicleDistance3 : 8;
+
+        uint8_t IC_TotalVehicleDistance4 : 8;
+
+    } Sig;
+
+} CANMsg210Union;
+
+/*****************************************************************************************************
+ID  :  0x211
+报文： IP_211
+信号：
+       |- IC_BrkOilLowWarn
+       |- IC_SafetyBeltDRVSide
+       |- IC_VehSpdDisplayVd
+       |- IC_VehSpdDisplay_H
+       |- IC_VehSpdDisplay_L
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t  : 8;
+
+        uint8_t IP_shift : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+        uint8_t  : 8;
+
+
+    } Sig;
+
+} CANMsg213Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t Res0        : 8;
+        uint8_t Res1        : 8;
+        uint8_t Res2        : 8;
+        uint8_t Res3        : 8;
+        uint8_t Res4        : 8;
+        uint8_t Res5        : 8;
+        uint8_t IC_VSpeed_L : 8;
+        uint8_t IC_VSpeed_H : 8;
+    } Sig;
+} CANMsg0CFE6C17Union;
+
+/*****************************************************************************************************
+ID  :  0x385
+报文： IP_385
+信号：
+       |- IP_MessageAlertSoundSetStatus
+       |- IP_RearSeatbeltWarningEnableFB
+       |- IP_WarningVolumeSettingFB
+       |- IP_AlarmSoundSetStatus
+       |- IP_Adaptivedimminglevel
+       |- IP_DimmingModeSetStatus
+       |- IP_SoundStyleSetStatus
+       |- IP_AlarmSoundStatus
+       |- IP_WelcomeSoundSetStatus
+       |- IP_DimmingSetStatus
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_MessageAlertSoundSetStatus : 3;    // IP_MessageAlertSoundSetStatus       7
+        uint8_t IP_DimmingSetStatus           : 4;    //                           7
+        uint8_t IP_MaintainReset              : 1;    //                              7
+
+        uint8_t IP_RearSeatbeltWarningEnableFB : 2;    // IP_RearSeatbeltWarningEnableFB  7
+        uint8_t IP_WarningVolumeSettingFB      : 3;    // IP_WarningVolumeSettingFB      7
+        uint8_t IP_AlarmSoundSetStatus         : 3;    // IP_AlarmSoundSetStatus      7
+
+        uint8_t IP_Adaptivedimminglevel : 8;    //                      7
+
+        uint8_t IP_DimmingModeSetStatus : 2;
+        uint8_t IP_SoundStyleSetStatus  : 3;    // IP_SoundStyleSetStatus      7
+        uint8_t IP_AlarmSoundStatus     : 3;    //              7
+
+        uint8_t IP_VehicleSpeedIndicatorOutput_H : 1;
+        uint8_t IP_ECnsAvgReset                  : 1;    // ok
+        uint8_t IP_WelcomeSoundSetStatus         : 3;    // IP_WelcomeSoundSetStatus
+        uint8_t IP_EngineCoolanTemperatureHigh   : 1;    // ok
+        uint8_t IP_EngineOilPressureLowSts       : 1;    // ok
+        uint8_t IP_FuelLow                       : 1;    // ok
+
+        uint8_t IP_VehicleSpeedIndicatorOutput_M : 8;
+
+        uint8_t                                  : 2;
+        uint8_t IP_EnergyDspSts                  : 1;
+        uint8_t IP_BrakeFluidState               : 1;
+        uint8_t IP_VehicleSpeedIndicatorOutput_L : 4;
+
+        uint8_t IP_RealFuelConsumption : 8;
+    } Sig;
+} CANMsg385Union;
+
+/*****************************************************************************************************
+ID  :  0x52E
+报文： IP_52E
+信号：
+       |- IP_SunroofControlReq
+       |- IP_IndirectTPMSReset
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_SunroofControlReq : 8;
+
+        uint8_t                      : 2;
+        uint8_t IP_IndirectTPMSReset : 1;
+        uint8_t IP_AddOilStatus      : 2;
+        uint8_t IP_SmallMapEntry     : 2;
+        uint8_t IP_MipiScreenFailure : 1;
+
+        uint8_t IP_ImformationTransmission_Request : 5;
+        uint8_t IP_TrafficLaneRecon                : 2;
+
+        uint8_t IP_HUConnection_acknowledge : 2;
+        uint8_t IP_MusicEntry               : 2;
+        uint8_t IP_HUTaskCounter            : 4;
+
+        uint32_t                     : 32;
+    } Sig;
+} CANMsg52EUnion;
+
+/*****************************************************************************************************
+ID  :  0x69B
+报文： IP_69B
+信号：
+       |- IP_SunroofControlReq
+       |- IP_IndirectTPMSReset
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_DTC1_HighByte : 8;
+        uint8_t IP_DTC1_MiddByte : 8;
+        uint8_t IP_DTC1_LowByte  : 8;
+        uint8_t IP_DTC1_Status   : 8;
+        uint8_t IP_DTC2_HighByte : 8;
+        uint8_t IP_DTC2_MiddByte : 8;
+        uint8_t IP_DTC2_LowByte  : 8;
+        uint8_t IP_DTC2_Status   : 8;
+    } Sig;
+} CANMsg69BUnion;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_HUHeartbeat    : 2;
+        uint8_t IP_HUConnectReply : 1;
+        uint8_t                   : 5;
+
+        uint8_t IP_TimeMinAfterIgnOn : 6;
+        uint8_t                      : 2;
+
+        uint8_t IP_TimeHourAfterIgnOn : 7;
+        uint8_t                       : 1;
+
+        uint8_t      : 8;
+        uint8_t      : 8;
+        uint8_t      : 8;
+        uint8_t      : 8;
+        uint8_t      : 8;
+    } Sig;
+} CANMsg609Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_RisksAvoidTimes_H : 8;
+
+        uint8_t IP_TotalRisksAvoidTimes_H : 6;
+        uint8_t IP_RisksAvoidTimes_L      : 2;
+
+        uint8_t IP_TotalRisksAvoidTimes_L : 8;
+
+        uint8_t IP_AIDrvDisAfterIgnOn_H: 8;
+
+        uint8_t IP_TotalAIDrvDis_H     : 1;
+        uint8_t                        : 1;
+        uint8_t IP_AIDrvDisAfterIgnOn_L: 6;
+        
+        uint8_t IP_TotalAIDrvDis_M : 8;
+        uint8_t IP_TotalAIDrvDis_L : 8;
+        uint8_t      : 8;
+    } Sig;
+} CANMsg60BUnion;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_SGNameError : 4;
+        uint8_t                : 4;
+
+        uint8_t IP_Error : 4;
+        uint8_t          : 4;
+
+        uint8_t IP_Statuts : 8;
+
+        uint8_t IP_DteCFe: 8;
+
+        uint8_t IP_DteRfl_H : 2;
+        uint8_t IP_CalFuel  : 4;
+        uint8_t             : 2;
+        
+        uint8_t IP_DteRfl_L : 8;
+
+        uint8_t      : 8;
+        uint8_t      : 8;
+    } Sig;
+} CANMsg620Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_HUBuzzerWarning : 8;
+
+        // uint8_t IP_DayBiasLightStatus   : 4;
+        // uint8_t IP_NightBiasLightStatus : 4;
+        uint8_t IP_BiasLightCurrentSta    : 8;
+
+        uint8_t IP_ShemeColorsSwitchStatus       : 3;
+        uint8_t IP_ImformationTransmissionStatus : 5;
+
+        uint8_t IP_ACCInterfaceDisplaySts : 2;
+        uint8_t IP_BiasLightCurrentStatus : 2;
+        uint8_t IP_SmallWindowStatus      : 4;
+
+        uint8_t                     : 3;
+        uint8_t IP_DTEDspMode       : 2;
+        uint8_t IP_HUTransFaultType : 3;
+        
+        uint8_t IP_TotalOdometer_Oil_H : 8;
+
+        uint8_t IP_TotalOdometer_Oil_M : 8;
+        uint8_t IP_TotalOdometer_Oil_L : 8;
+    } Sig;
+} CANMsg640Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_o_FuelTgt : 4;
+        uint8_t IP_i_IGN     : 2;
+        uint8_t IP_o_Diag    : 2;
+
+        uint8_t IP_VehSpd : 8;
+        // uint8_t           : 4;
+
+        uint8_t IP_o_DteCfe_H : 8;
+        uint8_t IP_o_DteCfe_L : 8;
+
+        uint8_t IP_o_DteRfl_H : 8;
+        uint8_t IP_o_DteRfl_L : 8;
+
+        uint8_t IP_o_DteDisp_H: 8;
+        uint8_t IP_o_DteDisp_L: 8;
+    } Sig;
+} CANMsg6F1Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t o_CurSampFuel_H : 8;
+
+        uint8_t o_CurSampFuel_L : 8;
+
+        uint8_t i_FuelAD_H : 8;
+
+        uint8_t i_FuelAD_L : 8;
+
+        uint8_t o_FuelLeftOver_H : 8;
+
+        uint8_t o_FuelLeftOver_L : 8;
+        uint8_t TripMile_H : 8;
+        uint8_t TripMile_L : 8;
+    } Sig;
+} CANMsg6F2Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t AvgVehicleSpeed_H : 8;
+
+        uint8_t AvgVehicleSpeed_L : 8;
+
+        uint8_t InsFc_Lp100km : 8;
+
+        uint8_t InsFc_L_h : 8;
+
+        uint8_t NearFc : 8;
+
+        uint8_t IdleFc_H : 8;
+        uint8_t IdleFc_L : 8;
+        uint8_t          : 8;
+    } Sig;
+} CANMsg6F3Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t DrvSig_TimeHour_1_H : 8;
+
+        uint8_t DrvSig_TimeHour_1_L : 8;
+
+        uint8_t DrvSig_TimeMinute_1 : 8;
+
+        uint8_t DrvSig_Mile_1_H : 8;
+
+        uint8_t DrvSig_Mile_1_M : 8;
+
+        uint8_t DrvSig_Mile_1_L : 8;
+        uint8_t TripDrvSig_AvgFc_1 : 8;
+        uint8_t          : 8;
+    } Sig;
+} CANMsg6F5Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t DrvSig_TimeHour_2_H : 8;
+
+        uint8_t DrvSig_TimeHour_2_L : 8;
+
+        uint8_t DrvSig_TimeMinute_2 : 8;
+
+        uint8_t DrvSig_Mile_2_H : 8;
+
+        uint8_t DrvSig_Mile_2_M : 8;
+
+        uint8_t DrvSig_Mile_2_L : 8;
+        uint8_t TripDrvSig_AvgFc_2 : 8;
+        uint8_t          : 8;
+    } Sig;
+} CANMsg6F7Union;
+
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t DrvSig_TimeHour_H : 8;
+
+        uint8_t DrvSig_TimeHour_L : 8;
+
+        uint8_t DrvSig_TimeMinute : 8;
+
+        uint8_t DrvSig_Mile_H : 8;
+
+        uint8_t DrvSig_Mile_M : 8;
+
+        uint8_t DrvSig_Mile_L : 8;
+        uint8_t TripDrvSig_AvgFc : 8;
+        uint8_t          : 8;
+    } Sig;
+} CANMsg6F8Union;
+
+/*****************************************************************************************************
+ID  :  0x28A
+报文： IP_28A
+信号：
+*****************************************************************************************************/
+// typedef union
+// {
+//     uint8_t Msg [ 8 ];
+//     struct
+//     {
+//         uint8_t IP_KEY_UP    : 2;
+//         uint8_t IP_KEY_DOWN  : 2;
+//         uint8_t IP_KEY_LEFT  : 2;
+//         uint8_t IP_KEY_RIGHT : 2;
+
+//         uint8_t                    : 1;
+//         uint8_t IP_KEY_CURSTOM     : 2;
+//         uint8_t IP_KEY_SPEECH      : 2;
+//         uint8_t                    : 1;
+//         uint8_t IP_KEY_OK          : 2;
+
+//         uint8_t IP_DisplayMode_2        : 4;
+//         uint8_t IP_RaceModeRecordStatus : 2;
+//         uint8_t IP_DisplayModeMemory    : 2;
+
+//         uint8_t IP_DisplaySpeed_H : 8;
+
+//         uint8_t                   : 3;
+//         uint8_t IP_DisplaySpeed_L : 5;
+
+//         uint8_t : 8;
+//         uint8_t : 8;
+//         uint8_t : 8;
+//     } Sig;
+// } CANMsg28AUnion;
+
+/*****************************************************************************************************
+ID  :  0x28A
+报文： IP_28A
+信号：
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_VoiceReq : 8;
+
+        uint8_t IP_VoicePlayTimesReq : 5;
+        uint8_t                      : 1;
+        uint8_t IP_LFReq             : 2;
+
+        uint8_t IP_MsgWarningReq : 8;
+
+        uint8_t IP_TurnWarningReq         : 3;
+        uint8_t IP_AlarmReqRollingCounter : 3;
+        uint8_t IP_RFReq                  : 2;
+
+        uint8_t IP_LRReq               : 2;
+        uint8_t IP_TypeOfCutSoundShort : 3;
+        uint8_t IP_SeatBeltWarningReq  : 3;
+
+        uint8_t IP_VoicePlayCycleReq_H  : 1;
+        uint8_t IP_RRReq                : 2;
+        uint8_t IP_VoicePlayIntervalReq : 5;
+
+        uint8_t                        : 4;
+        uint8_t IP_VoicePlayCycleReq_L : 4;
+
+        uint8_t : 8;
+    } Sig;
+} CANMsg28AUnion;
+
+/*****************************************************************************************************
+ID  :  0x2DE
+报文： IP_2DE
+信号：
+*****************************************************************************************************/
+typedef union
+{
+    uint8_t Msg [ 8 ];
+    struct
+    {
+        uint8_t IP_QDashACCFail        : 2;
+        uint8_t IP_DISFail             : 1;
+        uint8_t IP_PassengerLCDALEDSts : 1;
+        uint8_t IP_DriverLCDALEDSts    : 1;
+        uint8_t IP_LongTermClrFlg      : 1;
+        uint8_t IP_RefuelEndClrFlg     : 1;
+        uint8_t IP_ShortTermClrFlg     : 1;
+
+        uint8_t IP_Odometer_H     : 1;
+        uint8_t IP_AddOilMode_Req : 2;
+        uint8_t                   : 5;
+
+
+        uint8_t IP_Odometer_M : 8;
+
+        uint8_t IP_Odometer_L : 8;
+
+        uint8_t IP_EngineSpeedOutput_H : 8;
+
+        uint8_t IP_EngineSpeedOutput_L : 8;
+
+        uint8_t IP_RollingCounter_2DE   : 4;
+        uint8_t IP_WholeTermClrFlg      : 1;
+        uint8_t IP_SCSSeatBeltControl   : 2;
+        uint8_t                         : 2;
+
+        uint8_t IP_CRCCheck_2DE : 8;
+    } Sig;
+} CANMsg2DEUnion;
+
+
+
+#endif

Application/CAN_CH0_CAN_Communication_Matrix.c

+#include  "CAN_CH0_CAN_Communication_Matrix.h"
+#include "CAN_APP.h"
+/* 2024/08/12 15:09:44 */
+st_CanMsgOp CAN_CH0_CanMsgOp;
+st_CanMsgTxOp CAN_CH0_CanMsgTxOp;
+#define CAN_CH0 &CAN_CH0_CanMsgOp
+
+const st_CAN_SendAttribute    CAN_CH0_CANSendAttr[CAN_CH0_ID_SEND_TOTAL] =
+{
+    {0x213ul, 8ul * 1000ul,  6ul * 1000ul, 0u, 0, 7u, 8u, 0, Can_Set_Buff_213, ( void * )0},
+    {0x100ul, 8ul * 1000ul,  6ul * 1000ul, 0u, 0, 10u, 8u, 0, Can_Set_Buff_100, ( void * )0},
+};
+
+const st_CANMsgAttribute CAN_CH0_CAN_MSG_CONST_ARRAY[CAN_CH0_ID_TOTAL_MAX] =
+{
+    // {
+    //     {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+    //     {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+    //     {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+    //     5000ul,
+    //     0x213ul,
+    //     (( void * )0),
+    //     (( void * )0),
+    //     (( void * )0),
+    // },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x7E8ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x7E0ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x7DFul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x404ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x212ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x15Ful,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x620ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x621ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x08u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x5FAul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x402ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x401ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x02u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x400ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x238ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        5000ul,
+        0x111ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    {
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+        1000ul,
+        0x101ul,
+        (( void * )0),
+        (( void * )0),
+        (( void * )0),
+    },
+    // {
+    //     {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+    //     {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+    //     {0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u, 0x00u},
+    //     5000ul,
+    //     0x100ul,
+    //     (( void * )0),
+    //     (( void * )0),
+    //     (( void * )0),
+    // },
+};
+
+// uint8_t  Get_CAN_CH0_ID_213_Sig_Dashboard_GEAR(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DASHBOARD_213_Msg_Count, 1u) >> 0u) & 0xFFu));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_213_Sig_Vehicle_Speed_Limt(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DASHBOARD_213_Msg_Count, 0u) >> 6u) & 0x01u));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_213_Sig_EPS_mode(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DASHBOARD_213_Msg_Count, 0u) >> 2u) & 0x03u));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_213_Sig_a24WD_Switch(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DASHBOARD_213_Msg_Count, 0u) >> 1u) & 0x01u));
+// }
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b7(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b6(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 6u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b5(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b4(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b3(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b2(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b1(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b0(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count, 0u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b7(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b6(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 6u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b5(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b4(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b3(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b2(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b1(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b0(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count, 0u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b7(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b6(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 6u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b5(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b4(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b3(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b2(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b1(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b0(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count, 0u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_404_Sig_Sport_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_Dash_Set_Msg_Count, 0u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_404_Sig_Oil_Pressure_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_Dash_Set_Msg_Count, 0u) >> 3u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_404_Sig_Front_Axle_Lock_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_Dash_Set_Msg_Count, 0u) >> 2u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_404_Sig_ETC_Target_Performance_Mode(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_Dash_Set_Msg_Count, 0u) >> 0u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_CheckSum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_AliveCounter(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 6u) >> 4u) & 0x0Fu));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_Ignition_Enable2(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 6u) >> 2u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_Ignition_Enable(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 6u) >> 0u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_TBOX_KeyAuthentSts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 5u) >> 6u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_signallamp_outsts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 1u) >> 0u) & 0x0Fu));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_BCM_Start_SwSts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 6u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_ecustart_insts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 5u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_start_relay_outsts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_K15_outsts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 3u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_horn_outsts(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 2u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_BCM_TurnIndicatorLeft(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 1u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_212_Sig_BCM_TurnIndicatorRight(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE__Msg_Count, 0u) >> 0u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte7(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte6(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 6u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte5(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte4(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte3(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte2(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte1(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte0(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_PKE_Msg_Count, 0u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_620_Checksum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeSecond(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 6u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeMinute(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeHour(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeDate(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeMonth(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeYear(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeValid(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_TBOX_Msg_Count, 0u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_621_Checksum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_T_BOX_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_PowerReq(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_T_BOX_Msg_Count, 2u) >> 0u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_Pitch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_T_BOX_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_Roll(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_T_BOX_Msg_Count, 0u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_5FA_Sig_EPS_fault_light(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_EPS_Msg_Count, 2u) >> 3u) & 0x01u));
+}
+
+uint16_t Get_CAN_CH0_ID_5FA_Sig_EPS_fault_code(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_EPS_Msg_Count, 0u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_EPS_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_ECU_402_Checksum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_ECU_402_Livecounter(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 6u) >> 0u) & 0x0Fu));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_a2WD_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 6u) >> 6u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Reay_Axle_Lock_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 6u) >> 5u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Thrust_Augmentation_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 6u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_High_Gear_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 5u) >> 7u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Low_Gear_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 5u) >> 6u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Rear_Gear_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 5u) >> 5u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Brake_Switch_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 5u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_ETC_performance_mode_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 5u) >> 3u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_ETC_performance_mode(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 5u) >> 1u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Power_Mode_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 4u) >> 0u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Hot_Engine_Warning(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 4u) >> 1u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_TCS_Indicator_Request(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 4u) >> 2u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Idle_stop_request(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 4u) >> 4u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_402_Sig_Engine_Troq_Request(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 4u) >> 6u) & 0x03u));
+}
+
+uint16_t Get_CAN_CH0_ID_402_Sig_ECU_History_Fault_Code(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 2u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint16_t Get_CAN_CH0_ID_402_Sig_ECU_Current_Fault_Code(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 0u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_402_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_401_Checksum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_401_Livecounter(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 6u) >> 0u) & 0x0Fu));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_CoolantFAN_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 6u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Autostart_Req_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 6u) >> 5u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Autostart_Req(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 6u) >> 6u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_MIL_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 6u) >> 7u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Gear_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint16_t Get_CAN_CH0_ID_401_Sig_ECU_Fuel_Consumption(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 3u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Battery_Voltage(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint16_t Get_CAN_CH0_ID_401_Sig_ECU_Environment_Presure(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 0u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_401_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Fuel_Level_Signal(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Oil_Preseeure_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 7u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Head_Light_compensation_switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 6u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Hand_Brake_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 5u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Neutral_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Park_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 3u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Safety_Belt_Switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 2u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_400_Sig_Seat_switch(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_400_Msg_Count, 0u) >> 1u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_238_Sig_TCS_Disable_Request(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_Cluster_238_Msg_Count, 0u) >> 0u) & 0x03u));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_111_Checksum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_111_Livecounter(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 6u) >> 0u) & 0x0Fu));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Fault_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 4u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_Autostop_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 3u) >> 0u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_InjIgn_Cutoff_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 2u) >> 0u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_Autostop(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 1u) >> 0u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_InjIgn_Cutoff(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 0u) >> 0u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_Engine_Reverse_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 0u) >> 1u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_111_Sig_Engine_Reverse_State_Valid(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ISG_111_Msg_Count, 0u) >> 2u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_101_Checksum(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 7u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_101_Livecounter(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 6u) >> 0u) & 0x0Fu));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Engine_Speed_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 6u) >> 4u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Vehicle_Speed_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 6u) >> 5u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Throttle_Position_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 6u) >> 6u) & 0x01u));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Engine_Temperature_State(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 6u) >> 7u) & 0x01u));
+}
+
+uint16_t Get_CAN_CH0_ID_101_Sig_ECU_Engine_Temperature(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 4u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 5u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Throttle_Position(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 3u) >> 0u) & 0xFFu));
+}
+
+uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Vehicle_Speed(void)
+{
+    return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 2u) >> 0u) & 0xFFu));
+}
+
+uint16_t Get_CAN_CH0_ID_101_Sig_ECU_Engine_Speed(void)
+{
+    return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 0u) >> 0u) & 0xFFu) << 8u) + \
+    ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ECU_101_Msg_Count, 1u) >> 0u) & 0xFFu));
+}
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_Checksum(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 7u) >> 0u) & 0xFFu));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_Livecounter(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 6u) >> 0u) & 0x0Fu));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_Supplier(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 6u) >> 4u) & 0x0Fu));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_St_ABS(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 5u) >> 4u) & 0x01u));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_wheelSpeed_Rear(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 3u) >> 4u) & 0x01u));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_ABS(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 5u) >> 5u) & 0x01u));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_vehiclereference(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 5u) >> 6u) & 0x01u));
+// }
+
+// uint16_t Get_CAN_CH0_ID_100_Sig_ABS1_N_vehiclereference(void)
+// {
+//     return (((uint16_t)((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 3u) >> 0u) & 0x0Fu) << 8u) + \
+//     ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 4u) >> 0u) & 0xFFu) << 1u) + \
+//     ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 5u) >> 7u) & 0x01u));
+// }
+
+// uint16_t Get_CAN_CH0_ID_100_Sig_ABS1_N_wheelSpeed_Rear(void)
+// {
+//     return (((uint16_t)((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 1u) >> 0u) & 0x03u) << 8u) + \
+//     ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 2u) >> 0u) & 0xFFu) << 3u) + \
+//     ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 3u) >> 5u) & 0x07u));
+// }
+
+// uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_wheelSpeed_Front(void)
+// {
+//     return (((uint8_t)((uint8_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 1u) >> 2u) & 0x01u));
+// }
+
+// uint16_t Get_CAN_CH0_ID_100_Sig_ABS1_N_wheelSpeed_Front(void)
+// {
+//     return (((uint16_t)((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 0u) >> 0u) & 0xFFu) << 5u) + \
+//     ((uint16_t)((uint16_t)CAN_MSG_Read(CAN_CH0,CAN_CH0_ID_ABS_100_Msg_Count, 1u) >> 3u) & 0x1Fu));
+// }
+
+uint8_t  Co_Can_ConvertSubID_CAN_CH0(uint32_t MsgID)
+{
+    uint8_t u8Result = CAN_CH0_ID_TOTAL_MAX;
+    switch (MsgID)
+    {
+    // case CAN_CH0_ID_DASHBOARD_213_Msg:
+    //     u8Result = CAN_CH0_ID_DASHBOARD_213_Msg_Count;
+    //     break;
+    case CAN_CH0_ID_DIAG_EMS_RESP_Msg:
+        u8Result = CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count;
+        break;
+    case CAN_CH0_ID_DIAG_EMS_REQ_Msg:
+        u8Result = CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count;
+        break;
+    case CAN_CH0_ID_DIAG_FUNC_REQ_Msg:
+        u8Result = CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count;
+        break;
+    case CAN_CH0_ID_Dash_Set_Msg:
+        u8Result = CAN_CH0_ID_Dash_Set_Msg_Count;
+        break;
+    case CAN_CH0_ID_PKE__Msg:
+        u8Result = CAN_CH0_ID_PKE__Msg_Count;
+        break;
+    case CAN_CH0_ID_PKE_Msg:
+        u8Result = CAN_CH0_ID_PKE_Msg_Count;
+        break;
+    case CAN_CH0_ID_TBOX_Msg:
+        u8Result = CAN_CH0_ID_TBOX_Msg_Count;
+        break;
+    case CAN_CH0_ID_T_BOX_Msg:
+        u8Result = CAN_CH0_ID_T_BOX_Msg_Count;
+        break;
+    case CAN_CH0_ID_EPS_Msg:
+        u8Result = CAN_CH0_ID_EPS_Msg_Count;
+        break;
+    case CAN_CH0_ID_ECU_402_Msg:
+        u8Result = CAN_CH0_ID_ECU_402_Msg_Count;
+        break;
+    case CAN_CH0_ID_ECU_401_Msg:
+        u8Result = CAN_CH0_ID_ECU_401_Msg_Count;
+        break;
+    case CAN_CH0_ID_ECU_400_Msg:
+        u8Result = CAN_CH0_ID_ECU_400_Msg_Count;
+        break;
+    case CAN_CH0_ID_Cluster_238_Msg:
+        u8Result = CAN_CH0_ID_Cluster_238_Msg_Count;
+        break;
+    case CAN_CH0_ID_ISG_111_Msg:
+        u8Result = CAN_CH0_ID_ISG_111_Msg_Count;
+        break;
+    case CAN_CH0_ID_ECU_101_Msg:
+        u8Result = CAN_CH0_ID_ECU_101_Msg_Count;
+        break;
+    // case CAN_CH0_ID_ABS_100_Msg:
+    //     u8Result = CAN_CH0_ID_ABS_100_Msg_Count;
+    //     break;
+    default :
+        u8Result = CAN_CH0_ID_TOTAL_MAX;
+        break;
+    }
+    return u8Result;
+}
+

Application/CAN_CH0_CAN_Communication_Matrix.h

+#ifndef CAN_CH0_CAN_COMMUNICATION_MATRIX_H_
+#define CAN_CH0_CAN_COMMUNICATION_MATRIX_H_
+#include "Components.h"
+#include "CAN_Signal\CAN_Lib.h"
+
+extern st_CanMsgOp CAN_CH0_CanMsgOp;
+
+extern st_CanMsgTxOp CAN_CH0_CanMsgTxOp;
+
+typedef enum
+{
+    CAN_CH0_ID_DIAG_EMS_RESP_Msg_Count,
+    CAN_CH0_ID_DIAG_EMS_REQ_Msg_Count,
+    CAN_CH0_ID_DIAG_FUNC_REQ_Msg_Count,
+    CAN_CH0_ID_Dash_Set_Msg_Count,
+    CAN_CH0_ID_PKE__Msg_Count,
+    CAN_CH0_ID_PKE_Msg_Count,
+    CAN_CH0_ID_TBOX_Msg_Count,
+    CAN_CH0_ID_T_BOX_Msg_Count,
+    CAN_CH0_ID_EPS_Msg_Count,
+    CAN_CH0_ID_ECU_402_Msg_Count,
+    CAN_CH0_ID_ECU_401_Msg_Count,
+    CAN_CH0_ID_ECU_400_Msg_Count,
+    CAN_CH0_ID_Cluster_238_Msg_Count,
+    CAN_CH0_ID_ISG_111_Msg_Count,
+    CAN_CH0_ID_ECU_101_Msg_Count,
+
+    CAN_CH0_ID_TOTAL_MAX,                          
+} CAN_CH0_CAN_MSG_ID_t;
+
+typedef enum
+{
+    CAN_CH0_ID_DASHBOARD_213_Msg_Count,
+    CAN_CH0_ID_ABS_100_Msg_Count,
+    CAN_CH0_ID_SEND_TOTAL,
+} CAN_CH0_CAN_MSG_SEND_ID_t;
+
+extern const st_CANMsgAttribute CAN_CH0_CAN_MSG_CONST_ARRAY[CAN_CH0_ID_TOTAL_MAX] ;
+extern const st_CAN_SendAttribute    CAN_CH0_CANSendAttr[CAN_CH0_ID_SEND_TOTAL] ;
+
+#define  CAN_CH0_ID_DASHBOARD_213_Msg    0x213ul
+#define  CAN_CH0_ID_DIAG_EMS_RESP_Msg    0x7E8ul
+#define  CAN_CH0_ID_DIAG_EMS_REQ_Msg     0x7E0ul
+#define  CAN_CH0_ID_DIAG_FUNC_REQ_Msg    0x7DFul
+#define  CAN_CH0_ID_Dash_Set_Msg         0x404ul
+#define  CAN_CH0_ID_PKE__Msg             0x212ul
+#define  CAN_CH0_ID_PKE_Msg              0x15Ful
+#define  CAN_CH0_ID_TBOX_Msg             0x620ul
+#define  CAN_CH0_ID_T_BOX_Msg            0x621ul
+#define  CAN_CH0_ID_EPS_Msg              0x5FAul
+#define  CAN_CH0_ID_ECU_402_Msg          0x402ul
+#define  CAN_CH0_ID_ECU_401_Msg          0x401ul
+#define  CAN_CH0_ID_ECU_400_Msg          0x400ul
+#define  CAN_CH0_ID_Cluster_238_Msg      0x238ul
+#define  CAN_CH0_ID_ISG_111_Msg          0x111ul
+#define  CAN_CH0_ID_ECU_101_Msg          0x101ul
+#define  CAN_CH0_ID_ABS_100_Msg          0x100ul
+
+// extern uint8_t  Get_CAN_CH0_ID_213_Sig_Dashboard_GEAR(void);
+// extern uint8_t  Get_CAN_CH0_ID_213_Sig_Vehicle_Speed_Limt(void);
+// extern uint8_t  Get_CAN_CH0_ID_213_Sig_EPS_mode(void);
+// extern uint8_t  Get_CAN_CH0_ID_213_Sig_a24WD_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b7(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b6(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b5(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b4(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b3(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b2(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b1(void);
+extern uint8_t  Get_CAN_CH0_ID_7E8_Sig_Diag_EMS_Resp_Sig_b0(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b7(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b6(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b5(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b4(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b3(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b2(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b1(void);
+extern uint8_t  Get_CAN_CH0_ID_7E0_Sig_Diag_EMS_Req_Sig_b0(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b7(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b6(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b5(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b4(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b3(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b2(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b1(void);
+extern uint8_t  Get_CAN_CH0_ID_7DF_Sig_Diag_Funct_Req_Sig_b0(void);
+extern uint8_t  Get_CAN_CH0_ID_404_Sig_Sport_State(void);
+extern uint8_t  Get_CAN_CH0_ID_404_Sig_Oil_Pressure_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_404_Sig_Front_Axle_Lock_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_404_Sig_ETC_Target_Performance_Mode(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_CheckSum(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_AliveCounter(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_Ignition_Enable2(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_Ignition_Enable(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_PKE_TBOX_KeyAuthentSts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_signallamp_outsts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_BCM_Start_SwSts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_ecustart_insts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_start_relay_outsts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_K15_outsts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_horn_outsts(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_BCM_TurnIndicatorLeft(void);
+extern uint8_t  Get_CAN_CH0_ID_212_Sig_BCM_TurnIndicatorRight(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte7(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte6(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte5(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte4(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte3(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte2(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte1(void);
+extern uint8_t  Get_CAN_CH0_ID_15F_Sig_PKE_TBOX_ChallengeCodByte0(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_620_Checksum(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeSecond(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeMinute(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeHour(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeDate(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeMonth(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeYear(void);
+extern uint8_t  Get_CAN_CH0_ID_620_Sig_TBOX_TimeValid(void);
+extern uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_621_Checksum(void);
+extern uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_PowerReq(void);
+extern uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_Pitch(void);
+extern uint8_t  Get_CAN_CH0_ID_621_Sig_TBOX_Roll(void);
+extern uint8_t  Get_CAN_CH0_ID_5FA_Sig_EPS_fault_light(void);
+extern uint16_t Get_CAN_CH0_ID_5FA_Sig_EPS_fault_code(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_ECU_402_Checksum(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_ECU_402_Livecounter(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_a2WD_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Reay_Axle_Lock_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Thrust_Augmentation_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_High_Gear_State(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Low_Gear_State(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Rear_Gear_State(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Brake_Switch_State(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_ETC_performance_mode_State(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_ETC_performance_mode(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Power_Mode_State(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Hot_Engine_Warning(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_TCS_Indicator_Request(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Idle_stop_request(void);
+extern uint8_t  Get_CAN_CH0_ID_402_Sig_Engine_Troq_Request(void);
+extern uint16_t Get_CAN_CH0_ID_402_Sig_ECU_History_Fault_Code(void);
+extern uint16_t Get_CAN_CH0_ID_402_Sig_ECU_Current_Fault_Code(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_401_Checksum(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_401_Livecounter(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_CoolantFAN_State(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Autostart_Req_State(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Autostart_Req(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_MIL_State(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Gear_State(void);
+extern uint16_t Get_CAN_CH0_ID_401_Sig_ECU_Fuel_Consumption(void);
+extern uint8_t  Get_CAN_CH0_ID_401_Sig_ECU_Battery_Voltage(void);
+extern uint16_t Get_CAN_CH0_ID_401_Sig_ECU_Environment_Presure(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Fuel_Level_Signal(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Oil_Preseeure_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Head_Light_compensation_switch(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Hand_Brake_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Neutral_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Park_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Safety_Belt_Switch(void);
+extern uint8_t  Get_CAN_CH0_ID_400_Sig_Seat_switch(void);
+extern uint8_t  Get_CAN_CH0_ID_238_Sig_TCS_Disable_Request(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_111_Checksum(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_111_Livecounter(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Fault_State(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_Autostop_State(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_InjIgn_Cutoff_State(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_Autostop(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_ISG_Engine_InjIgn_Cutoff(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_Engine_Reverse_State(void);
+extern uint8_t  Get_CAN_CH0_ID_111_Sig_Engine_Reverse_State_Valid(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_101_Checksum(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_101_Livecounter(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Engine_Speed_State(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Vehicle_Speed_State(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Throttle_Position_State(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Engine_Temperature_State(void);
+extern uint16_t Get_CAN_CH0_ID_101_Sig_ECU_Engine_Temperature(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Throttle_Position(void);
+extern uint8_t  Get_CAN_CH0_ID_101_Sig_ECU_Vehicle_Speed(void);
+extern uint16_t Get_CAN_CH0_ID_101_Sig_ECU_Engine_Speed(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_Checksum(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_Livecounter(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_Supplier(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_St_ABS(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_wheelSpeed_Rear(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_ABS(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_vehiclereference(void);
+// extern uint16_t Get_CAN_CH0_ID_100_Sig_ABS1_N_vehiclereference(void);
+// extern uint16_t Get_CAN_CH0_ID_100_Sig_ABS1_N_wheelSpeed_Rear(void);
+// extern uint8_t  Get_CAN_CH0_ID_100_Sig_ABS1_F_wheelSpeed_Front(void);
+// extern uint16_t Get_CAN_CH0_ID_100_Sig_ABS1_N_wheelSpeed_Front(void);
+
+extern uint8_t  Co_Can_ConvertSubID_CAN_CH0(uint32_t MsgID);
+
+#endif

Application/Can_User.c

+#include "Can_User.h"
+#include <string.h>
+#include "can.h"
+#include "RTE.h"
+#include  "CAN_CH0_CAN_Communication_Matrix.h"
+#include "DoCAN_ISO15765.h"
+
+__align(4)
+uint32_t pRXBuff[CAN_RX_MSG_Block * CAN_CH0_ID_TOTAL_MAX];
+uint32_t pTXBuff[CAN_TX_MSG_Block * CAN_CH0_ID_SEND_TOTAL];
+static RSCAN0BusoffMonitorStruct RSCAN0Busoff;
+
+void Can_Init(void)
+{
+    can_config_st_t Can_Config;
+    Can_Config.ch = CAN_CH_0;
+    Can_Config.freq = CAN_500Kbps;
+    Can_Config.MASK[0] = 0x1fffffffU;
+    Can_Config.MASK[1] = 0x1fffffffU;
+    Can_Config.MASK[2] = 0x1fffffffU;
+    Can_Config.MASK[3] = 0x1fffffffU;
+    Can_Config.rx_callback = Can_Rx_Cak;
+    COM_CAN_Init();
+    rte_can_init(&Can_Config);
+
+    Can_Tx_Apply_Buff();
+    Can_RX_Apply_Buff();
+
+    RTE_GPIO_Set_Level(RTE_GPIO_PORT05_PIN02,RTE_GPIO_LEVEL_LOW);
+
+}
+
+/**
+ * @brief 用于申请RXBUFF CAN0MSG01~CAN0MSG011
+ *
+ */
+void Can_RX_Apply_Buff(void)
+{
+    // CAN_RecvMsg.Id = 0x213ul;
+    // CAN_RecvMsg.IDE = CAN_Id_Standard;
+    // CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    // CAN_RecvMsg.RTR = CAN_RTR_Data;
+    // CAN_RecvMsg.Interrupt = ENABLE;
+    // CAN_MessageCache_DeInit(CAN0MSG07);
+    // CAN_MessageCache_Init(CAN0MSG07, &CAN_RecvMsg);
+    // CAN_MessageCache_OverWriteConfig(CAN0MSG07, ENABLE);
+
+    CAN_RecvMsg.Id = 0x404;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG06);
+    CAN_MessageCache_Init(CAN0MSG06, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG06, ENABLE);
+
+    CAN_RecvMsg.Id = 0x5FAul;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG01);
+    CAN_MessageCache_Init(CAN0MSG01, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG01, ENABLE);
+
+    CAN_RecvMsg.Id = 0x402;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG04);
+    CAN_MessageCache_Init(CAN0MSG04, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG04, ENABLE);
+
+    CAN_RecvMsg.Id = 0x401;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG03);
+    CAN_MessageCache_Init(CAN0MSG03, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG03, ENABLE);
+
+    CAN_RecvMsg.Id = 0x400;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG02);
+    CAN_MessageCache_Init(CAN0MSG02, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG02, ENABLE);
+
+    CAN_RecvMsg.Id = 0x101;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG11);
+    CAN_MessageCache_Init(CAN0MSG11, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG11, ENABLE);
+
+    // CAN_RecvMsg.Id = 0x100;
+    // CAN_RecvMsg.IDE = CAN_Id_Standard;
+    // CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    // CAN_RecvMsg.RTR = CAN_RTR_Data;
+    // CAN_RecvMsg.Interrupt = ENABLE;
+    // CAN_MessageCache_DeInit(CAN0MSG10);
+    // CAN_MessageCache_Init(CAN0MSG10, &CAN_RecvMsg);
+    // CAN_MessageCache_OverWriteConfig(CAN0MSG10, ENABLE);
+
+
+    CAN_RecvMsg.Id = 0x12B;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG05);
+    CAN_MessageCache_Init(CAN0MSG05, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG05, ENABLE);
+
+
+
+    CAN_RecvMsg.Id = DIAG_ID_Rx_PHY;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG08);
+    CAN_MessageCache_Init(CAN0MSG08, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG08, ENABLE);
+
+    CAN_RecvMsg.Id = DIAG_ID_Rx_FUN;
+    CAN_RecvMsg.IDE = CAN_Id_Standard;
+    CAN_RecvMsg.CacheType = CAN_CacheType_Rx_NoMask;
+    CAN_RecvMsg.RTR = CAN_RTR_Data;
+    CAN_RecvMsg.Interrupt = ENABLE;
+    CAN_MessageCache_DeInit(CAN0MSG09);
+    CAN_MessageCache_Init(CAN0MSG09, &CAN_RecvMsg);
+    CAN_MessageCache_OverWriteConfig(CAN0MSG09, ENABLE);
+}
+
+/**
+ * @brief 用于申请TXBUFF
+ *
+ */
+void Can_Tx_Apply_Buff(void)
+{
+    CanTxRxMsg CAN_SendMsg;
+    CanTxRxMsg CAN_SendMsg_Diag_Tx;
+	CAN_SendMsg.Id = 0x213ul;
+	CAN_SendMsg.IDE = CAN_Id_Standard;
+	CAN_SendMsg.CacheType = CAN_CacheType_Tx;
+	CAN_SendMsg.RTR = CAN_RTR_Data;
+	CAN_RecvMsg.Interrupt = ENABLE;
+	CAN_SendMsg.DLC = 8;
+    for (uint8_t i = 0; i < CAN_SendMsg.DLC; i++)
+    {
+        CAN_SendMsg.Data[i] = 0;
+    }
+    CAN_MessageCache_DeInit(CAN0MSG07);
+    CAN_MessageCache_Init(CAN0MSG07, &CAN_SendMsg);
+    CAN_SendMsg.Id = 0x100ul;
+	CAN_SendMsg.IDE = CAN_Id_Standard;
+	CAN_SendMsg.CacheType = CAN_CacheType_Tx;
+	CAN_SendMsg.RTR = CAN_RTR_Data;
+	CAN_RecvMsg.Interrupt = ENABLE;
+	CAN_SendMsg.DLC = 8;
+    for (uint8_t i = 0; i < CAN_SendMsg.DLC; i++)
+    {
+        CAN_SendMsg.Data[i] = 0;
+    }
+    CAN_MessageCache_DeInit(CAN0MSG10);
+    CAN_MessageCache_Init(CAN0MSG10, &CAN_SendMsg);
+	CAN_SendMsg_Diag_Tx.Id = DIAG_ID_Tx;
+	CAN_SendMsg_Diag_Tx.IDE = CAN_Id_Standard;
+	CAN_SendMsg_Diag_Tx.CacheType = CAN_CacheType_Tx;
+	CAN_SendMsg_Diag_Tx.RTR = CAN_RTR_Data;
+	CAN_SendMsg_Diag_Tx.Interrupt = DISABLE;
+	CAN_SendMsg_Diag_Tx.DLC = 8;
+    for (uint8_t i = 0; i < CAN_SendMsg_Diag_Tx.DLC; i++)
+    {
+        CAN_SendMsg_Diag_Tx.Data[i] = 0;
+    }
+
+    CAN_MessageCache_DeInit(CAN0MSG00);
+    CAN_MessageCache_Init(CAN0MSG00, &CAN_SendMsg_Diag_Tx);
+}
+/**
+ * @brief 用于接收回调函数
+ * @code
+ */
+void Can_Rx_Cak(CanTxRxMsg *Msg)
+{
+    Co_Can_Buff_Set(&CAN_CH0_CanMsgOp, Co_Can_ConvertSubID_CAN_CH0(Msg->Id), Msg->DLC, Msg->Data);
+
+    if ((Msg->Id == DIAG_ID_Rx_FUN) || (Msg->Id == DIAG_ID_Rx_PHY))
+    {
+      DoCAN_L_Data_Indication((uint16_t)Msg->Id, Msg->DLC, Msg->Data);
+    }
+}
+/**
+ * @brief CAN库初始化TX/RX
+ *
+ */
+void COM_CAN_Init(void)
+{
+    memset(pRXBuff, 0, sizeof(pRXBuff));
+    CAN_CH0_CanMsgOp.CAN_MSG_Analysis = (st_CANMsgStruct *)pRXBuff;
+    CAN_CH0_CanMsgOp.pAttrubute = CAN_CH0_CAN_MSG_CONST_ARRAY;
+    CAN_CH0_CanMsgOp.Total_Msg = CAN_CH0_ID_TOTAL_MAX;
+    CAN_CH0_CanMsgOp.u8CAN_RX_ENABLE = CAN_N_RX_Enable;
+    Can_RX_BuffInit(&CAN_CH0_CanMsgOp, CAN_CH0_CAN_MSG_CONST_ARRAY, CAN_CH0_ID_TOTAL_MAX);
+    CAN_RX_SetEnable(&CAN_CH0_CanMsgOp, CAN_N_RX_Enable);
+
+    memset(pTXBuff, 0, sizeof(pTXBuff));
+    CAN_CH0_CanMsgTxOp.CanMsg = (st_CAN_SendOperation *)pTXBuff;
+    Can_TX_BuffInit(&CAN_CH0_CanMsgTxOp, CAN_CH0_CANSendAttr, CAN_CH0_ID_SEND_TOTAL, COM_APP_Process);
+    CAN_TX_SetEnable(&CAN_CH0_CanMsgTxOp, CAN_N_TX_Enable);
+}
+
+uint16_t cji_canflsg = 0u;
+/**
+ * @brief Buff恢复函数
+ * @param deltaTime 调用时间 单位ms 10MS调用
+ */
+void Can_BusOff_Recover(uint8_t deltaTime)
+{
+    if (get_can_busoff(CAN_CH_0) == 2)
+    {
+        cji_canflsg = 1u;
+        if (RSCAN0Busoff.Status == RSCAN0_BUS_STABLE)
+        {
+            RSCAN0Busoff.Status = RSCAN0_BUS_OFF_LV1;
+        }
+
+        if (RSCAN0Busoff.Status == RSCAN0_BUS_OFF_LV1)
+        {
+            RSCAN0Busoff.Timer++;
+            if (RSCAN0Busoff.Timer >= RSCAN0_BUS_OFF_LV1_RECOVERY_TIME / deltaTime)
+            {
+                RSCAN0Busoff.Timer = 0U;
+
+                RSCAN0Busoff.Cnt++;
+                if (RSCAN0Busoff.Cnt >= 10U)
+                {
+
+                    RSCAN0Busoff.Cnt = 0U;
+
+                    RSCAN0Busoff.Status = RSCAN0_BUS_OFF_LV2;
+                }
+                reset_busoff(CAN_CH_0);
+
+            }
+        }
+        else if (RSCAN0Busoff.Status == RSCAN0_BUS_OFF_LV2)
+        {
+            RSCAN0Busoff.Timer++;
+
+            if (RSCAN0Busoff.Timer >= RSCAN0_BUS_OFF_LV2_RECOVERY_TIME / deltaTime)
+            {
+                RSCAN0Busoff.Timer = 0U;
+                reset_busoff(CAN_CH_0);
+              }
+        }
+        else
+        {
+        }
+    }
+    else /* 总线正常,没有Bus-off发生*/
+    {
+        if (cji_canflsg == 1)
+        {
+            cji_canflsg = 0u;
+            Can_RX_Apply_Buff();
+            Can_Tx_Apply_Buff();
+        }
+    }
+}
+
+/**
+ * @brief 获取busoff状态
+ * @return 0 没有busoff
+ *         1 错误的操作
+ *         2 busoff
+ */
+uint8_t Get_Busoff_Status(void)
+{
+    return get_can_busoff(CAN_CH_0);
+}
+
+uint8_t COM_APP_Process(st_CAN_Msg *Msg)
+{
+    Can_Write_((st_CAN_Msg *)Msg);
+    return 0;
+}
+
+void Can_Write_(st_CAN_Msg *Msg)
+{
+    uint32_t i = 0;
+    CanTxRxMsg CAN_SendMsg;
+
+    CAN_SendMsg.Id = Msg->MsgID;       /* ID */
+    CAN_SendMsg.DLC = Msg->MsgDLC;     /* Len */
+    CAN_SendMsg.RTR = Msg->MsgRTR;     /* Default 0 */
+    CAN_SendMsg.IDE = CAN_Id_Standard; /* Stand 0 Ext 1 */
+    CAN_SendMsg.CacheType = CAN_CacheType_Tx;
+
+    for (i = 0; i < CAN_SendMsg.DLC; i++) /* 获取数据 */
+    {
+        CAN_SendMsg.Data[i] = Msg->Msg[i];
+    }
+
+    switch (CAN_SendMsg.Id)
+    {
+    case 0x213:
+        CAN_Transmit(CAN0MSG07, &CAN_SendMsg);
+        break;
+    case 0x100:
+        CAN_Transmit(CAN0MSG10, &CAN_SendMsg);
+        break;
+
+    default:
+        break;
+    }
+}

Application/Can_User.h

+#ifndef _CAN_USER_H_
+#define _CAN_USER_H_
+#include "RTE.h"
+#include "Components.h"
+
+
+
+
+
+/******************************************************************************
+Bus-off
+******************************************************************************/
+#define   RSCAN0_BUS_STABLE                 0x00U
+#define   RSCAN0_BUS_OFF_LV1                0x01U
+#define   RSCAN0_BUS_OFF_LV2                0x02U
+#define   RSCAN00_BUS_LIMP                   0x03U
+/******************************************************************************
+Bus-off
+******************************************************************************/
+
+#define   RSCAN0_BUS_OFF_LV1_RECOVERY_TIME  70U             
+#define   RSCAN0_BUS_OFF_LV2_RECOVERY_TIME  1000U      
+
+typedef struct
+{
+    uint8_t  Status;
+    uint8_t  Timer;
+    uint8_t  Cnt;
+    uint8_t  ReportDTCCnt;
+} RSCAN0BusoffMonitorStruct;
+
+
+
+extern void Can_Tx_Apply_Buff(void);
+extern void Can_RX_Apply_Buff(void);
+extern void Can_BusOff_Recover(uint8_t deltaTime);
+extern void COM_CAN_Init(void);
+extern void Can_Init(void);
+extern void Can_Rx_Cak(CanTxRxMsg *Msg);
+extern void Busoff(void);
+extern uint8_t COM_APP_Process(st_CAN_Msg *Msg);
+extern void Can_Write_(st_CAN_Msg *Msg);
+
+#endif

Application/CommonInterface.c

+
+#include "CommonInterface.h"
+#include "Components.h"
+#include "PowerManagement\PowerManag_user.h"
+
+uint32_t PowerIgnOnTimeLine;
+uint32_t PowerIgnOnTimeL = 0u;;
+uint32_t PowerIgnOffTimeLine;
+extern uint8_t Voltage_Anomaly;
+static uint32_t PowerSocTimeLine;
+static uint32_t PowerSelfTimer = 0;
+static uint16_t tyre_Size_State = 0;
+static COMMON_PowerStatus_t PowerSts; /*1 ON ;  0 OFF*/
+static uint32_t Act_V_Speed;          /*实际值,十倍的*/
+static uint32_t Disp_V_Speed;         /*显示值,十倍的*/
+static DataValid_t PowerSts_Valid;
+volatile static DataValid_t Act_V_Speed_Valid;
+static DataValid_t Disp_V_Speed_Valid;
+uint16_t Disp_Valid;
+
+// static uint16_t u16SelfCheckTime;
+/*每次唤醒调用*/
+void Common_DataInit(void)
+{
+    PowerSts = COMMON_POWER_UNKNOW;
+    Act_V_Speed = 0xffffu;
+    Disp_V_Speed = 0xffffu;
+
+    PowerSts_Valid = COMMON_Valid_UNKNOW;
+    Act_V_Speed_Valid = COMMON_Valid_UNKNOW;
+    Disp_V_Speed_Valid = COMMON_Valid_UNKNOW;
+    PowerIgnOnTimeLine = 0x0ul;
+    PowerIgnOnTimeL = 0u;
+    PowerIgnOffTimeLine = 0x0ul;
+    PowerSocTimeLine = 0x0ul;
+}
+
+/*以下由各个处理模块按需调用*/
+/*使用数据之前,需要先判断数据是否有效,如果无效,则不可以使用*/
+
+uint8_t Common_Get_IG_Sts(void)
+{
+    return (uint8_t)PowerSts;
+}
+
+uint16_t Common_Get_Act_V_Speed(void)
+{
+    return (uint16_t)Act_V_Speed;
+}
+uint16_t Common_Get_Disp_V_Speed(void)
+{
+    return (uint16_t)Disp_V_Speed;
+} 
+
+uint16_t Common_Get_TireSize(void)
+{
+    return 1u;
+}
+
+void Common_Set_IG_Sts(COMMON_PowerStatus_t Val)
+{
+    PowerSts = Val;
+}
+void Common_Set_Act_V_Speed(uint32_t Val)
+{
+    if (Val >= 500u)
+    {
+        Val += 20u;
+    }
+    else if(Val >= 100)
+    {
+        Val += 10u;
+    }
+    Act_V_Speed = Val;
+}
+void Common_Set_Disp_V_Speed(uint32_t Val)
+{
+    Disp_V_Speed = Val;
+}
+
+DataValid_t Common_Get_IG_Sts_Valid(void)
+{
+    return PowerSts_Valid;
+}
+DataValid_t Common_Get_Act_V_Speed_Valid(void)
+{
+    return Act_V_Speed_Valid;
+}
+DataValid_t Common_Get_Disp_V_Speed_Valid(void)
+{
+    return Disp_V_Speed_Valid;
+}
+
+void Common_Set_IG_Sts_Valid(DataValid_t Val)
+{
+    PowerSts_Valid = Val;
+}
+void Common_Set_Act_V_Speed_Valid(DataValid_t Val)
+{
+    Act_V_Speed_Valid = Val;
+}
+void Common_Set_Disp_V_Speed_Valid(DataValid_t Val)
+{
+    Disp_V_Speed_Valid = Val;
+}
+
+uint16_t Common_Get_DispSpeed(void)
+{
+    uint16_t m_Res = 0;
+    return m_Res;
+}
+
+void Common_Input_Para(void)
+{
+
+    if (SYS_OPR_STAT_IGN_ON)
+    {
+        Common_Set_IG_Sts(COMMON_POWER_ON);
+        Common_Set_IG_Sts_Valid(COMMON_Valid);
+        if (Get_Voltage_Anomaly() == 1)//过压无自检
+        {
+            Voltage_Anomaly = 2u;
+            PowerSelfTimer = 1041u;
+            PowerIgnOnTimeLine = 2082u;          
+        }
+        if (Get_Uptime_Staus() == 1u)//开机动画结束标志位
+        {
+            if (GetLcdInitSt() == 1u)
+            {
+                PowerSelfTimer++;
+                if (PowerSelfTimer >= 2000u)//防止时间溢出
+                {
+                    PowerSelfTimer = 2000u;
+                }
+            }
+            if (PowerSelfTimer > 1030u)//自检2s
+            {
+                Disp_Valid = 0u;//非自检
+            }
+            else
+            {
+                Disp_Valid = 1u;//自检
+            }
+        }
+
+        Common_Set_Act_V_Speed(Get_ActualVechileSpeed());
+        Common_Set_Disp_V_Speed(Get_DispVechileSpeed());  
+        if (Get_VechileSpeedValid() == COMMON_Valid)
+        {
+            Common_Set_Act_V_Speed_Valid(COMMON_Valid);
+            Common_Set_Disp_V_Speed_Valid(COMMON_Valid);
+        }
+        else
+        {
+            Common_Set_Act_V_Speed_Valid(COMMON_InValid);
+            Common_Set_Disp_V_Speed_Valid(COMMON_InValid);
+        }
+
+        PowerIgnOffTimeLine = 0u;//上15电置0
+        if (Get_Dis_Old_Staus() == 3u)//轮胎选择界面
+        {
+            PowerSelfTimer = 0u;
+            PowerIgnOnTimeLine = 0u;
+            for(uint8_t i = 0; i<23;i++)//点亮所有指示灯
+            {
+                Telltales_DiagCtrl(i,0x01);
+            }
+            tyre_Size_State = 1u;//轮胎选择界面结束标志位
+        }
+        else
+        {
+            if (tyre_Size_State == 1u)
+            {
+                tyre_Size_State = 0u;
+                Telltales_DiagRelease(1);
+            }
+            if (GetLcdInitSt() >= 1u)
+            {
+                if (Get_Uptime_Staus() == 1u)
+                {
+                    if (PowerIgnOnTimeLine < 0x7ffffffful)
+                    {
+                        PowerIgnOnTimeLine += 2u;
+                    }
+                }
+            }
+        }
+        PowerIgnOnTimeL += 2u;
+    }
+    else
+    {
+        Disp_Valid = 0u;
+        PowerSelfTimer = 0u;
+        PowerIgnOnTimeLine = 0ul;
+        PowerIgnOnTimeL = 0u;
+        if (PowerIgnOffTimeLine < 0x7ffffffful)
+        {
+            PowerIgnOffTimeLine += 2u;
+        }
+        Common_Set_IG_Sts(COMMON_POWER_OFF);
+        Common_Set_IG_Sts_Valid(COMMON_Valid);
+
+        /*车转真实值OFF为0*/
+        Common_Set_Act_V_Speed(0u);
+        Common_Set_Disp_V_Speed(0u);
+    }
+}
+
+uint32_t Common_GetIgnOnTime(void)
+{
+    return PowerIgnOnTimeLine;
+}
+uint32_t Common_GetIgnOnTimeL(void)
+{
+    return PowerIgnOnTimeL;
+}
+uint32_t Common_GetIgnOffTime(void)
+{
+    return PowerIgnOffTimeLine;
+}
+
+uint32_t Common_GetSocTime(void)
+{
+    return PowerSocTimeLine;
+}
+
+uint16_t Get_Self(void)
+{
+    return Disp_Valid;
+}
+
+/**
+ * @brief 公里转换英里
+ * @return 公里
+ */
+uint32_t Data_Km_To_Mile(uint32_t Km)
+{   
+    //Km *= 621;
+    //Km /= 1000;
+    Km *= 64;
+    Km /= 103;
+    return Km;
+}
+/**
+ * @brief 英里转换公里
+ * @return 英里
+ */
+uint32_t Data_Mile_To_Km(uint32_t Mile)
+{
+    Mile *= 103;
+    Mile /= 64;
+    return Mile;
+}
+
+void Data_SwapWord(uint32_t *pData1, uint32_t *pData2)
+{
+	uint32_t psw;
+	if ((*pData1) > (*pData2))
+	{
+		psw = (*pData2);
+		(*pData2) = (*pData1);
+		(*pData1) = psw;
+	}
+}
+
+
+void Data_SortNWord(uint32_t *SortData, uint32_t len)
+{
+	uint8_t n = 0, m;
+	for (; n < len - 1; n++)
+	{
+		for (m = n + 1; m < len; m++)
+		{
+			Data_SwapWord((SortData + n), (SortData + m));
+		}
+	}
+}
+
+
+
+

Application/CommonInterface.h

+#ifndef _COMMON_INTERFACE_H_
+#define _COMMON_INTERFACE_H_
+
+#include "stdint.h"
+
+/*COMMON INTERFACE*/
+typedef enum
+{
+    CAN_SIG_NORMAL = 0u,
+    CAN_SIG_LOST = 0x55U,
+} CAN_MSG_Status_t;
+
+typedef enum
+{
+    EX_OK = 0u,
+    EX_ERR,
+} _Fun_Res;
+
+typedef enum
+{
+    COMMON_POWER_OFF = 0x00u,
+    COMMON_POWER_ON = 0x01u,
+    COMMON_POWER_UNKNOW = 0xFFu,
+} COMMON_PowerStatus_t;
+
+typedef enum
+{
+    COMMON_InValid = 0X00U,
+    COMMON_Valid = 0X01U,
+    COMMON_Valid_UNKNOW = 0XFFU,
+} DataValid_t;
+
+typedef enum
+{
+    CAN_MSG_TX_CYCLE = 0u,
+    CAN_MSG_TX_CYCKE_EVENT,
+} CAN_TX_Type_t;
+
+typedef enum
+{
+    MSG_STD = 0u,
+    MSG_EXT,
+} CAN_MSG_FORMAT_t;
+
+/*COMMON INTERFACE END*/
+
+typedef enum
+{
+    Bus_Sleep_Mode,
+    Pre_Bus_Sleep_Mode,
+    Network_Mode,
+} NM_Mode_t;
+
+extern void Common_DataInit(void);
+extern void Common_Input_Para(void);
+extern uint8_t Common_Get_IG_Sts(void);
+extern DataValid_t Common_Get_IG_Sts_Valid(void);
+extern void Common_Set_IG_Sts(COMMON_PowerStatus_t Val);
+extern void Common_Set_IG_Sts_Valid(DataValid_t Val);
+extern uint16_t Common_Get_Act_V_Speed(void);
+extern uint16_t Common_Get_Disp_V_Speed(void);
+extern DataValid_t Common_Get_Act_V_Speed_Valid(void);
+extern DataValid_t Common_Get_Disp_V_Speed_Valid(void);
+extern void Common_Set_Act_V_Speed(uint32_t Val);
+extern void Common_Set_Disp_V_Speed(uint32_t Val);
+extern uint16_t Common_Get_TireSize(void);
+extern void Common_Set_Act_V_Speed_Valid(DataValid_t Val);
+extern void Common_Set_Disp_V_Speed_Valid(DataValid_t Val);
+extern uint16_t Common_Get_DispSpeed(void);
+extern uint16_t Get_Self(void);
+extern uint32_t Common_GetIgnOnTime(void);  /*ms*/
+extern uint32_t Common_GetIgnOffTime(void); /*ms*/
+extern uint32_t Common_GetIgnOnTimeL(void);
+
+
+
+extern uint32_t Data_Km_To_Mile(uint32_t Km);
+extern uint32_t Data_Mile_To_Km(uint32_t Mile);
+
+void Data_SwapWord(uint32_t *pData1, uint32_t *pData2);
+void Data_SortNWord(uint32_t *SortData, uint32_t len);
+
+#endif

Application/Data_Coolant.c

+#include "Data_Coolant.h"
+#include "Components.h"
+#include "Backlight.h"
+#include "Battery_Voltage.h"
+#include "PowerManagement\PowerManag_user.h"
+
+#define Coolant_DATA_TIME 50u /*这里填写多长时间采集一个数据，单位ms*/
+#define Coolant_DATA_NUM 20u  /*水温电阻采集数据总数 最大255*/
+#define Coolant_CAL_START 5u  /*数据排序后取中间部分计算平均：起始*/
+#define Coolant_CAL_END 15u   /*数据排序后取中间部分计算平均：结束*/
+
+#define RETURN_DIFFERENCE 25u /*判断上升或下降的回差，精度0.1*/
+
+#define Coolant_SEG_UP 0u
+#define Coolant_SEG_DOWN 1u
+
+uint16_t g_u16CoolantData[Coolant_DATA_NUM];
+uint8_t g_u8CoolantDataCount = 0u;
+
+/*** 水温上升表格 ***/
+static const uint16_t Water_Temperature_Table_Up [9u] =
+    /*显示段：| 0 | 1 |  2   |  3  | 4 |  5  | 6 | 7 | 8 |  ...*/
+{30, 230,350,500,650,1000,1350,1850,2650}; // 上升时小于等于表值则熄灭相应段
+
+/*** 水温下降表格 ***/
+static const uint16_t Water_Temperature_Table_Dn [ 9u ] =
+    /*显示段：|    0     |    1     |    2     |    3     |    4     |      ...*/
+{60,260,380,530,680,1030,1380,1880,2680}; // 下降时小于等于表值则熄灭相应段
+
+/*** 水温上升表格 ***/
+static const uint16_t Water_TemperatureCan_Table_Up [9u] =
+    /*显示段：| 0 | 1 |  2   |  3  | 4 |  5  | 6 | 7 | 8 |  ...*/
+    {3180,3280,3380,3480,3580,3680,3780,3930,4330};    // 上升时小于等于表值则熄灭相应段
+
+/*** 燃油液位下降表格 ***/
+static const uint16_t Water_TemperatureCan_Table_Dn [ 9u ] =
+    /*显示段：|    0     |    1     |    2     |    3     |    4     |      ...*/
+    {3150,3250,3350,3450,3550,3650,3750,3900,4300};    // 下降时小于等于表值则熄灭相应段
+
+uint16_t CoolantR = 0u; /*滤波后的水温电阻，精度0.1*/
+static uint16_t Coolantpercentage_last = 0u;
+static uint16_t CoolantpercentageVal = 0u;
+uint8_t g_u8DesCoolantSetp = 0u;
+static uint8_t g_u8CurCoolantSetp = 0u;
+static uint16_t percentage;
+static uint16_t Coolant_Self_Inspection_Stage = 0u;
+static uint8_t Coolant_Timerf = 0u;
+static uint8_t Last = 0u;
+uint8_t g_u8CoolantInitFlag = 0u;
+uint8_t g_u8CoolantEmergency_StopFlag = 0u;
+uint8_t g_u8CoolantStateInitFlag = 0u;
+uint8_t g_u8CoolantDir = Coolant_SEG_UP;
+uint16_t Coolantpercentage = 0u;
+CoolantTemperature CoolantTemperatureCtrl;
+CoolantSensorSts_t CoolantSensorState = CoolantSensorNormal;
+uint16_t g_u16CoolantSensorNormalTime = 0u;
+uint32_t g_u16CoolantCanValue = 0u;
+uint16_t g_u16CoolantSensorShortTime = 0u;
+uint16_t g_u16CoolantSensorOpenTime = 0u;
+uint16_t timer_Staus = 0;
+uint32_t  CoolantNumChangeTime = 0;
+uint32_t CoolantNumTime = 0;
+uint8_t g_u8CoolantADCompleteFlg = 0u;
+uint8_t  g_u8DeCoolantSetp = 0;
+static uint16_t g_DropoutTime = 0u;
+static uint16_t CoolantSensorStaus = 1;
+static uint16_t Coolant_SensorStaus = 0;
+static uint8_t g_u8CoolantRedFlg = 0u;
+static uint16_t Coolant_Efficacious = 0;
+static uint16_t CooltimeCount = 0;
+uint8_t DstSeg = 0u;
+uint8_t C_DstSeg = 0u;
+uint32_t Coolant_C_Value_Last = 0;
+static uint16_t Coolant_Value_Last = 0;
+void Coolant_KL30_Init(void)
+{
+    g_u8DesCoolantSetp = 0u;
+    g_u8CurCoolantSetp = 0u;
+    Coolant_Timerf = 0u;
+    Last = 0u;
+    Coolant_Self_Inspection_Stage = 0u;
+    Coolant_Efficacious = 0;
+    g_u8CoolantInitFlag = 1u;
+    g_u8CoolantStateInitFlag = 1u;
+    CoolantSensorStaus = 1;
+    g_u8CoolantDir = Coolant_SEG_UP;
+    CoolantSensorState = CoolantSensorNormal;
+    g_u16CoolantSensorNormalTime = 0u;
+    g_u16CoolantSensorShortTime = 0u;
+    g_u16CoolantSensorOpenTime = 0u;
+    CoolantNumChangeTime = 0u;
+    CoolantNumTime = 0u;
+    timer_Staus = 0u;
+    g_u8CoolantADCompleteFlg = 0u;
+    g_u8DeCoolantSetp = 0u;
+    Coolant_SensorStaus = 0u;
+    g_DropoutTime = 0u;
+    g_u8CoolantRedFlg = 0u;
+    Coolantpercentage = 0u;
+    g_u16CoolantCanValue = 0u;
+    DstSeg = 0u;
+    C_DstSeg = 0u;
+    Coolant_C_Value_Last = 0u;
+    Coolant_Value_Last = 0u;
+    g_u8CoolantEmergency_StopFlag = 0u;
+}
+
+void Coolant_KL15_Init(void)
+{
+    g_u8DesCoolantSetp = 0u;
+    g_u8CurCoolantSetp = 0u;
+    Coolant_Efficacious = 0;
+    Coolant_Timerf = 0u;
+    Last = 0u;
+    Coolant_Self_Inspection_Stage = 0u;
+    g_u8CoolantInitFlag = 1u;
+    g_u8CoolantStateInitFlag = 1u;
+    CoolantSensorStaus = 1;
+    g_u8CoolantDir = Coolant_SEG_UP;
+    CoolantSensorState = CoolantSensorNormal;
+    g_u16CoolantSensorNormalTime = 0u;
+    g_u16CoolantSensorShortTime = 0u;
+    g_u16CoolantSensorOpenTime = 0u;
+    CoolantNumChangeTime = 0u;
+    CoolantNumTime = 0u;
+    timer_Staus = 0u;
+    g_u8CoolantADCompleteFlg = 0u;
+    g_u8DeCoolantSetp = 0u;
+    Coolant_SensorStaus = 0u;
+    g_DropoutTime = 0u;
+    g_u8CoolantRedFlg = 0u;
+    Coolantpercentage = 0u;
+    g_u16CoolantCanValue = 0u;
+    DstSeg = 0u;
+    C_DstSeg = 0u;
+    Coolant_C_Value_Last = 0u;
+    Coolant_Value_Last = 0u;
+    g_u8CoolantEmergency_StopFlag = 0u;
+}
+
+void Coolant_R_Cal(uint8_t deltaTime)
+{
+    uint16_t CoolantRes = 0;
+    uint8_t i, j;
+    uint32_t temp32;
+
+
+    if (g_u8CoolantStateInitFlag)
+    {
+        CoolantR = ADC_Read_Signal(ADC_CH_COOLANT_TEMP_R);
+    }
+
+    if (CooltimeCount >= Coolant_DATA_TIME)
+    {
+        CooltimeCount = 0;
+        if (g_u8CoolantDataCount < Coolant_DATA_NUM)
+        {
+            /*获取水温电阻*/
+            CoolantRes = ADC_Read_Signal(ADC_CH_COOLANT_TEMP_R);
+
+            /*四舍五入*/
+            if (CoolantRes < 65535)
+            {
+                if ((CoolantRes % 10u) >= 5u)
+                {
+                    CoolantRes += 5u;
+                }
+            }
+            else
+            {
+                CoolantRes = 0xFFFF;
+            }
+            /*由小到大插入数据*/
+            for (i = 0; i < g_u8CoolantDataCount; i++)
+            {
+                if (CoolantRes < g_u16CoolantData[i])
+                {
+                    break;
+                }
+            }
+            for (j = g_u8CoolantDataCount; j > i; j--)
+            {
+                g_u16CoolantData[j] = g_u16CoolantData[j - 1];
+            }
+            g_u16CoolantData[i] = CoolantRes;
+            g_u8CoolantDataCount++;
+        }
+        else
+        {
+            /*一组数据采集完毕，取中间部分计算平均值*/
+            temp32 = 0;
+            for (i = Coolant_CAL_START; i < Coolant_CAL_END; i++)
+            {
+                temp32 += g_u16CoolantData[i];
+            }
+            CoolantR = (uint16_t)(temp32 / (Coolant_CAL_END - Coolant_CAL_START));
+            g_u8CoolantDataCount = 0u;
+            g_u8CoolantADCompleteFlg = 1u;
+        }
+    }
+    CooltimeCount += deltaTime;
+}
+
+void Coolant_State_Check(uint8_t deltaTime)
+{
+    if (Coolant_Efficacious != 1)//can在线
+    {
+        if (CoolantR < 30)
+        { /*短路3*/
+            g_u16CoolantSensorOpenTime = 0u;
+            g_u16CoolantSensorNormalTime = 0u;
+            if ((g_u16CoolantSensorShortTime > 3000u) || ((g_u8CoolantStateInitFlag) && (g_u16CoolantSensorShortTime > 3000u)))
+            {
+                CoolantSensorState = CoolantSensorShortCircuit;
+                g_u8DesCoolantSetp = 0u;
+                g_u8CurCoolantSetp = 8u;
+                g_u8CoolantInitFlag = 1u;
+                g_u8CoolantStateInitFlag = 0u;
+                g_u8CoolantDir = Coolant_SEG_UP;
+            }
+            else
+            {
+                g_u16CoolantSensorShortTime += deltaTime;
+            }
+        }
+        else if (CoolantR > 5000u)
+        { /*开路 500*/
+            g_u16CoolantSensorShortTime = 0u;
+            g_u16CoolantSensorNormalTime = 0u;
+            if ((g_u16CoolantSensorOpenTime > 3000u) || ((g_u8CoolantStateInitFlag) && (g_u16CoolantSensorOpenTime >= 3000u)))
+            {
+                CoolantSensorState = CoolantSensorOpenCircuit;
+                g_u8DesCoolantSetp = 0u;
+                g_u8CurCoolantSetp = 8u;
+                g_u8CoolantInitFlag = 1u;
+                g_u8CoolantStateInitFlag = 0u;
+                g_u8CoolantDir = Coolant_SEG_UP;
+            }
+            else
+            {
+                g_u16CoolantSensorOpenTime += deltaTime;
+            }
+        }
+        else
+        {
+            g_u16CoolantSensorShortTime = 0u;
+            Coolant_Efficacious = 0u;
+            g_u16CoolantSensorOpenTime = 0u;
+            CoolantSensorState = CoolantSensorNormal;
+            g_u8CoolantStateInitFlag = 0u;
+        }
+    }
+    else
+    {
+        g_u16CoolantSensorOpenTime = 0u;
+        g_u16CoolantSensorShortTime = 0u;
+    }
+}
+
+void Coolant_Gauges_Cal(uint8_t deltaTime)
+{
+    static uint16_t time = 0u;
+    static uint16_t timer = 0u;
+    static uint16_t timerA = 0u;
+    g_u16CoolantCanValue = Get_CAN_CH0_ID_101_Sig_ECU_Engine_Temperature();
+    if ((CAN_MSG_Status(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_101_Msg_Count) == CAN_SIG_NORMAL) && (g_u16CoolantCanValue != 0xFFFF))//can在线且不等于FFFF
+    {
+        Coolant_Efficacious = 1u;
+        timerA = 0u;
+        if ((g_u16CoolantCanValue < 2380u))//小于零下35度
+        {
+            g_u8DesCoolantSetp = 0u;
+            CoolantSensorState = CoolantSensorNormal;
+        }
+        else if(g_u16CoolantCanValue >= 4330u)//大于160度
+        {
+            g_u8DesCoolantSetp = 8u;
+            CoolantSensorState = CoolantSensorNormal;
+        }
+        else
+        {
+            if (g_u16CoolantCanValue > Coolant_C_Value_Last) // 新燃油液位高于前次燃油液位,查上升表
+            {
+                while (C_DstSeg < 9u)
+                {
+                    if (g_u16CoolantCanValue < Water_TemperatureCan_Table_Up[C_DstSeg])
+                        break;
+                    C_DstSeg++;
+                }
+            }
+            else if (g_u16CoolantCanValue < Coolant_C_Value_Last) // 新燃油液位低于前次燃油液位,查下降表
+            {
+                while (C_DstSeg)
+                {
+                    if (g_u16CoolantCanValue > Water_TemperatureCan_Table_Dn[C_DstSeg - 1u])
+                        break;
+                    C_DstSeg--;
+                }
+            }
+            Coolant_C_Value_Last = g_u16CoolantCanValue;
+            g_u8DesCoolantSetp = C_DstSeg;
+            CoolantSensorState = CoolantSensorNormal;
+        }
+        if (Common_GetIgnOnTime() > 1950u)//自检后
+        {
+            g_u8CoolantRedFlg = 0u;
+            timer += deltaTime;
+            if (g_u8CoolantInitFlag)
+            {
+                g_u8CoolantInitFlag = 0u;
+                timer = 0u;
+                g_u8CurCoolantSetp = g_u8DesCoolantSetp;
+            }
+            if (g_DropoutTime < 12000u)//自检后立即指示
+            {
+                g_DropoutTime += deltaTime;
+                if (CoolantSensorStaus == 1u)
+                {
+                    CoolantSensorStaus = 2u;
+                    Coolant_Value_Last = g_u8DesCoolantSetp;
+                }
+                if (Coolant_Value_Last == g_u8DesCoolantSetp)
+                {
+                    g_u8CurCoolantSetp = g_u8DesCoolantSetp;
+                    Coolant_Value_Last = g_u8DesCoolantSetp;
+                }
+            }
+            else
+            {
+            }
+            if (timer >= 12000)
+            { /* 12S变化一格 */
+                timer = 0;
+                if (g_u8CurCoolantSetp < g_u8DesCoolantSetp)
+                {
+                    g_u8CurCoolantSetp++;
+                }
+                else if (g_u8CurCoolantSetp > g_u8DesCoolantSetp)
+                {
+                    g_u8CurCoolantSetp--;
+                }
+            }
+
+            if (g_u8CurCoolantSetp == g_u8DesCoolantSetp)
+            {
+                timer = 0u;
+            }
+        }
+        else
+        {
+            g_u8CoolantInitFlag = 1u;
+        }
+    }
+    else
+    {
+        if ((CoolantSensorState == CoolantSensorNormal) && (CoolantR <= 5000u) && (CoolantR > 30u))//硬线判断
+        {
+            timerA = 0u;
+            Coolant_Efficacious = 0u;
+            /*采集完第一组数据后，开始计算水温格数*/
+
+            if (g_u8CoolantInitFlag)
+            {
+            }
+            if (CoolantR < Coolant_Value_Last) // 新燃油液位高于前次燃油液位,查上升表
+            {
+                while (DstSeg)
+                {
+
+                    if (CoolantR > Water_Temperature_Table_Up[DstSeg - 1u])
+                    {
+                        break;
+                    }
+                    DstSeg--;
+                }
+            }
+            else if (CoolantR > Coolant_Value_Last) // 新燃油液位低于前次燃油液位,查下降表
+            {
+                while (DstSeg < 9u)
+                {
+                    if (CoolantR < Water_Temperature_Table_Dn[DstSeg])
+                    {
+                        break;
+                    }
+                    DstSeg++;
+                }
+            }
+            Coolant_Value_Last = CoolantR;
+            g_u8DesCoolantSetp = 9u - DstSeg;
+
+            /*IGN ON 2秒/故障恢复后，开始走格  立即指向当前格*/
+            if (Common_GetIgnOnTime() >= 2000u)
+            {
+                      time += deltaTime;
+                if (g_u8CoolantInitFlag)
+                {
+                    g_u8CoolantInitFlag = 0u;
+                    time = 0u;
+                    g_u8CurCoolantSetp = g_u8DesCoolantSetp;
+                }
+                if (g_DropoutTime < 12000u)
+                {
+                    g_DropoutTime += deltaTime;
+                    if (CoolantSensorStaus == 1u)
+                    {
+                        CoolantSensorStaus = 2u;
+                        Coolant_Value_Last = g_u8DesCoolantSetp;
+                    }
+                    if (Coolant_Value_Last == g_u8DesCoolantSetp)
+                    {
+                        g_u8CurCoolantSetp = g_u8DesCoolantSetp;
+                        Coolant_Value_Last = g_u8DesCoolantSetp;
+                    }
+                }
+                else
+                {
+                }
+                if (time >= 12000u)
+                { /* 12S变化一格 */
+                    time = 0u;
+                    if (g_u8CurCoolantSetp < g_u8DesCoolantSetp)
+                    {
+                        g_u8CurCoolantSetp++;
+                    }
+                    else if (g_u8CurCoolantSetp > g_u8DesCoolantSetp)
+                    {
+                        g_u8CurCoolantSetp--;
+                    }
+                }
+
+                if (g_u8CurCoolantSetp == g_u8DesCoolantSetp)
+                {
+                    time = 0u;
+                }
+            }
+        }
+        /*can和硬线均掉线*/
+        else
+        {
+            timer_Staus = 0u;
+            g_u8CoolantRedFlg = 0u;
+            timerA += deltaTime;
+            if (g_u8CoolantInitFlag)
+            {
+                g_u8CoolantInitFlag = 0u;
+                g_u8CurCoolantSetp = g_u8DesCoolantSetp;
+            }
+            if (Coolant_Efficacious == 1u)
+            {
+                CoolantSensorState = CoolantSensorNormal;
+                if (g_u16CoolantCanValue != 0xFFFF)
+                {
+                    if (timerA >= 2000u) // 2秒后判can掉线
+                    {
+                        g_u8CurCoolantSetp = 8u;
+                        CoolantSensorState = CoolantSensorShortCircuit;
+                        Coolant_Efficacious = 2u;
+                        g_u8CoolantInitFlag = 1u;
+                        Coolant_SensorStaus = 1u;
+                    }
+                }
+                else
+                {
+                     if (timerA >= 3000u) // 3秒后判can掉线
+                    {
+                        g_u8CurCoolantSetp = 8u;
+                        CoolantSensorState = CoolantSensorShortCircuit;
+                        Coolant_Efficacious = 2u;
+                        g_u8CoolantInitFlag = 1u;
+                        Coolant_SensorStaus = 1u;
+                    }
+                }
+            }
+            if (Coolant_Efficacious == 0u)
+            {
+                CoolantSensorState = CoolantSensorNormal;
+                if (timerA >= 3000u)//3秒后判硬线掉线
+                {
+                    g_u8CurCoolantSetp = 8u;
+                    CoolantSensorState = CoolantSensorShortCircuit;
+                    Coolant_Efficacious = 2u;
+                    g_u8CoolantInitFlag = 1u;
+                    Coolant_SensorStaus = 1u;
+                }
+            }
+        }
+    }
+    /*水温信号由掉线到在线3秒判断*/
+    if(Common_GetIgnOnTime() >= 2000u)
+    {
+        if (CoolantSensorState == CoolantSensorNormal)
+        {
+            if (Coolant_SensorStaus == 1u)
+            {
+                timer_Staus += deltaTime;
+                if (timer_Staus <= 3000u)
+                {
+                    g_u8CurCoolantSetp = 8u;
+                    CoolantSensorState = CoolantSensorShortCircuit;
+                    Coolant_Efficacious = 2u;
+                    g_u8CoolantInitFlag = 1u;
+                }
+                else
+                {
+                    timer_Staus = 0u;
+                    Coolant_SensorStaus = 0u;
+                }
+            }
+            if ((CoolantR <= 5000u) && (CoolantR > 30u))
+            {
+            }
+            else
+            {
+                if (CAN_RX_Get_TimeStamp(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_101_Msg_Count) >= 20u)
+                {
+                    timer_Staus = 0u;
+                }
+            }
+        }
+        else
+        {
+            timer_Staus = 0;
+            // Coolant_SensorStaus = 0u;
+        }
+    }
+}
+/*水温数显*/
+void Coolant_Percentage_Figure(uint8_t deltaTime)
+{
+
+    if (Coolant_SensorStaus == 1u)//掉线置零
+    {
+        CoolantTemperatureCtrl.CoolantTemperatureCurrent = 0u;
+        CoolantpercentageVal = 0u;
+        Coolantpercentage = 0u; 
+        percentage = 0u;
+    }
+    else//水温信号在线
+    {
+        if (CoolantR > 3985u)// 短路开路置0
+        {
+            CoolantpercentageVal = 0u;
+        }
+        if ((CoolantR <= 3985u) && (CoolantR > 2650u))
+        {
+            CoolantpercentageVal = ((3985u - CoolantR) / 29u); // 减去-35摄氏度的阻值1015
+        }
+        else if ((CoolantR <= 2650u) && (CoolantR > 1850u))
+        {
+            CoolantpercentageVal = ((2650u - CoolantR) / 80u) + 44u;
+        }
+        else if ((CoolantR <= 1850u) && (CoolantR > 1350u))
+        {
+            CoolantpercentageVal = ((1850u - CoolantR) / 50u) + 54u;
+        }
+        else if ((CoolantR <= 1350u) && (CoolantR > 1000u))
+        {
+            CoolantpercentageVal = ((1350u - CoolantR) / 35u) + 64u;
+        }
+        else if ((CoolantR <= 1000u) && (CoolantR > 650u))
+        {
+            CoolantpercentageVal = ((1000u - CoolantR) / 35u) + 74u;
+        }
+        else if ((CoolantR <= 650u) && (CoolantR > 500u))
+        {
+            CoolantpercentageVal = ((650u - CoolantR) / 15u) + 84u;
+        }
+        else if ((CoolantR <= 500u) && (CoolantR > 350u))
+        {
+            CoolantpercentageVal = ((500u - CoolantR) / 15u) + 94u;
+        }
+        else if ((CoolantR <= 350u) && (CoolantR > 230u))
+        {
+            CoolantpercentageVal = ((350u - CoolantR) / 8u) + 104u;
+        }
+        else if ((CoolantR <= 230u) && (CoolantR > 30u))
+        {
+            CoolantpercentageVal = ((230u - CoolantR) / 5u) + 119u;
+            if ((CoolantR <= 35u))
+            {
+                CoolantpercentageVal = 160u;
+            }
+        }
+        if (Coolant_Efficacious == 1u)//can在线
+        {
+
+            if (g_u16CoolantCanValue > 2730u)
+            {
+                CoolantpercentageVal = (uint16_t)((g_u16CoolantCanValue - 2730u) / 10u);
+            }
+            else
+            {
+                CoolantpercentageVal = 0u;
+            }
+            if (g_u16CoolantCanValue >= 4330u)
+            {
+                CoolantpercentageVal = 160u;
+            }
+        }
+        /*格数有变化*/
+        if (g_u8DesCoolantSetp != g_u8CurCoolantSetp)
+        {
+            /*计算时间*/
+            if ((g_u8DeCoolantSetp == 1u) || (g_u8DeCoolantSetp == 2u))
+            {
+                CoolantNumTime += deltaTime;
+            }
+            else
+            {
+                // if (Coolantpercentage == CoolantpercentageVal)
+                // {
+
+                if (g_u8DesCoolantSetp > g_u8CurCoolantSetp)//目标格数大于当前格数
+                {
+                    if (Coolantpercentage < CoolantpercentageVal)
+                    {
+                        g_u8DeCoolantSetp = 1u;
+                        CoolantNumChangeTime = ((g_u8DesCoolantSetp - g_u8CurCoolantSetp)) * 12000u;
+                        CoolantNumChangeTime = CoolantNumChangeTime / (CoolantpercentageVal - Coolantpercentage);
+                    }
+                }
+                else//目标格数小于当前格数
+                {
+                    if (Coolantpercentage > CoolantpercentageVal)
+                    {
+                        g_u8DeCoolantSetp = 2u;
+                        CoolantNumChangeTime = ((g_u8CurCoolantSetp - g_u8DesCoolantSetp)) * 12000u;
+                        CoolantNumChangeTime = CoolantNumChangeTime / (Coolantpercentage - CoolantpercentageVal);
+                    }
+                }
+                // }
+            }
+            
+            if (Get_Self() != 1)//自检期间不进入
+            {
+                if (CoolantNumTime > CoolantNumChangeTime)
+                {
+                    if (g_u8DesCoolantSetp > g_u8CurCoolantSetp)
+                    {
+                        Coolantpercentage += 1u;
+                    }
+                    else
+                    {
+                        Coolantpercentage -= 1u;
+                    }
+                    CoolantNumTime = 0u;
+                }
+            }
+            if (g_u8DeCoolantSetp == 1)
+            {
+                if (CoolantpercentageVal > percentage)
+                {
+                    // if (g_u8CoolantEmergency_StopFlag < 1)
+                    // {
+                        percentage = Coolantpercentage;
+                    // }
+                }
+                else
+                {
+                    //急停
+                    // g_u8CoolantEmergency_StopFlag++;
+                }
+            }
+            if (g_u8DeCoolantSetp == 2)
+            {
+                if (CoolantpercentageVal < percentage)
+                {
+                    // if (g_u8CoolantEmergency_StopFlag < 1)
+                    // {
+                        percentage = Coolantpercentage;
+                    // }
+                }
+                else
+                {
+                    //急停
+                    // g_u8CoolantEmergency_StopFlag++;
+                }
+            }
+            
+        }
+        else//格数无变化时
+        {
+            g_u8CoolantEmergency_StopFlag = 0U;
+            Coolantpercentage = CoolantpercentageVal;
+            CoolantNumTime = 0u;
+            CoolantNumChangeTime = 0u;
+            g_u8DeCoolantSetp = 0u;
+        }
+    }
+
+    if ((Get_Self() == 1u) || (timer_Staus == 3000u))//自检或掉线恢复时
+    {
+        if (CoolantR > 3985u)// 短路开路置0
+        {
+            CoolantpercentageVal = 0u;
+        }
+        if ((CoolantR <= 3985u) && (CoolantR > 2650u))
+        {
+            CoolantpercentageVal = ((3985u - CoolantR) / 29u); // 减去-35摄氏度的阻值1015
+        }
+        else if ((CoolantR <= 2650u) && (CoolantR > 1850u))
+        {
+            CoolantpercentageVal = ((2650u - CoolantR) / 80u) + 44u;
+        }
+        else if ((CoolantR <= 1850u) && (CoolantR > 1350u))
+        {
+            CoolantpercentageVal = ((1850u - CoolantR) / 50u) + 54u;
+        }
+        else if ((CoolantR <= 1350u) && (CoolantR > 1000u))
+        {
+            CoolantpercentageVal = ((1350u - CoolantR) / 35u) + 64u;
+        }
+        else if ((CoolantR <= 1000u) && (CoolantR > 650u))
+        {
+            CoolantpercentageVal = ((1000u - CoolantR) / 35u) + 74u;
+        }
+        else if ((CoolantR <= 650u) && (CoolantR > 500u))
+        {
+            CoolantpercentageVal = ((650u - CoolantR) / 15u) + 84u;
+        }
+        else if ((CoolantR <= 500u) && (CoolantR > 350u))
+        {
+            CoolantpercentageVal = ((500u - CoolantR) / 15u) + 94u;
+        }
+        else if ((CoolantR <= 350u) && (CoolantR > 230u))
+        {
+            CoolantpercentageVal = ((350u - CoolantR) / 8u) + 104u;
+        }
+        else if ((CoolantR <= 230u) && (CoolantR > 30u))
+        {
+            CoolantpercentageVal = ((230u - CoolantR) / 5u) + 119u;
+            if ((CoolantR <= 35u))
+            {
+                CoolantpercentageVal = 160u;
+            }
+        }
+        if ((CAN_MSG_Status(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_101_Msg_Count) == CAN_SIG_NORMAL) && (g_u16CoolantCanValue != 0xFFFF))
+        {
+            if (g_u16CoolantCanValue > 2730u)
+            {
+                CoolantpercentageVal = (uint16_t)((g_u16CoolantCanValue - 2730u) / 10u);
+            }
+            else
+            {
+                CoolantpercentageVal = 0u;
+            }
+            if (CoolantpercentageVal >= 160u)
+            {
+                CoolantpercentageVal = 160u;
+            }
+        }
+
+        CoolantTemperatureCtrl.CoolantTemperatureCurrent = CoolantpercentageVal;
+        // percentage = CoolantpercentageVal;
+        Coolantpercentage = CoolantpercentageVal;
+    }
+    // if (Get_Voltage_Anomaly() == 2)
+    // {
+    //     CoolantTemperatureCtrl.CoolantTemperatureCurrent = CoolantpercentageVal;
+    // }
+    if (Coolantpercentage >=  Coolantpercentage_last) // 上升
+    {
+       percentage = Coolantpercentage;
+        Coolantpercentage_last = Coolantpercentage;
+    }
+    else // 下降
+    {
+        if (((Coolantpercentage_last - Coolantpercentage) > 2u) || (Coolantpercentage == 0u))
+        {
+           percentage = Coolantpercentage;
+            Coolantpercentage_last = Coolantpercentage;   
+        }
+        else // 保持上一状态
+        {
+           percentage =Coolantpercentage_last;
+        }
+    }
+    CoolantTemperatureCtrl.Goal = percentage;
+    Duty_Cycle_Delta(CoolantTemperatureCtrl.Goal, &CoolantTemperatureCtrl.CoolantTemperatureCurrent, &CoolantTemperatureCtrl.Time);
+}
+
+void Coolant_Self_InspectionOld(void)
+{
+    if (Common_GetIgnOnTime() < 2000u)
+    {
+        if (Get_Voltage_Anomaly() == 2u)
+        {
+        }
+        else
+        {
+            if (Common_Get_IG_Sts() == COMMON_POWER_OFF)
+            {
+                Coolant_Self_Inspection_Stage = 0u;
+                Coolant_Timerf = 0u;
+            }
+            else
+            {
+
+                if (Get_Dis_Old_Staus() == 3u)
+                {
+                    Coolant_Timerf = 0u;
+                }
+                Coolant_Self_Inspection_Stage = 1u;
+                if (Coolant_Timerf <= 20u)
+                {
+                    CoolantSensorState = CoolantSensorNormal;
+                    g_u8CurCoolantSetp = 0u;
+                    if (GetLcdInitSt() == 1u)
+                    {
+                        if (Get_Uptime_Staus() == 1u)
+                        {
+                            Coolant_Timerf++;
+                        }
+                    }
+                    if (Coolant_Timerf >= 3u)
+                    {
+                        if (Coolant_Self_Inspection_Stage == 1u)
+                        {
+                            if (Coolant_Timerf <= 10u)
+                            {
+                                Last = ((Coolant_Timerf) * 100u) / 125u;
+                                g_u8CurCoolantSetp = Last;
+                            }
+                            else
+                            {
+                                Last = 8u - (((Coolant_Timerf - 10u) * 100u) / 125u);
+                                g_u8CurCoolantSetp = Last;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    Coolant_Self_Inspection_Stage = 2u;
+                }
+            }
+        }
+    }
+}
+
+void Coolant_Cal_Sevice(uint8_t deltaTime)
+{
+    /*检测水温电阻状态*/
+    Coolant_State_Check(deltaTime);
+
+    /*显示水温格*/
+    Coolant_Gauges_Cal(deltaTime);
+    Coolant_Percentage_Figure(deltaTime);
+}
+/*0正常，1表格红色*/
+uint8_t Get_CurCoolantRed(void)
+{
+    return g_u8CoolantRedFlg;
+}
+/*返回百分比%*/
+uint16_t Get_Coolant_Percentage(void)
+{
+    return CoolantTemperatureCtrl.CoolantTemperatureCurrent;
+}
+/*格数*/
+uint8_t Get_CurCoolantSetp(void)
+{
+    return g_u8CurCoolantSetp;
+}
+/*状态*/
+CoolantSensorSts_t Get_Coolant_Sensor_State(void)
+{
+    return CoolantSensorState;
+}
\ No newline at end of file

Application/Data_Coolant.h

+#ifndef DATA_COOLANT_H
+#define DATA_COOLANT_H
+
+#include "Components.h"
+
+typedef struct
+{
+    uint16_t Goal;
+    uint16_t CoolantTemperatureCurrent;
+    uint16_t Time;
+} CoolantTemperature;
+
+typedef enum{
+    CoolantSensorNormal = 0u,
+    CoolantSensorShortCircuit,
+    CoolantSensorOpenCircuit,
+}CoolantSensorSts_t;
+
+extern void Coolant_KL15_Init(void);
+extern void Coolant_KL30_Init(void);
+extern void Coolant_Cal_Sevice(uint8_t deltaTime);
+extern uint8_t Get_CurCoolantSetp(void);
+extern CoolantSensorSts_t Get_Coolant_Sensor_State(void);
+extern void Coolant_R_Cal(uint8_t deltaTime);
+extern uint8_t Get_CurCoolantRed(void);
+extern uint16_t Get_Coolant_Percentage(void);
+extern void Coolant_Percentage_Figure(uint8_t deltaTime);
+extern void Coolant_Self_InspectionOld(void);
+
+#endif

Application/Data_ESpeed.c

+
+#include "Data_ESpeed.h"
+#include "Components.h"
+#include "PowerManagement\PowerManag_user.h"
+#include  "CAN_CH0_CAN_Communication_Matrix.h"
+#include "Battery_Voltage.h"
+
+/*** 发动机转速 ***/
+uint16_t                DataESpeedActual = 0u;
+uint16_t                DataESpeedDisp = 0u;
+uint8_t                 DataESpeedValid = 0u;
+DataESpeedSamplerStruct DataESpeedSampler;
+DataESPeedDampingStruct DataESPeedDamping;
+DataESpeedIdleStruct    DataESpeedIdle;
+
+#define DATA_APPR_DIR_INC 0x01
+#define DATA_APPR_DIR_DEC 0x02
+static uint16_t ESpeed_Offline_timer = 0;
+uint16_t  Self_InspectionTimer = 0u;
+uint16_t Self_Inspection_Last = 0u;
+/******************************************************************************
+函数名：Data_Engine_Speed_KL30_Wakeup_Init
+功  能：发动机转速初始化函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数KL30初始化/Wakeup初始化被调用一次
+******************************************************************************/
+void Data_Engine_Speed_KL30_Wakeup_Init (void)
+{
+    DataESpeedIdle.Timer      = 0;
+    DataESpeedActual          = 0;
+    DataESpeedDisp            = 0;
+    DataESpeedValid           = 0;
+    DataESpeedSampler.Cnt     = 0;
+    DataESPeedDamping.Speed   = 0;
+    DataESPeedDamping.Delta   = 0;
+    DataESPeedDamping.Dir     = DATA_APPR_DIR_INC;
+    ESpeed_Offline_timer = 0;
+}
+
+/******************************************************************************
+函数名：Data_Engine_Speed_Processing_Service
+功  能：发动机转速数据处理函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数必须每20ms被调用一次
+******************************************************************************/
+void Data_Engine_Speed_Processing_Service ( void )
+{
+    uint8_t   i;
+    uint16_t  ESpeed;
+    uint16_t  Delta;
+    //第1步：获取实际转速值及转速有效性
+    if ( Common_Get_IG_Sts() == COMMON_POWER_ON )
+    {
+        if (CAN_MSG_Status(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_101_Msg_Count) == CAN_SIG_LOST)
+        {
+            if (ESpeed_Offline_timer >= 79)
+            {
+                DataESpeedValid = 0;
+                DataESpeedActual = 0;
+                DataESpeedSampler.Cnt = 0;
+            }
+            else
+            {
+                ESpeed_Offline_timer++;
+            }
+        }
+        else
+        {
+            ESpeed_Offline_timer = 0;
+            if (DataESpeedValid == 0)
+            {
+                DataESpeedValid = 1;
+                ESpeed = Get_CAN_CH0_ID_101_Sig_ECU_Engine_Speed() / 4u;
+                if (ESpeed > 10000u)
+                    ESpeed = 10000u;
+                DataESpeedActual = ESpeed;
+            }
+            else
+            {
+                DataESpeedSampler.Buffer[DataESpeedSampler.Cnt] = Get_CAN_CH0_ID_101_Sig_ECU_Engine_Speed() / 4;
+
+                i = DataESpeedSampler.Cnt;
+                while ( ( i > 0 ) && ( DataESpeedSampler.Buffer[i] < DataESpeedSampler.Buffer[i - 1] ) )
+                {
+                    ESpeed = DataESpeedSampler.Buffer[i];
+                    DataESpeedSampler.Buffer[i] = DataESpeedSampler.Buffer[i - 1];
+                    DataESpeedSampler.Buffer[i - 1] = ESpeed;
+                    i--;
+                }
+
+                DataESpeedSampler.Cnt++;
+                if ( DataESpeedSampler.Cnt >= 5 )
+                {
+                    DataESpeedSampler.Cnt = 0u;
+                    ESpeed  = DataESpeedSampler.Buffer[3];
+                    if ( ESpeed > 10000 )
+                         ESpeed = 10000u;
+                    DataESpeedActual = ESpeed;
+                }
+            }
+        }
+    }
+    else
+    {
+
+        DataESpeedValid = 0u;
+        DataESpeedActual = 0u;
+        DataESpeedSampler.Cnt = 0u;
+    }
+
+    //第2步：怠速模式
+    ESpeed = DataESpeedActual;
+#if 0
+    if ( ( ESpeed >= 500 ) && ( ESpeed <= 1000 ) )
+    {
+        DataESpeedIdle.Timer++;
+
+        if ( ESpeed > DataESpeedIdle.ESpeedBackup )
+            Delta = ESpeed - DataESpeedIdle.ESpeedBackup;
+        else
+            Delta = DataESpeedIdle.ESpeedBackup - ESpeed;
+
+        if ( DataESpeedIdle.Mode == 0 )
+        {
+            if ( Delta < 150 )
+            {
+                if ( DataESpeedIdle.Timer >= 200 )
+                {
+                    DataESpeedIdle.Mode  = 1;
+                    DataESpeedIdle.Timer = 0;
+                }
+            }
+            else
+                DataESpeedIdle.Timer = 0;
+
+            DataESpeedIdle.ESpeedBackup = ESpeed;
+        }
+        else
+        {
+            if ( Delta < 150 )
+            {
+                if ( DataESpeedIdle.Timer >= 200 )               //怠速模式下每10秒转速数据更新一次
+                {
+                    DataESpeedIdle.Timer = 0;
+                    DataESpeedIdle.ESpeedBackup = ESpeed;
+                }
+                else
+                    ESpeed = DataESpeedIdle.ESpeedBackup;
+            }
+            else                                                //转速变化大于等于300立即退出怠速模式
+            {
+                DataESpeedIdle.Mode  = 0;
+                DataESpeedIdle.Timer = 0;
+                DataESpeedIdle.ESpeedBackup = ESpeed;
+            }
+        }
+    }
+    else
+    {
+        DataESpeedIdle.Mode  = 0;
+        DataESpeedIdle.Timer = 0;
+        DataESpeedIdle.ESpeedBackup = ESpeed;
+    }
+#endif
+    //第3步：转速的阻尼处理
+    if ( ESpeed > DataESPeedDamping.Speed )                //实际值比当前显示值大时
+    {
+        Delta = ESpeed - DataESPeedDamping.Speed;
+
+        if ( DataESPeedDamping.Dir == DATA_APPR_DIR_INC )     //显示值正在向实际值增加,则维持当前方向调节增加速度
+        {
+            if ( DataESPeedDamping.Delta < Delta )              //当前增量小于显示值与实际值的差值,则提升增加的速度
+            {
+                DataESPeedDamping.Delta += DATA_ESPEED_INC_STEP;
+                if ( DataESPeedDamping.Delta > Delta )
+                    DataESPeedDamping.Delta = Delta;
+            }
+            else                                                //当前增量大于等于显示值与实际值的差值,保持增量与当前差值同步,增加的速度即逐步减小
+                DataESPeedDamping.Delta = Delta;
+
+            Delta  = DataESPeedDamping.Delta;
+            Delta /= DATA_ESPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_ESPEED_APPR_SPEED_MIN )
+                Delta = DATA_ESPEED_APPR_SPEED_MIN;
+
+            DataESPeedDamping.Speed += Delta;
+            if ( DataESPeedDamping.Speed > ESpeed )
+                DataESPeedDamping.Speed = ESpeed;
+        }
+        else                                                 //显示值正在减小,则尽快减速至速度为最小时更换方向
+        {
+            if ( DataESPeedDamping.Delta > DATA_ESPEED_DEC_STEP )
+                DataESPeedDamping.Delta -= DATA_ESPEED_DEC_STEP;
+            else
+                DataESPeedDamping.Delta = 0u;
+
+            Delta  = DataESPeedDamping.Delta;
+            Delta /= DATA_ESPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_ESPEED_APPR_SPEED_MIN )          //已减速至最小速度
+                DataESPeedDamping.Dir = DATA_APPR_DIR_INC;       //更换方向
+            else
+            {
+                if ( DataESPeedDamping.Speed > Delta )
+                    DataESPeedDamping.Speed -= Delta;
+                else
+                    DataESPeedDamping.Speed = 0u;
+            }
+        }
+    }
+    else if ( ESpeed < DataESPeedDamping.Speed )           //实际值比当前显示值小时
+    {
+        Delta = DataESPeedDamping.Speed - ESpeed;
+
+        if ( DataESPeedDamping.Dir == DATA_APPR_DIR_INC )     //显示值仍在增加,则尽快减速至速度为最小时更换方向
+        {
+            if ( DataESPeedDamping.Delta > DATA_ESPEED_DEC_STEP )
+                DataESPeedDamping.Delta -= DATA_ESPEED_DEC_STEP;
+            else
+                DataESPeedDamping.Delta = 0u;
+
+            Delta  = DataESPeedDamping.Delta;
+            Delta /= DATA_ESPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_ESPEED_APPR_SPEED_MIN )           //已减速至最小速度
+                DataESPeedDamping.Dir = DATA_APPR_DIR_DEC;        //更换方向
+            else
+            {
+                DataESPeedDamping.Speed += Delta;
+                if ( DataESPeedDamping.Speed > 10000u )
+                     DataESPeedDamping.Speed = 10000u;
+            }
+        }
+        else                                                  //显示值正在向实际值减小,则维持当前方向调节增加速度
+        {
+            if ( DataESPeedDamping.Delta < Delta )              //当前(负)增量小于显示值与实际值的差值,则提升减小的速度
+            {
+                DataESPeedDamping.Delta += DATA_ESPEED_INC_STEP;
+                if ( DataESPeedDamping.Delta > Delta )
+                    DataESPeedDamping.Delta = Delta;
+            }
+            else                                                //当前(负)增量大于等于显示值与实际值的差值,保持(负)增量与当前差值同步,减小的速度即逐步减小
+                DataESPeedDamping.Delta = Delta;
+
+            Delta  = DataESPeedDamping.Delta;
+            Delta /= DATA_ESPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_ESPEED_APPR_SPEED_MIN )
+                Delta = DATA_ESPEED_APPR_SPEED_MIN;
+
+            if ( DataESPeedDamping.Speed < ESpeed + Delta )
+                DataESPeedDamping.Speed  = ESpeed;
+            else
+                DataESPeedDamping.Speed -= Delta;
+        }
+    }
+    else                                                    //实际值与当前显示值相等时
+    {
+        Delta  = DataESPeedDamping.Delta;
+        Delta /= DATA_ESPEED_DAMPING_FACTOR;
+
+        if ( Delta > DATA_ESPEED_APPR_SPEED_MIN )             //当前的速度不是最小,说明数值正在增加/减小中,则继续原过程
+        {
+            if ( DataESPeedDamping.Delta > DATA_ESPEED_DEC_STEP ) //显示值越过了实际值,必然要先减速至最小速度,再改变方向返回实际值
+                DataESPeedDamping.Delta -= DATA_ESPEED_DEC_STEP;
+            else
+                DataESPeedDamping.Delta = 0;
+
+            Delta  = DataESPeedDamping.Delta;
+            Delta /= DATA_ESPEED_DAMPING_FACTOR;
+
+            if ( DataESPeedDamping.Dir == DATA_APPR_DIR_INC )   //显示值当前是增加方向
+            {
+                if ( Delta < DATA_ESPEED_APPR_SPEED_MIN )         //已减速至最小速度
+                    DataESPeedDamping.Dir = DATA_APPR_DIR_DEC;      //更换方向
+                else
+                {
+                    DataESPeedDamping.Speed += Delta;
+                    if ( DataESPeedDamping.Speed > 10000 )
+                         DataESPeedDamping.Speed = 10000u;
+                }
+            }
+            else                                                //显示值当前是减小方向
+            {
+                if ( Delta < DATA_ESPEED_APPR_SPEED_MIN )         //已减速至最小速度
+                    DataESPeedDamping.Dir = DATA_APPR_DIR_INC;      //更换方向
+                else
+                {
+                    if ( DataESPeedDamping.Speed > Delta )
+                        DataESPeedDamping.Speed -= Delta;
+                    else
+                        DataESPeedDamping.Speed = 0u;
+                }
+            }
+        }
+    }
+
+    // 第4步 增加回差
+    if ((Get_Self() != 1) && (Get_Uptime_Staus() != 0))
+    {
+        if (DataESpeedDisp <= 80)
+        {
+            DataESpeedDisp = DataESPeedDamping.Speed;
+        }
+        else
+        {
+            if (DataESpeedDisp < DataESPeedDamping.Speed)
+            {
+                DataESpeedDisp = DataESPeedDamping.Speed;
+            }
+            else
+            {
+                Delta = DataESpeedDisp - DataESPeedDamping.Speed;
+                if (Delta >= DATA_ESPEED_HYSTERESIS)
+                {
+                    DataESpeedDisp = DataESPeedDamping.Speed;
+                }
+            }
+        }
+    }
+}
+/*自检*/
+void Self_Inspection(void)
+{
+
+    if (Get_Voltage_Anomaly() == 2)
+    {
+    }
+    else
+    {
+        if (Common_Get_IG_Sts() == COMMON_POWER_OFF)
+        {
+            Self_InspectionTimer = 0u;
+            Self_Inspection_Last = 0u;
+            DataESpeedDisp = 0u;
+        }
+        else
+        {
+            if (Get_Uptime_Staus() == 0)
+            {
+                Self_InspectionTimer = 0u;
+                Self_Inspection_Last = 0u;
+            }
+            if (Get_Dis_Old_Staus() == 3)
+            {
+                Self_InspectionTimer = 0u;
+            }
+            if (Self_InspectionTimer <= 42u)
+            {
+                if (Self_InspectionTimer >= 1u)
+                {
+                    Self_InspectionTimer++;
+
+                    DataESpeedDisp = 0u;
+                    DataESpeedValid = 1u;
+                    if (Self_InspectionTimer <= 22)
+                    {
+                        Self_Inspection_Last += 500u;
+                        DataESpeedDisp = Self_Inspection_Last;
+                    }
+                    else
+                    {
+                        Self_Inspection_Last -= 500u;
+                        DataESpeedDisp = Self_Inspection_Last;
+                    }
+                }
+                else
+                {
+                    if (GetLcdInitSt() == 1)
+                    {
+                        if (Get_Uptime_Staus() == 1)
+                        {
+                            Self_InspectionTimer++;
+                        }                       
+                    }
+                }
+            }
+            else
+            {
+            }
+        }
+    }
+}
+
+uint8_t Get_EngineValid(void)
+{
+  return DataESpeedValid;
+}
+
+uint16_t Get_ActualEngineSpeed(void)
+{   
+    return DataESpeedActual;
+}
+
+uint16_t Get_DispEngineSpeed(void)
+{
+    return DataESpeedDisp;
+}

Application/Data_ESpeed.h

+#ifndef _Data_Espeed_H_
+#define _Data_Espeed_H_
+
+#include "common.h"
+
+/******************************************************************************
+发动机转速
+******************************************************************************/
+
+/*** 参数设置 ***/
+#define   DATA_ENGINE_RUNNING_THRESHOLD     400  //发动机运转阈值    
+#define   DATA_ENGINE_STOP_THRESHOLD        300  //发动机停止阈值
+
+#define   DATA_ESPEED_DAMPING_FACTOR        4    //阻尼系数
+#define   DATA_ESPEED_INC_STEP              10   //速度增加时慢加速速度变化步长
+#define   DATA_ESPEED_DEC_STEP              10   //方向改变时急减速速度变化步长
+#define   DATA_ESPEED_APPR_SPEED_MIN        20   //最小逼近速度
+#define   DATA_ESPEED_HYSTERESIS            80u   //回差    
+
+/*** 控制结构 ***/
+typedef struct
+{
+    uint16_t  Buffer[5];
+    uint8_t   Cnt;
+} DataESpeedSamplerStruct;            //转速采样结构
+
+typedef struct
+{
+    uint16_t  Speed;
+    uint16_t  Delta;
+    uint8_t   Dir;
+} DataESPeedDampingStruct;            //转速阻尼结构
+
+typedef struct
+{
+    uint16_t  ESpeedBackup;
+    uint16_t  Timer;
+    uint8_t   Mode;
+} DataESpeedIdleStruct;               //怠速处理结构
+
+
+/******************************************************************************
+函数名：Data_Engine_Speed_KL30_Wakeup_Init
+功  能：发动机转速初始化函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数KL30初始化/Wakeup初始化被调用一次
+******************************************************************************/
+void Data_Engine_Speed_KL30_Wakeup_Init (void);
+
+/******************************************************************************
+函数名：Data_Engine_Speed_Processing_Service
+功  能：发动机转速数据处理函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数必须每20ms被调用一次
+******************************************************************************/
+void Data_Engine_Speed_Processing_Service ( void );
+void Self_Inspection(void);
+uint8_t Get_EngineValid(void);
+
+uint16_t Get_ActualEngineSpeed(void);
+
+uint16_t Get_DispEngineSpeed(void);
+
+#endif

Application/Data_Fuel.c

+#include "Data_Fuel.h"
+#include "Components.h"
+#include "Backlight.h"
+#include "Battery_Voltage.h"
+#include "PowerManagement\PowerManag_user.h"
+
+#define FUEL_DATA_TIME 20u /*这里填写多长时间采集一个数据，单位ms*/
+#define FUEL_DATA_NUM 20u  /*燃油电阻采集数据总数 最大255*/
+#define FUEL_CAL_START 10u  /*数据排序后取中间部分计算平均：起始*/
+#define FUEL_CAL_END 20u   /*数据排序后取中间部分计算平均：结束*/
+
+#define RETURN_DIFFERENCE 25u /*判断上升或下降的回差，精度0.1*/
+
+#define FUEL_SEG_UP 0u
+#define FUEL_SEG_DOWN 1u
+
+static const uint16_t Fuel_Table_Up [9u] =
+    /*显示段：| 0 | 1 |  2   |  3  | 4 |  5  | 6 | 7 | 8 |  ...*/
+    {30,160,270,380,490,590,690,800,900};    // 上升时小于等于表值则熄灭相应段
+
+/*** 燃油液位上升表格 ***/
+static const uint16_t Fuel_Table_Dn [ 9u ] =
+    /*显示段：|    0     |    1     |    2     |    3     |    4     |      ...*/
+    {60,190,300,410,520,620,720,830,930};    // 下降时小于等于表值则熄灭相应段
+
+uint16_t g_u16FuelData[FUEL_DATA_NUM];
+uint8_t g_u8FuelDataCount = 0u;
+uint16_t FuelR = 0u; /*滤波后的燃油电阻，精度0.1*/
+uint16_t Fuelvalue_Last = 0;
+uint16_t FuelRBak = 0;
+uint16_t Fuel_Self_Inspection_Stage = 0u;
+uint8_t Timerf = 0u;
+uint8_t  Fuel_Self_Last = 0u;
+uint8_t g_u8DesFuelSetp = 0u;
+uint8_t g_u8DeFuelSetp = 0u;
+uint8_t g_u8CurFuelSetp = 0u;
+uint8_t g_u8FuelInitFlag = 0u;
+uint8_t g_u8FuelEmergency_StopFlag = 0u;
+uint8_t g_u8FuelStateInitFlag = 0u;
+uint8_t g_u8FuelDir = FUEL_SEG_UP;
+uint16_t g_u16FuelSensorNormalTime = 0u;
+uint16_t g_u16FuelSensorShortTime = 0u;
+uint16_t g_u16FuelSensorOpenTime = 0u;
+uint16_t g_u16FuelSensostausTime = 0u;
+uint8_t g_u8FuelADCompleteFlg = 0u;
+uint32_t  NumChangeTime = 0;
+uint32_t NumTime = 0;
+static uint16_t g_DropoutTime = 0u;
+static uint16_t Fpercentage;
+uint8_t g_u8FuelRedFlg = 0u;
+static uint16_t Fuelpercentage = 0u;
+static uint8_t FuelSensorStaus = 1;
+uint8_t Fuel_SensorStaus = 0;
+FuelSensorSts_t FuelSensorState = FuelSensorNormal;
+uint16_t F_DstSeg = 0u;
+FuelOilSensor FuelOilSensorCtrl;
+void Fuel_KL30_Init(void)
+{
+    g_u8DesFuelSetp = 0u;
+    g_u8DeFuelSetp = 0u;
+    g_u8CurFuelSetp = 0u;
+    Fuel_Self_Inspection_Stage = 0u;
+    Timerf = 0u;
+    Fuel_Self_Last = 0u;
+    g_u8FuelInitFlag = 1u;
+    FuelSensorStaus = 1;
+    g_u8FuelStateInitFlag = 1u;
+    g_u8FuelDir = FUEL_SEG_UP;
+    FuelSensorState = FuelSensorNormal;
+    g_u16FuelSensorNormalTime = 0u;
+    g_u16FuelSensorShortTime = 0u;
+    g_u16FuelSensorOpenTime = 0u;
+    g_u16FuelSensostausTime = 0u;
+    NumChangeTime = 0u;
+    g_u8FuelADCompleteFlg = 0u;
+    g_DropoutTime = 0u;
+    g_u8FuelRedFlg = 0u;
+    Fuel_SensorStaus = 0;
+    Fuelpercentage = 0u;
+    Fuelvalue_Last = 0;
+    F_DstSeg = 0u;
+    g_u8FuelEmergency_StopFlag = 0u;
+}
+
+void Fuel_KL15_Init(void)
+{
+    g_u8DesFuelSetp = 0u;
+    g_u8DeFuelSetp = 0u;
+    g_u8CurFuelSetp = 0u;
+    g_u8FuelInitFlag = 1u;
+    Fuel_Self_Inspection_Stage = 0u;
+    Timerf = 0u;
+    Fuel_Self_Last = 0u;
+    FuelSensorStaus = 1;
+    g_u8FuelStateInitFlag = 1u;
+    g_u8FuelDir = FUEL_SEG_UP;
+    FuelSensorState = FuelSensorNormal;
+    g_u16FuelSensorNormalTime = 0u;
+    g_u16FuelSensorShortTime = 0u;
+    g_u16FuelSensorOpenTime = 0u;
+    g_u16FuelSensostausTime = 0u;
+    NumChangeTime = 0;
+    g_u8FuelADCompleteFlg = 0u;
+    g_DropoutTime = 0u;
+    g_u8FuelRedFlg = 0u;
+    Fuel_SensorStaus = 0;
+    Fuelpercentage = 0u;
+    Fuelvalue_Last = 0;
+    F_DstSeg = 0u;
+    g_u8FuelEmergency_StopFlag = 0u;
+}
+
+void Fuel_R_Cal(uint8_t deltaTime)
+{
+    uint16_t FuelRes = 0;
+    uint8_t i, j;
+    uint32_t temp32;
+    static uint16_t timeCount = 0;
+
+    if(g_u8FuelStateInitFlag)
+    {
+        FuelR = ADC_Read_Signal(ADC_CH_FUEL);
+    }
+
+    if (timeCount >= FUEL_DATA_TIME)
+    {
+        timeCount = 0;
+        if (g_u8FuelDataCount < FUEL_DATA_NUM)
+        {
+            /*获取燃油电阻*/
+            FuelRes = ADC_Read_Signal(ADC_CH_FUEL);
+
+            /*四舍五入*/
+            if (FuelRes < 65535)
+            {
+                if (FuelRes % 10 >= 5)
+                {
+                    FuelRes += 5;
+                }
+            }
+            else
+            {
+                FuelRes = 0xFFFF;
+            }
+            /*由小到大插入数据*/
+            for (i = 0; i < g_u8FuelDataCount; i++)
+            {
+                if (FuelRes < g_u16FuelData[i])
+                {
+                    break;
+                }
+            }
+            for (j = g_u8FuelDataCount; j > i; j--)
+            {
+                g_u16FuelData[j] = g_u16FuelData[j - 1];
+            }
+            g_u16FuelData[i] = FuelRes;
+            g_u8FuelDataCount++;
+        }
+        else
+        {
+            /*一组数据采集完毕，取中间部分计算平均值*/
+            temp32 = 0;
+            for (i = FUEL_CAL_START; i < FUEL_CAL_END; i++)
+            {
+                temp32 += g_u16FuelData[i];
+            }
+            FuelR = (uint16_t)(temp32 / (FUEL_CAL_END - FUEL_CAL_START));
+            g_u8FuelDataCount = 0;
+            g_u8FuelADCompleteFlg = 1;
+        }
+    }
+    timeCount += deltaTime;
+}
+
+void Fuel_State_Check(uint8_t deltaTime)
+{
+
+    if (FuelR < 30)
+    { /*短路3*/
+        g_u16FuelSensorOpenTime = 0;
+        g_u16FuelSensorNormalTime = 0;
+        if(Get_Voltage_Anomaly() == 2u)
+        {
+            g_u16FuelSensorShortTime = 3001u;
+        }
+        if (Get_Self() == 1)
+        {
+            g_u16FuelSensorShortTime = 3001u;
+        }
+        if ((g_u16FuelSensorShortTime > 3000u) || ((g_u8FuelStateInitFlag) && (g_u16FuelSensorShortTime > 3000u)))
+        {
+            FuelSensorState = FuelSensorShortCircuit;
+            g_u8DesFuelSetp = 0;
+            g_u8CurFuelSetp = 8;
+            Fuel_SensorStaus = 1;
+            g_u8FuelStateInitFlag = 0;
+            g_u8FuelInitFlag = 1;
+            g_u8FuelDir = FUEL_SEG_UP;
+        }
+        else
+        {
+            g_u16FuelSensorShortTime += deltaTime;
+        }
+    }
+    else if (FuelR >= 5000)
+    { /*开路 500*/
+        g_u16FuelSensorShortTime = 0u;
+        g_u16FuelSensorNormalTime = 0u;
+        if(Get_Voltage_Anomaly() == 2u)
+        {
+            g_u16FuelSensorOpenTime = 3001u;
+        }
+        if (Get_Self() == 1)
+        {
+            g_u16FuelSensorOpenTime = 3001u;
+        }
+        if ((g_u16FuelSensorOpenTime > 3000u) || ((g_u8FuelStateInitFlag) && (g_u16FuelSensorOpenTime > 3000u)))
+        {
+            FuelSensorState = FuelSensorOpenCircuit;
+            g_u8DesFuelSetp = 0u;
+            g_u8CurFuelSetp = 8u;
+            Fuel_SensorStaus = 1u;
+            g_u8FuelStateInitFlag = 0u;
+            g_u8FuelInitFlag = 1u;
+            g_u8FuelDir = FUEL_SEG_UP;
+        }
+        else
+        {
+            g_u16FuelSensorOpenTime += deltaTime;
+        }
+    }
+    else
+    {
+        g_u16FuelSensorShortTime = 0u;
+        g_u16FuelSensorOpenTime = 0u;
+        FuelSensorState = FuelSensorNormal;
+        g_u8FuelStateInitFlag = 0u;
+    }
+    if (FuelSensorState == FuelSensorNormal)
+    {
+        if (Fuel_SensorStaus == 1u)
+        {
+            g_u16FuelSensostausTime += deltaTime;
+            if (g_u16FuelSensostausTime > 3000u)
+            {
+                Fuel_SensorStaus = 0u;
+                g_u16FuelSensostausTime = 0u;
+            }
+            else
+            {
+                FuelSensorState = FuelSensorOpenCircuit;
+                g_u8DesFuelSetp = 8u;
+                g_u8CurFuelSetp = 8u;
+                g_u8FuelStateInitFlag = 0u;
+                g_u8FuelInitFlag = 1u;
+                Fuel_SensorStaus = 1u;
+                g_u8FuelDir = FUEL_SEG_UP;
+            }
+        }
+        else
+        {
+            g_u16FuelSensostausTime = 0u;
+        }
+    }
+}
+
+void Fuel_Gauges_Cal(uint8_t deltaTime)
+{
+    static uint16_t time = 0u;
+    static uint16_t Fuel_Value_Last = 0u;
+
+    if ((FuelSensorState == FuelSensorNormal) && (FuelR < 5000u) && (FuelR >= 30u))
+    {
+        /*采集完第一组数据后，开始计算燃油格数*/
+
+        if (g_u8FuelInitFlag)
+        {
+            FuelRBak = FuelR;
+        }
+
+        if (FuelRBak >= FuelR + RETURN_DIFFERENCE)
+        {
+            g_u8FuelDir = FUEL_SEG_UP;
+            FuelRBak = FuelR;
+        }
+        if (FuelR < FuelRBak)
+        {
+            FuelRBak = FuelR;
+        }
+        if (FuelR < Fuelvalue_Last) // 新燃油液位高于前次燃油液位,查上升表
+        {
+            while (F_DstSeg)
+            {
+                if (FuelR > Fuel_Table_Up[F_DstSeg - 1u])
+                    break;
+                F_DstSeg--;
+            }
+        }
+        else if (FuelR > Fuelvalue_Last) // 新燃油液位低于前次燃油液位,查下降表
+        {
+            while (F_DstSeg < 9)
+            {
+                if (FuelR < Fuel_Table_Dn[F_DstSeg])
+                    break;
+                F_DstSeg++;
+            }
+        }
+        Fuelvalue_Last = FuelR;
+        g_u8DesFuelSetp = 9 - F_DstSeg;
+
+        /*IGN ON 5秒/故障恢复后，开始走格  立即指向当前格*/
+        if (Common_GetIgnOnTime() >= 2000u)
+        {
+            time += deltaTime;
+            if (g_u8FuelInitFlag)
+            {
+                g_u8FuelInitFlag = 0u;
+                time = 0u;
+                g_u8CurFuelSetp = g_u8DesFuelSetp;
+            }
+            if(g_DropoutTime < 15000u) //自检后立即指示
+            {
+                g_DropoutTime += deltaTime;
+                if( FuelSensorStaus == 1u)
+                {
+                    FuelSensorStaus = 2u;
+                    Fuel_Value_Last = g_u8DesFuelSetp;
+                }
+                if (Fuel_Value_Last == g_u8DesFuelSetp)
+                {
+                    g_u8CurFuelSetp = g_u8DesFuelSetp;
+                    Fuel_Value_Last = g_u8DesFuelSetp;
+                }
+            }
+            else
+            {  
+            }
+            if (time >= 15000u)
+            { /* 15S变化一格 */
+                time = 0;
+                if (g_u8CurFuelSetp < g_u8DesFuelSetp)
+                {
+                    g_u8CurFuelSetp++;
+                }
+                else if (g_u8CurFuelSetp > g_u8DesFuelSetp)
+                {
+                    g_u8CurFuelSetp--;
+                }
+            }
+
+            if (g_u8CurFuelSetp == g_u8DesFuelSetp)
+            {
+                time = 0;
+            }
+        }
+    }
+}
+
+void Fuel_Percentage_(uint8_t deltaTime)
+{
+    static uint16_t  Fuelpercentage_last;
+    static uint16_t  FuelpercentageVal;
+    if (Fuel_SensorStaus == 1u)
+    {
+        FuelOilSensorCtrl.FuelOilPreCurrent = 0u;
+        FuelpercentageVal = 0u;
+        Fuelpercentage = 0u;
+        Fpercentage = 0u;
+    }
+    else
+    {
+        if ((FuelR < 5000u) && (FuelR >= 900u))
+        {
+            FuelpercentageVal = ((5000u - FuelR) / 372u);
+        }
+        else if ((FuelR < 900u) && (FuelR >= 800u))
+        {
+            FuelpercentageVal = (((900u - FuelR) / 9u)) + 11u;
+        }
+        else if ((FuelR < 800u) && (FuelR >= 697u))
+        {
+            FuelpercentageVal = (((800u - FuelR) / 9u)) + 22u;
+        }
+        else if ((FuelR < 697u) && (FuelR >= 596))
+        {
+            FuelpercentageVal = (((697u - FuelR) / 9u)) + 33u;
+        }
+        else if ((FuelR < 596u) && (FuelR >= 495u))
+        {
+            FuelpercentageVal = (((596u - FuelR) / 9u)) + 44u;
+        }
+        else if ((FuelR < 495u) && (FuelR >= 396u))
+        {
+            FuelpercentageVal = (((495u - FuelR) / 9u)) + 55u;
+        }
+        else if ((FuelR < 396u) && (FuelR >= 277u))
+        {
+            FuelpercentageVal = ((3960u - (FuelR * 10u)) / 108u) + 66u;
+        }
+        else if ((FuelR < 277u) && (FuelR >= 169u))
+        {
+            FuelpercentageVal = ((2770u - (FuelR * 10u)) / 98u) + 77u;
+        }
+        else if((FuelR < 169u) && (FuelR >= 30u))
+        {
+            FuelpercentageVal = ((1690u - (FuelR * 10u)) / 126u) + 88u;
+            if ((FuelR < 40u))
+            {
+                FuelpercentageVal = 100u;
+            }
+        }
+        if (g_u8DesFuelSetp != g_u8CurFuelSetp)
+        {
+            if ((g_u8DeFuelSetp == 1u) || (g_u8DeFuelSetp == 2u))
+            {
+                NumTime += deltaTime;
+            }
+            else
+            {                
+                if (g_u8DesFuelSetp > g_u8CurFuelSetp)
+                {
+                    g_u8DeFuelSetp = 1u;
+                    NumChangeTime = ((g_u8DesFuelSetp - g_u8CurFuelSetp)) * 15000u;
+                    NumChangeTime = NumChangeTime / (FuelpercentageVal - Fuelpercentage);
+                }
+                else
+                {
+                    g_u8DeFuelSetp = 2u;
+                    NumChangeTime = ((g_u8CurFuelSetp - g_u8DesFuelSetp)) * 15000u;
+                    NumChangeTime = NumChangeTime / (Fuelpercentage - FuelpercentageVal);
+                }
+            }
+            
+            if (NumTime > NumChangeTime)
+            {
+                if (g_u8DesFuelSetp > g_u8CurFuelSetp)
+                {
+                    Fuelpercentage += 1u;
+                }
+                else
+                {
+                    Fuelpercentage -= 1u;
+                }
+                NumTime = 0u;
+            }
+            
+            if (g_u8DeFuelSetp == 1)
+            {
+                if (FuelpercentageVal > Fpercentage)
+                {
+                //     if (g_u8FuelEmergency_StopFlag < 1)
+                //     {
+                        Fpercentage = Fuelpercentage;
+                    // }
+                }
+                else
+                {
+                    // g_u8FuelEmergency_StopFlag++;
+                }
+            }
+            if (g_u8DeFuelSetp == 2)
+            {
+                if (FuelpercentageVal < Fpercentage)
+                {
+                    // if (g_u8FuelEmergency_StopFlag < 1)
+                    // {
+                        Fpercentage = Fuelpercentage;
+                    // }
+                }
+                else
+                {
+                    // g_u8FuelEmergency_StopFlag++;
+                }
+            }
+        }
+        else
+        {
+            g_u8FuelEmergency_StopFlag = 0u;
+            Fuelpercentage = FuelpercentageVal;
+            NumTime = 0;
+            NumChangeTime = 0;
+            g_u8DeFuelSetp = 0;
+        }
+    }
+
+    if ((Get_Self() == 1u) || (g_u16FuelSensostausTime == 3000u))
+    {
+        if ((FuelR < 5000u) && (FuelR >= 900u))
+        {
+            FuelpercentageVal = ((5000u - FuelR) / 372u);
+        }
+        else if ((FuelR < 900u) && (FuelR >= 800u))
+        {
+            FuelpercentageVal = (((900u - FuelR) / 9u)) + 11u;
+        }
+        else if ((FuelR < 800) && (FuelR >= 697))
+        {
+            FuelpercentageVal = (((800u - FuelR) / 9u)) + 22u;
+        }
+        else if ((FuelR < 697u) && (FuelR >= 596u))
+        {
+            FuelpercentageVal = (((697u - FuelR) / 9u)) + 33u;
+        }
+        else if ((FuelR < 596u) && (FuelR >= 495u))
+        {
+            FuelpercentageVal = (((596u - FuelR) / 9u)) + 44u;
+        }
+        else if ((FuelR < 495u) && (FuelR >= 396u))
+        {
+            FuelpercentageVal = (((495u - FuelR) / 9u)) + 55u;
+        }
+        else if ((FuelR < 396u) && (FuelR >= 277u))
+        {
+            FuelpercentageVal = ((3960u - (FuelR * 10u)) / 108u) + 66u;
+        }
+        else if ((FuelR < 277u) && (FuelR >= 169u))
+        {
+            FuelpercentageVal = ((2770u - (FuelR * 10u)) / 98u) + 77u;
+        }
+        else if ((FuelR < 169u) && (FuelR >= 30u))
+        {
+            FuelpercentageVal = ((1690u - (FuelR * 10u)) / 126u) + 88u;
+            if ((FuelR < 40u))
+            {
+                FuelpercentageVal = 100u;
+            }
+        }
+      FuelOilSensorCtrl.FuelOilPreCurrent =  FuelpercentageVal;
+      Fuelpercentage =  FuelpercentageVal;
+    }
+    if (Fuelpercentage >= Fuelpercentage_last) // 上升
+    {
+        Fpercentage = Fuelpercentage;
+        Fuelpercentage_last = Fuelpercentage;
+    }
+    else // 下降
+    {
+        if (((Fuelpercentage_last - Fuelpercentage) > 2u) || (Fpercentage == 0u))
+        {
+            Fpercentage = Fuelpercentage;
+            Fuelpercentage_last = Fuelpercentage;
+        }
+        else // 保持上一状态
+        {
+            Fpercentage = Fuelpercentage_last;
+        }
+    }
+    if (Fpercentage > 100u)
+    {
+        Fpercentage = 100u;
+    }
+    FuelOilSensorCtrl.Fuel_Goal = Fpercentage;
+    Duty_Cycle_Delta(FuelOilSensorCtrl.Fuel_Goal, &FuelOilSensorCtrl.FuelOilPreCurrent, &FuelOilSensorCtrl.Time);
+}
+
+
+
+/*100ms*/
+void Fuel_Cal_Sevice(uint8_t deltaTime)
+{
+    /*检测燃油电阻状态*/
+    Fuel_State_Check(deltaTime);
+
+    /*显示燃油格*/
+    Fuel_Gauges_Cal(deltaTime);
+    /*燃油百分比*/
+    Fuel_Percentage_(deltaTime);
+}
+void Fuel_Self_InspectionOld(void)
+{
+
+    if (Get_Voltage_Anomaly() == 2u)
+    {
+    }
+    else
+    {
+        if (Common_Get_IG_Sts() == COMMON_POWER_OFF)
+        {
+            Fuel_Self_Inspection_Stage = 0u;
+            Timerf = 0u;
+        }
+        else
+        {
+            if (Get_Dis_Old_Staus() == 3u)
+            {
+                Timerf = 0u;
+            }
+            Fuel_Self_Inspection_Stage = 1u;
+            if (Timerf <= 20u)
+            {
+                FuelSensorState = FuelSensorNormal;
+                g_u8CurFuelSetp = 0;
+                 if (GetLcdInitSt() == 1u)
+                {
+                    if (Get_Uptime_Staus() == 1u)
+                    {
+                        Timerf++;
+                    }
+                }
+                if (Timerf >= 3u)
+                {
+                    if (Fuel_Self_Inspection_Stage == 1u)
+                    {
+                        if (Timerf <= 10u)
+                        {
+                            Fuel_Self_Last = ((Timerf ) * 100u) / 125u;
+                            g_u8CurFuelSetp = Fuel_Self_Last;
+                        }
+                        else
+                        {
+                            Fuel_Self_Last = 8u - (((Timerf - 10u) * 100u) / 125u);
+                            g_u8CurFuelSetp = Fuel_Self_Last;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                Fuel_Self_Inspection_Stage = 2u;
+            }
+        }
+    }
+}
+
+/*0正常，1红色*/
+uint8_t Get_CurFuelRed(void)
+{
+    return g_u8FuelRedFlg;
+}
+/*返回百分比%*/
+uint8_t Get_Fuel_Percentage(void)
+{
+    return (uint8_t)FuelOilSensorCtrl.FuelOilPreCurrent;
+}
+/*格数*/
+uint8_t Get_CurFuelSetp(void)
+{
+    return g_u8CurFuelSetp;
+}
+/*状态*/
+FuelSensorSts_t Get_Fuel_Sensor_State(void)
+{
+    return FuelSensorState;
+}
\ No newline at end of file

Application/Data_Fuel.h

+#ifndef DATA_FUEL_H
+#define DATA_FUEL_H
+
+// #include "Components.h"
+#include "stdint.h"
+
+typedef struct{
+    uint16_t Fuel_Goal;
+    uint16_t FuelOilPreCurrent;
+    uint16_t Time;
+} FuelOilSensor;
+
+
+typedef enum{
+    FuelSensorNormal = 0,
+    FuelSensorShortCircuit,
+    FuelSensorOpenCircuit,
+}FuelSensorSts_t;
+
+extern void Fuel_KL15_Init(void);
+extern void Fuel_KL30_Init(void);
+extern void Fuel_Cal_Sevice(uint8_t deltaTime);
+extern uint8_t Get_CurFuelSetp(void);
+extern FuelSensorSts_t Get_Fuel_Sensor_State(void);
+extern void Fuel_R_Cal(uint8_t deltaTime);
+extern uint8_t Get_Fuel_Percentage(void);
+extern uint8_t Get_CurFuelRed(void);
+// extern void Fuel_Percentage(uint8_t deltaTime);
+void Fuel_Self_InspectionOld(void);
+#endif

Application/Data_VSpeed.c

+
+#include "Data_VSpeed.h"
+#include "Components.h"
+#include "CommonInterface.h"
+#include "PowerManagement\PowerManag_user.h"
+#include  "CAN_CH0_CAN_Communication_Matrix.h"
+#include "FreIn.h"
+#include "FreIn_User.h"
+
+uint32_t DataVSpeedActual;
+uint32_t DataVSpeedActual_ignoreError;
+uint32_t DataVSpeedDisp;
+uint32_t DataVSpeedHysteresis;
+uint8_t  DataVSpeedValid;
+uint8_t  DataVSpeedstaus;
+uint8_t Offline_timer = 0;
+uint16_t timerDataVSpeed = 0;
+uint32_t Vspeed = 0;
+uint8_t Vehicle_Speed_Duty_Valid = 0u;
+uint8_t Vehicle_Speed_Duty_HZ_Valid = 0u;
+uint16_t Speed_Self_InspectionTimer = 0u;
+uint32_t Speed_Self_Inspection_Last = 0u;
+uint32_t timerDutyDataVSpeed = 0u;
+uint32_t Vehicle_Speed_HZ_Last = 0u;
+DataVSpeedSamplerStruct DataVSpeedSampler;
+DataVSPeedDampingStruct DataVSPeedDamping;
+uint8_t V_DstSeg = 0u;
+#define DATA_APPR_DIR_INC 0x01
+#define DATA_APPR_DIR_DEC 0x02
+/*** 车速频率升表格 ***/
+static const uint16_t Vehicle_Speed_Duty_Table_Up [4u] =
+    /*显示段：| 0 | 1 |  2   |  3  | 4 |  ...*/
+{10500, 20200,30200,40200}; // 上升时小于等于表值则熄灭相应段
+
+/***车速频率下降表格 ***/
+static const uint16_t Vehicle_Speed_Duty_Table_Dn [ 4u ] =
+    /*显示段：|    0     |    1     |    2     |    3     |    4     |      ...*/
+{10000,19700,29700,39700}; // 下降时小于等于表值则熄灭相应段
+
+/******************************************************************************
+函数名：Data_Vehicle_Speed_KL30_Init
+功  能：车速数据KL30初始化
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数KL30初始化被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_KL30_Init(void)
+{
+    DataVSpeedActual             = 0;
+    DataVSpeedActual_ignoreError = 0;
+    DataVSpeedDisp               = 0;
+    DataVSpeedHysteresis         = 0;
+    DataVSpeedValid              = 0;
+    DataVSpeedSampler.Cnt        = 0;
+    DataVSPeedDamping.Speed      = 0;
+    DataVSPeedDamping.Delta      = 0;
+    DataVSpeedstaus              = 0;
+    Offline_timer                = 0;
+    timerDataVSpeed              = 0;
+    V_DstSeg                     = 0u;
+    Vehicle_Speed_HZ_Last        = 0u;
+    Vehicle_Speed_Duty_Valid     = 1u;
+    Vehicle_Speed_Duty_HZ_Valid  = 1u;
+    DataVSPeedDamping.Dir        = DATA_APPR_DIR_INC;
+}
+
+/******************************************************************************
+函数名：Data_Vehicle_Speed_Wakeup_Init
+功  能：车速数据唤醒初始化
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数唤醒初始化被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_Wakeup_Init(void)
+{
+    DataVSpeedDisp          = 0;
+    DataVSpeedHysteresis    = 0;
+    DataVSPeedDamping.Speed = 0;
+    DataVSPeedDamping.Delta = 0;
+    DataVSpeedstaus         = 0;
+    Offline_timer           = 0;
+    timerDataVSpeed         = 0;
+    V_DstSeg                = 0u;
+    Vehicle_Speed_HZ_Last   = 0u;
+    Vehicle_Speed_Duty_Valid = 1u;
+    Vehicle_Speed_Duty_HZ_Valid = 1u;
+    DataVSPeedDamping.Dir   = DATA_APPR_DIR_INC;
+}
+/******************************************************************************
+函数名：Data_Vehicle_Speed_Duty_Cycle_Detection
+功  能：车速占空比检测函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数必须每20ms被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_Duty_Cycle_Detection(void)
+{
+    uint32_t Vehicle_Speed_HZ = 0U;
+    uint32_t Vehicle_Speed_Duty = 0u;
+    uint8_t  Vehicle_Speed_Dut_Valid = 0u;
+    if (Fre_In_Get_Channel_Status(FRE_VEHICLE) == FRE_STATUS_VALID)
+    {
+        Vehicle_Speed_HZ += Fre_In_Get_Channel_HZ(FRE_VEHICLE);
+        Vehicle_Speed_Duty = Fre_In_Get_Channel_Duty(FRE_VEHICLE);
+    }
+    if (Vehicle_Speed_HZ > Vehicle_Speed_HZ_Last) // 新燃油液位高于前次燃油液位,查上升表
+    {
+        while (V_DstSeg < 5u)
+        {
+            if (Vehicle_Speed_HZ < Vehicle_Speed_Duty_Table_Up[V_DstSeg])
+                break;
+            V_DstSeg++;
+        }
+    }
+    else if (Vehicle_Speed_HZ < Vehicle_Speed_HZ_Last) // 新燃油液位低于前次燃油液位,查下降表
+    {
+        while (V_DstSeg)
+        {
+            if (Vehicle_Speed_HZ > Vehicle_Speed_Duty_Table_Dn[V_DstSeg - 1u])
+                break;
+            V_DstSeg--;
+        }
+    }
+    Vehicle_Speed_HZ_Last = Vehicle_Speed_HZ;
+    Vehicle_Speed_Dut_Valid = V_DstSeg;
+    if (Vehicle_Speed_Dut_Valid == 1)
+    {
+        if ((Vehicle_Speed_Duty >= 120) && (Vehicle_Speed_Duty <= 880))
+        {
+            Vehicle_Speed_Duty_Valid = 1u;
+            Vehicle_Speed_Duty_HZ_Valid = 1u;
+        }
+        else
+        {
+            Vehicle_Speed_Duty_Valid = 0u;
+        }
+    }
+    else if (Vehicle_Speed_Dut_Valid == 2)
+    {
+        if ((Vehicle_Speed_Duty >= 170) && (Vehicle_Speed_Duty <= 830))
+        {
+            Vehicle_Speed_Duty_Valid = 1u;
+            Vehicle_Speed_Duty_HZ_Valid = 1u;
+        }
+        else
+        {
+            Vehicle_Speed_Duty_Valid = 0u;
+        }
+    }
+    else if (Vehicle_Speed_Dut_Valid >= 3)
+    {
+        if ((Vehicle_Speed_Duty >= 250) && (Vehicle_Speed_Duty <= 750))
+        {
+            Vehicle_Speed_Duty_Valid = 1u;
+            Vehicle_Speed_Duty_HZ_Valid = 1u;
+        }
+        else
+        {
+            Vehicle_Speed_Duty_Valid = 0u;
+        }
+    }
+    else
+    {
+        Vehicle_Speed_Duty_Valid = 1u;
+        Vehicle_Speed_Duty_HZ_Valid = 1u;
+    }
+}
+/******************************************************************************
+函数名：Data_Vehicle_Speed_Processing_Service
+功  能：车速数据处理函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数必须每20ms被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_Processing_Service(void)
+{
+    uint8_t  i         = 0U;
+    uint16_t Delta     = 0U;
+    uint32_t VSpeed    = 0U;
+    uint32_t VSpeedCal = 0U;
+    uint32_t VSpeedpwm = 0U;
+    static uint8_t time = 0;
+    static uint32_t MeanValue = 0;
+    static uint32_t MeanValueA = 0;
+    //上电
+    if(Common_Get_IG_Sts( ) == COMMON_POWER_ON )
+    {
+        // 第1步：获取实际车速值及车速有效性
+        if (Fre_In_Get_Channel_Status(FRE_VEHICLE) == FRE_STATUS_VALID)
+        {
+            DataVSpeedstaus = 1;
+            time++;
+            MeanValue += Fre_In_Get_Channel_HZ(FRE_VEHICLE);
+            if (time == 5)
+            {
+                MeanValue /= 50;
+                MeanValueA = MeanValue;
+                MeanValue = 0;
+                time = 0;
+            }
+            if (MeanValueA > 10000)
+            {
+                DataVSpeedValid = 0;
+                DataVSpeedActual = 0;
+                DataVSpeedActual_ignoreError = 0;
+                DataVSpeedSampler.Cnt = 0;
+            }
+            else
+            {
+                if (Vehicle_Speed_Duty_HZ_Valid  == 1)
+                {
+                    if (DataVSpeedValid == 0)
+                    {
+                        DataVSpeedValid = 1;
+                        VSpeed = Fre_In_Get_Channel_HZ(FRE_VEHICLE)*100u;
+                        // VSpeed = MeanValueA * 100;
+                        if (Get_Dis_Sizes() == 1)
+                        {
+                            VSpeed /= 2425;
+                        }
+                        if (Get_Dis_Sizes() == 3)
+                        {
+                            VSpeed /= 2183;
+                        }
+                        DataVSpeedActual_ignoreError = (uint16_t)VSpeed;
+                        if (VSpeed > 1990)
+                        {
+                            VSpeed = 1990;
+                        }
+                        DataVSpeedActual = (uint16_t)VSpeed;
+                    }
+                    else
+                    {
+                        DataVSpeedSampler.Buffer[DataVSpeedSampler.Cnt] = Fre_In_Get_Channel_HZ(FRE_VEHICLE) / 10;
+                        i = DataVSpeedSampler.Cnt;
+                        while ((i > 0) && (DataVSpeedSampler.Buffer[i] < DataVSpeedSampler.Buffer[i - 1]))
+                        {
+                            VSpeed = DataVSpeedSampler.Buffer[i];
+                            DataVSpeedSampler.Buffer[i] = DataVSpeedSampler.Buffer[i - 1];
+                            DataVSpeedSampler.Buffer[i - 1] = (uint16_t)VSpeed;
+                            i--;
+                        }
+
+                        DataVSpeedSampler.Cnt++;
+                        if (DataVSpeedSampler.Cnt >= 3)
+                        {
+                            DataVSpeedSampler.Cnt = 0;
+                            VSpeed = DataVSpeedSampler.Buffer[1];
+                            if (VSpeed > 10000)
+                            {
+                                VSpeed = 0;
+                            }
+                            else
+                            {
+                                VSpeed *= 1000;
+                                if (Get_Dis_Sizes() == 1)
+                                {
+                                    VSpeed /= 2425;
+                                }
+                                if (Get_Dis_Sizes() == 3)
+                                {
+                                    VSpeed /= 2183;
+                                }
+                            }
+                            DataVSpeedActual_ignoreError = (uint16_t)VSpeed;
+                            if (VSpeed > 1990)
+                            {
+                                VSpeed = 1990;
+                            }
+                            DataVSpeedActual = (uint16_t)VSpeed;
+                        }
+                    }
+                }
+                else
+                {
+                    DataVSpeedValid = 0;
+                    DataVSpeedActual = 0;
+                    DataVSpeedActual_ignoreError = 0;
+                    DataVSpeedSampler.Buffer[0] = 0;
+                    DataVSpeedSampler.Buffer[1] = 0;
+                    DataVSpeedSampler.Buffer[2] = 0;
+                    DataVSpeedSampler.Cnt = 0;
+                }
+                if ((Fre_In_Get_Channel_HZ(FRE_VEHICLE) > 73000))
+                {
+                    if (timerDataVSpeed >= 250)
+                    {
+                        DataVSpeedActual = 0;
+                        Vehicle_Speed_Duty_HZ_Valid = 0u;
+
+                    }
+                    else
+                    {
+                        timerDataVSpeed++;
+                    }
+                }
+                else
+                {
+                    timerDataVSpeed = 0;
+                }
+                if((Vehicle_Speed_Duty_Valid == 0))
+                {
+                    if (timerDutyDataVSpeed >= 50)
+                    {
+                        DataVSpeedActual = 0;
+                        DataVSpeedValid = 0;
+                        Vehicle_Speed_Duty_HZ_Valid = 0u;
+                    }
+                    else
+                    {
+                        timerDutyDataVSpeed++;
+                    }
+                }
+                else
+                {
+                    timerDutyDataVSpeed = 0u;
+                }
+            }
+        }
+        else
+        {
+            DataVSpeedValid = 0;
+            DataVSpeedActual = 0;
+            DataVSpeedActual_ignoreError = 0;
+            DataVSpeedSampler.Buffer[0] = 0;
+            DataVSpeedSampler.Buffer[1] = 0;
+            DataVSpeedSampler.Buffer[2] = 0;
+            DataVSpeedSampler.Cnt = 0;
+        }
+    }
+    else
+    {
+        DataVSpeedValid = 0;
+        DataVSpeedActual = 0;
+        DataVSpeedActual_ignoreError = 0;
+        DataVSpeedSampler.Buffer[0] = 0;
+        DataVSpeedSampler.Buffer[1] = 0;
+        DataVSpeedSampler.Buffer[2] = 0;
+        DataVSpeedSampler.Cnt = 0;
+        DataVSpeedstaus = 0;
+    }
+
+
+    // 第2步：车速的阻尼处理
+    VSpeed = DataVSpeedActual;
+    if ( VSpeed > DataVSPeedDamping.Speed )    // 实际值比当前显示值大时
+    {
+        Delta = ( uint16_t )VSpeed - DataVSPeedDamping.Speed;
+
+        if ( DataVSPeedDamping.Dir == DATA_APPR_DIR_INC )    // 显示值正在向实际值增加,则维持当前方向调节增加速度
+        {
+            if ( DataVSPeedDamping.Delta < Delta )           // 当前增量小于显示值与实际值的差值,则提升增加的速度
+            {
+                DataVSPeedDamping.Delta += DATA_VSPEED_INC_STEP;
+                if ( DataVSPeedDamping.Delta > Delta )
+                    DataVSPeedDamping.Delta = Delta;
+            }
+            else    // 当前增量大于等于显示值与实际值的差值,保持增量与当前差值同步,增加的速度即逐步减小
+                DataVSPeedDamping.Delta = Delta;
+
+            Delta = DataVSPeedDamping.Delta;
+            Delta /= DATA_VSPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_VSPEED_APPR_SPEED_MIN )
+                Delta = DATA_VSPEED_APPR_SPEED_MIN;
+
+            DataVSPeedDamping.Speed += Delta;
+            if ( DataVSPeedDamping.Speed > VSpeed )
+                DataVSPeedDamping.Speed = ( uint16_t )VSpeed;
+        }
+        else    // 显示值正在减小,则尽快减速至速度为最小时更换方向
+        {
+            if ( DataVSPeedDamping.Delta > DATA_VSPEED_DEC_STEP )
+                DataVSPeedDamping.Delta -= DATA_VSPEED_DEC_STEP;
+            else
+                DataVSPeedDamping.Delta = 0;
+
+            Delta = DataVSPeedDamping.Delta;
+            Delta /= DATA_VSPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_VSPEED_APPR_SPEED_MIN )         // 已减速至最小速度
+                DataVSPeedDamping.Dir = DATA_APPR_DIR_INC;    // 更换方向
+            else
+            {
+                if ( DataVSPeedDamping.Speed > Delta )
+                    DataVSPeedDamping.Speed -= Delta;
+                else
+                    DataVSPeedDamping.Speed = 0;
+            }
+        }
+    }
+    else if ( VSpeed < DataVSPeedDamping.Speed )    // 实际值比当前显示值小时
+    {
+        Delta = DataVSPeedDamping.Speed - ( uint16_t )VSpeed;
+
+        if ( DataVSPeedDamping.Dir == DATA_APPR_DIR_INC )    // 显示值仍在增加,则尽快减速至速度为最小时更换方向
+        {
+            if ( DataVSPeedDamping.Delta > DATA_VSPEED_DEC_STEP )
+                DataVSPeedDamping.Delta -= DATA_VSPEED_DEC_STEP;
+            else
+                DataVSPeedDamping.Delta = 0;
+
+            Delta = DataVSPeedDamping.Delta;
+            Delta /= DATA_VSPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_VSPEED_APPR_SPEED_MIN )         // 已减速至最小速度
+                DataVSPeedDamping.Dir = DATA_APPR_DIR_DEC;    // 更换方向
+            else
+            {
+                DataVSPeedDamping.Speed += Delta;
+                if ( DataVSPeedDamping.Speed > 1990 )
+                     DataVSPeedDamping.Speed = 1990;
+            }
+        }
+        else                                          // 显示值正在向实际值减小,则维持当前方向调节增加速度
+        {
+            if ( DataVSPeedDamping.Delta < Delta )    // 当前(负)增量小于显示值与实际值的差值,则提升减小的速度
+            {
+                DataVSPeedDamping.Delta += DATA_VSPEED_INC_STEP;
+                if ( DataVSPeedDamping.Delta > Delta )
+                    DataVSPeedDamping.Delta = Delta;
+            }
+            else    // 当前(负)增量大于等于显示值与实际值的差值,保持(负)增量与当前差值同步,减小的速度即逐步减小
+                DataVSPeedDamping.Delta = Delta;
+
+            Delta = DataVSPeedDamping.Delta;
+            Delta /= DATA_VSPEED_DAMPING_FACTOR;
+
+            if ( Delta < DATA_VSPEED_APPR_SPEED_MIN )
+                Delta = DATA_VSPEED_APPR_SPEED_MIN;
+
+            if ( DataVSPeedDamping.Speed < VSpeed + Delta )
+                DataVSPeedDamping.Speed = ( uint16_t )VSpeed;
+            else
+                DataVSPeedDamping.Speed -= Delta;
+        }
+    }
+    else    // 实际值与当前显示值相等时
+    {
+        Delta = DataVSPeedDamping.Delta;
+        Delta /= DATA_VSPEED_DAMPING_FACTOR;
+
+        if ( Delta > DATA_VSPEED_APPR_SPEED_MIN )                    // 当前的速度不是最小,说明数值正在增加/减小中,则继续原过程
+        {
+            if ( DataVSPeedDamping.Delta > DATA_VSPEED_DEC_STEP )    // 显示值越过了实际值,必然要先减速至最小速度,再改变方向返回实际值
+                DataVSPeedDamping.Delta -= DATA_VSPEED_DEC_STEP;
+            else
+                DataVSPeedDamping.Delta = 0;
+
+            Delta = DataVSPeedDamping.Delta;
+            Delta /= DATA_VSPEED_DAMPING_FACTOR;
+
+            if ( DataVSPeedDamping.Dir == DATA_APPR_DIR_INC )     // 显示值当前是增加方向
+            {
+                if ( Delta < DATA_VSPEED_APPR_SPEED_MIN )         // 已减速至最小速度
+                    DataVSPeedDamping.Dir = DATA_APPR_DIR_DEC;    // 更换方向
+                else
+                {
+                    DataVSPeedDamping.Speed += Delta;
+                    if ( DataVSPeedDamping.Speed > 1990 )
+                         DataVSPeedDamping.Speed = 1990;
+                }
+            }
+            else                                                  // 显示值当前是减小方向
+            {
+                if ( Delta < DATA_VSPEED_APPR_SPEED_MIN )         // 已减速至最小速度
+                    DataVSPeedDamping.Dir = DATA_APPR_DIR_INC;    // 更换方向
+                else
+                {
+                    if ( DataVSPeedDamping.Speed > Delta )
+                        DataVSPeedDamping.Speed -= Delta;
+                    else
+                        DataVSPeedDamping.Speed = 0;
+                }
+            }
+        }
+    }
+
+    // 第3步：生成显示车速
+     if ( (DataVSPeedDamping.Speed >= DataVSpeedHysteresis))
+    {
+        if ( DataVSPeedDamping.Speed - DataVSpeedHysteresis >= DATA_VSPEED_HYSTERESIS )
+        {
+            DataVSpeedHysteresis = DataVSPeedDamping.Speed;
+        }
+    }
+    else
+    {
+        if ( DataVSpeedHysteresis - DataVSPeedDamping.Speed >= DATA_VSPEED_HYSTERESIS )
+        {
+            DataVSpeedHysteresis = DataVSPeedDamping.Speed;
+        }
+    }
+
+    VSpeedCal = (uint32_t)DataVSpeedHysteresis;
+    if ((Get_Self() != 1) && (Get_Uptime_Staus() != 0))
+    {
+        // if (1)
+        // {
+            VSpeedCal *= 106;
+            VSpeedCal /= 100;
+            if ((VSpeedCal % 10) >= 5)
+            {
+                VSpeedCal += 5; /* 四舍五入 */
+            }
+            DataVSpeedDisp = (uint16_t)VSpeedCal;
+        // }
+        // else
+        // {
+        //     DataVSpeedDisp = 0;
+        // }
+        if (Get_Dis_Unit() == 1)
+        {
+            DataVSpeedDisp *= 256;
+            DataVSpeedDisp /= 412;
+            if (DataVSpeedDisp >= 1233)
+            {
+                DataVSpeedDisp = 1240;
+            }
+            Vspeed = DataVSpeedDisp;
+        }
+        else
+        {
+            Vspeed = DataVSpeedDisp;
+        }
+    }
+}
+void Speed_Self_Inspection(void)
+{
+    if (Get_Voltage_Anomaly() == 2u)
+    {
+    }
+    else
+    {
+        if (Get_Uptime_Staus() == 0)
+        {
+            Speed_Self_InspectionTimer = 0u;
+            Speed_Self_Inspection_Last = 0u;
+        }
+        if (Get_Dis_Old_Staus() == 3)
+        {
+            Speed_Self_InspectionTimer = 0u;
+        }
+        if (Common_Get_IG_Sts() == COMMON_POWER_OFF)
+        {
+            Speed_Self_InspectionTimer = 0u;
+            Speed_Self_Inspection_Last = 0u;
+        }
+        else
+        {
+            if (Speed_Self_InspectionTimer <= 202)
+            {
+                if (Speed_Self_InspectionTimer >= 1u)
+                {
+                    Speed_Self_InspectionTimer++;
+                    Vspeed = 0u;
+                    DataVSpeedValid = 0u;
+                    if (Speed_Self_InspectionTimer <= 102u)
+                    {
+                        Speed_Self_Inspection_Last += 202u;
+                        DataVSpeedDisp = (Speed_Self_Inspection_Last / 10u);
+                    }
+                    else
+                    {
+                        Speed_Self_Inspection_Last -= 202u;
+                        DataVSpeedDisp = (Speed_Self_Inspection_Last / 10u);
+                    }
+                }
+                else
+                {
+                    if (GetLcdInitSt() == 1)
+                    {
+                        if (Get_Uptime_Staus() == 1u)
+                        {
+                            Speed_Self_InspectionTimer++;
+                        } 
+                    }
+                }
+            }
+            else
+            {
+            }
+        }
+    }
+}
+
+/*车速有效位：有效=1，无效=0*/
+uint8_t Get_VechileSpeedValid(void)
+{
+    return DataVSpeedValid;
+}
+/*真实的车速，精度10倍,*/
+uint32_t Get_ActualVechileSpeed(void)
+{
+    return DataVSpeedActual;
+}
+/*显示车速，精度10倍，取整，舍去小数点*/
+uint32_t Get_DispVechileSpeed(void)
+{
+    Vspeed = DataVSpeedDisp;
+    return Vspeed;
+}
+
+
+

Application/Data_VSpeed.h

+#ifndef _Data_Vspeed_H_
+#define _Data_Vspeed_H_
+
+#include "common.h"
+
+/*** 参数设置 ***/
+#define   DATA_VEHICLE_RUNNING_THRESHOLD    25  //汽车行进阈值    
+#define   DATA_VEHICLE_STOP_THRESHOLD       20  //汽车停止阈值
+
+#define   DATA_VSPEED_DAMPING_FACTOR        3   //阻尼系数
+#define   DATA_VSPEED_INC_STEP              1   //速度增加时慢加速速度变化步长
+#define   DATA_VSPEED_DEC_STEP              6   //方向改变时急减速速度变化步长
+#define   DATA_VSPEED_APPR_SPEED_MIN        1   //最小逼近速度
+#define   DATA_VSPEED_HYSTERESIS            10  //回差 
+
+/*** 控制结构 ***/
+typedef struct
+{
+    uint32_t  Buffer[3];
+    uint8_t   Cnt;
+} DataVSpeedSamplerStruct;            //车速采样结构
+
+typedef struct
+{
+    uint16_t  Speed;
+    uint16_t  Delta;
+    uint8_t   Dir;
+} DataVSPeedDampingStruct;            //车速阻尼结构
+
+
+/******************************************************************************
+函数名：Data_Vehicle_Speed_KL30_Init
+功  能：车速数据KL30初始化
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数KL30初始化被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_KL30_Init(void);
+/******************************************************************************
+函数名：Data_Vehicle_Speed_Wakeup_Init
+功  能：车速数据唤醒初始化
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数唤醒初始化被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_Wakeup_Init(void);
+
+/******************************************************************************
+函数名：Data_Vehicle_Speed_Processing_Service
+功  能：车速数据处理函数
+参  数：无
+返回值：无
+******************************************************************************
+注  意：该函数必须每20ms被调用一次
+******************************************************************************/
+void Data_Vehicle_Speed_Processing_Service(void);
+void Speed_Self_Inspection(void);
+void Data_Vehicle_Speed_Duty_Cycle_Detection(void);
+uint8_t Get_VechileSpeedValid(void);
+
+/*真实的车速，精度10倍,*/
+uint32_t Get_ActualVechileSpeed(void);
+
+/*显示车速，精度10倍，取整，舍去小数点*/
+uint32_t Get_DispVechileSpeed(void);
+uint16_t Get_DispVechileSpeed_Mile(void);
+
+#endif

Application/Display.c

+#include "common.h"
+#include "Components.h"
+#include "Display.h"
+#include "flash.h"
+#include "UDS\UDS_ISO14229_Services.h"
+#include "Mileage\Service_Interval.h"
+DataTimeStruct DataTime;
+uint16_t Driving_mode = 0u;
+uint32_t timerk = 0;
+uint8_t g_u8RTC_H = 0;
+uint8_t Intermediate_Variable = 0;
+uint8_t Dis_Hour_Tenb;
+uint8_t Dis_Hour_Bit;
+uint8_t Dis_Minute_Tenb;
+uint8_t Dis_Minute_Bit;
+uint8_t g_u8Time_Cocln = 0;//冒号
+uint8_t g_u8AMorPM = 1;//0:无显示 1:AM 2:PM
+uint8_t g_u8Flicker = 0;//0:全灭 1：小时十位亮 2：小时个位亮 3：分钟十位亮 4： 分钟个位亮
+RTC_CounterTypeDef counter_value;
+RTC_CounterTypeDef date_time;
+
+void Display_KL15_KL30_Init(void)
+{
+    Driving_mode = 0u;
+
+}
+
+void Driving_Mode_Display(void)
+{
+    uint16_t Mode = 0;
+    Mode = Get_CAN_CH0_ID_402_Sig_ETC_performance_mode();
+    if (Common_Get_IG_Sts() == COMMON_POWER_ON)
+    {    
+        if (CAN_MSG_Status(&CAN_CH0_CanMsgOp, CAN_CH0_ID_ECU_402_Msg_Count) == CAN_SIG_NORMAL)
+        {
+            if (Mode == 0)
+            {
+                Driving_mode = 1u;
+            }
+            else if (Mode == 1)
+            {
+                Driving_mode = 2u;
+            }
+            else if (Mode == 2)
+            {
+                Driving_mode = 3u;
+            }
+        }
+        if((Common_GetIgnOnTime() > 1990u) && (Common_GetIgnOnTime() <= 2000u))
+        {
+            Driving_mode = 0u;
+        }
+    }
+}
+
+void TIME_Service(void)
+{
+    g_u8RTC_H++;
+    Intermediate_Variable++;
+    if (g_u8RTC_H > 4)
+    {
+        g_u8RTC_H = 1u;
+    }
+}
+
+
+/*保存时间*/
+void Double_Empvalue(void)
+{
+   	RTE_RTC_Get_CounterValue(&date_time);
+	counter_value.time.RTC_Hours = RTC_Bcd2ToByte(date_time.time.RTC_Hours);
+	counter_value.time.RTC_Minutes = RTC_Bcd2ToByte(date_time.time.RTC_Minutes);
+	counter_value.time.RTC_Seconds = RTC_Bcd2ToByte(date_time.time.RTC_Seconds); 
+    Dis_Hour_Tenb = counter_value.time.RTC_Hours / 10u;
+    Dis_Hour_Bit = counter_value.time.RTC_Hours % 10u;
+    Dis_Minute_Tenb = counter_value.time.RTC_Minutes / 10u;
+    Dis_Minute_Bit = counter_value.time.RTC_Minutes % 10u;
+    DataTime.Dis_Seconds = counter_value.time.RTC_Seconds;
+    DataTime.Dis_Hour = counter_value.time.RTC_Hours;
+    DataTime.Dis_Minute = counter_value.time.RTC_Minutes;
+    DataTime.RTC_H12 = counter_value.time.RTC_H12;
+    DataTime.Dis_Timer_Set = 1U;  //存储标志位
+    DataTime.Val_ServiceMil100m = Get_g_ServiceMil100m();
+    DataTime.Val_ServiceTimer1s = Get_g_ServiceTimer1s();
+}
+/**
+ * @description: 针对于新MCU情况下的 D_Flash初始化
+ * @return {*}
+ */
+void D_Flash_Init(void)
+{
+    // flashRead((uint8_t*)APP_DATA_WRITE, sizeof(DataTime), (uint8_t *)&DataTime);
+    // if(Init_Flash_Buf[0]==0XFF)
+    // {
+    //     EraseSector(APP_DATA_WRITE);
+    //     Init_Flash_Buf[0]=0;
+    //     ProgramPage(APP_DATA_WRITE, sizeof(DataTime), (uint8_t *)&DataTime);
+    // }
+}
+/**
+ * @description: D_Flash 的设置写入 
+ * @return {*} 0成功 1失败
+ */
+uint8_t D_Flash_Set(void)
+{
+    uint8_t result = 0;
+    EraseSector(APP_DATA_WRITE);
+    result = ProgramPage(APP_DATA_WRITE, sizeof(DataTime), (uint8_t *)&DataTime);
+    return result;
+}
+
+uint8_t D_Flash_Get(void)
+{   
+    flashRead((uint8_t*)APP_DATA_WRITE, sizeof(DataTime), (uint8_t *)&DataTime);
+    return 1u;
+}
+
+void D_Flash_Clear(void)
+{
+    EraseSector(APP_DATA_WRITE);
+}
+void Time_Assignment(void)
+{
+    RTC_CounterTypeDef time_temp;
+    // uint32_t TempBuf[20] = {0};
+    uint8_t Size = 0u;
+    uint8_t BackLight = 0u;
+    // Gen_TimeDelay(10,1000);
+    // eeprom_ReadRecord(EEPROM_BLOCK_08, (uint8_t *)&DataTime, 8);
+    D_Flash_Get();
+    if (DataTime.Dis_Timer_Set == 1u )
+    {
+        Size = (DataTime.Size_Back_Light / 10);
+        BackLight = (DataTime.Size_Back_Light % 10);
+        time_temp.time.RTC_Hours = (DataTime.Dis_Hour);
+        time_temp.time.RTC_Minutes = (DataTime.Dis_Minute);
+        time_temp.time.RTC_Seconds = (DataTime.Dis_Seconds);
+        time_temp.time.RTC_H12 = (DataTime.RTC_H12);
+        v_g_ServiceMil100m(DataTime.Val_ServiceMil100m);
+        v_g_ServiceTimer1s(DataTime.Val_ServiceTimer1s);
+        RTC_SetTime(&time_temp.time);
+        DataTime.Dis_Timer_Set = 0u;
+        if (DataTime.ODO_KM_Memory == 0u)
+        {
+            Dis_OdoAndTrip(0u);
+            Dis_Unit(0u);
+        }
+        else if (DataTime.ODO_KM_Memory == 1u)
+        {
+            Dis_OdoAndTrip(0u);
+            Dis_Unit(1u);
+        }
+        else if (DataTime.ODO_KM_Memory == 2u)
+        {
+            Dis_OdoAndTrip(1u);
+            Dis_Unit(0u);
+        }
+        else if (DataTime.ODO_KM_Memory == 3u)
+        {
+            Dis_OdoAndTrip(1u);
+            Dis_Unit(1u);
+        }
+        DataTime.ODO_KM_Memory = 0u;
+        if(Size == 4u)
+        {
+            Dis_Sizes_Read(3u);
+        }
+        else if (Size == 2u)
+        {
+            Dis_Sizes_Read(1u);
+        }
+        if(BackLight == 5u)
+        {
+            Luminous_Value_Pwm_Alter(300u);
+        }
+        else if (BackLight == 4u)
+        {
+            Luminous_Value_Pwm_Alter(500u);
+        }
+        else if (BackLight == 3u)
+        {
+            Luminous_Value_Pwm_Alter(600u);
+        }
+        else if (BackLight == 2u)
+        {
+            Luminous_Value_Pwm_Alter(700u);
+        }
+        else if (BackLight == 1u)
+        {
+            Luminous_Value_Pwm_Alter(800u);
+        }
+        DataTime.Size_Back_Light = 0u;
+        Gen_TimeDelay(10,1000);
+        D_Flash_Clear();
+        D_Flash_Set();
+        // eeprom_WriteRecord(EEPROM_BLOCK_08, ( uint8_t * )&DataTime, 8);
+    }
+}
+/*单位及里程存储*/
+void ODO_KM_Memory_Feature(void) 
+{
+    if((Get_Dis_Unit() == 0u) && (Get_Dis_OdoAndTrip() == 0u))
+    {
+        DataTime.ODO_KM_Memory = 0u;
+    }
+    else if((Get_Dis_Unit() == 1u) && (Get_Dis_OdoAndTrip() == 0u))
+    {
+        DataTime.ODO_KM_Memory = 1u;
+    }
+    else if((Get_Dis_Unit() == 0u) && (Get_Dis_OdoAndTrip() == 1u))
+    {
+        DataTime.ODO_KM_Memory = 2u;
+    }
+    else if((Get_Dis_Unit() == 1u) && (Get_Dis_OdoAndTrip() == 1u))
+    {
+        DataTime.ODO_KM_Memory = 3u;
+    }
+}
+/*轮胎尺寸及背光存储*/
+void Size_Back_Light_Feature(void)
+{
+    uint8_t Size = 0u;
+    uint8_t Back_Light = 0u;
+    uint8_t Val = 0u;
+    if(Get_Luminous_Value_Pwm() == 300u)
+    {
+        Back_Light = 5u;
+    }
+    else if(Get_Luminous_Value_Pwm() == 500u)
+    {
+        Back_Light = 4u;
+    }
+    else if(Get_Luminous_Value_Pwm() == 600u)
+    {
+        Back_Light = 3u;
+    }
+    else if(Get_Luminous_Value_Pwm() == 700u)
+    {
+        Back_Light = 2u;
+    }
+    else if(Get_Luminous_Value_Pwm() == 800u)
+    {
+        Back_Light = 1u;
+    }
+     if(Get_Dis_Sizes() == 3u)
+    {
+        Size = 40u;
+    }
+    else if(Get_Dis_Sizes() == 1u)
+    {
+        Size = 20u;
+    }
+    DataTime.Size_Back_Light = (Size + Back_Light);
+    D_Flash_Clear();
+    D_Flash_Set();
+}
+void Time_Cocln_server(void)
+{
+    static uint32_t Led_Old_Staus = 0;
+    RTC_CounterTypeDef time_temp;
+    RTE_RTC_Get_CounterValue(&date_time);
+	time_temp.time.RTC_Hours = RTC_Bcd2ToByte(date_time.time.RTC_Hours);
+	time_temp.time.RTC_Minutes = RTC_Bcd2ToByte(date_time.time.RTC_Minutes);
+	time_temp.time.RTC_Seconds = RTC_Bcd2ToByte(date_time.time.RTC_Seconds);
+	if(g_u8RTC_H == 0u)
+	{
+		if(FLASH_SYNC_1Hz)
+		{
+			g_u8Time_Cocln = 1u;
+		}
+		else
+		{
+			g_u8Time_Cocln = 0u;
+		}
+	}
+	else
+	{
+		g_u8Time_Cocln = 1u;
+	}
+	if(g_u8RTC_H == 1u)
+	{
+		if(FLASH_SYNC_1Hz)
+		{
+			g_u8Flicker = 1u;//小时灭
+		}
+		else
+		{
+			g_u8Flicker = 0u;
+		}
+	}
+	else if(g_u8RTC_H == 2u)
+	{
+		if(FLASH_SYNC_1Hz)
+		{
+			g_u8Flicker = 2u;//小时灭
+		}
+		else
+		{
+			g_u8Flicker = 0u;
+		}
+	}
+    else if (g_u8RTC_H == 3u)
+    {
+        if (FLASH_SYNC_1Hz)
+        {
+            g_u8Flicker = 3u; // 分钟灭
+        }
+        else
+        {
+            g_u8Flicker = 0u;
+        }
+    }
+    else if (g_u8RTC_H == 4u)
+    {
+        if (FLASH_SYNC_1Hz)
+        {
+            g_u8Flicker = 4u; // 分钟灭
+        }
+        else
+        {
+            g_u8Flicker = 0u;
+        }
+    }
+    else
+	{
+		g_u8Flicker = 0u;
+	}
+    if (Get_Dis_Timer_Set() == 1)
+    {
+        timerk++;
+        if (timerk >= 200u)
+        {
+            time_temp.time.RTC_Seconds = 0u;
+            RTC_SetTime(&time_temp.time);
+            g_u8RTC_H = 0u;
+            Intermediate_Variable = 0u;
+            Dis_Timer_Set_(0);
+        }
+        else
+        {
+            if (Common_Get_IG_Sts() == COMMON_POWER_OFF)
+            {
+                if (g_u8RTC_H == 1)
+                {
+                    time_temp.time.RTC_Hours = ((Dis_Hour_Tenb * 10u) + (time_temp.time.RTC_Hours % 10u));
+                }
+                if (g_u8RTC_H == 2)
+                {
+                    time_temp.time.RTC_Hours = ((time_temp.time.RTC_Hours / 10u) + Dis_Hour_Bit);
+                }
+                if (g_u8RTC_H == 3u)
+                {
+                    time_temp.time.RTC_Minutes = ((Dis_Minute_Tenb * 10u) + (time_temp.time.RTC_Hours % 10u));
+                }
+                if (g_u8RTC_H == 4u)
+                {
+                    time_temp.time.RTC_Minutes = ((time_temp.time.RTC_Hours / 10u) + Dis_Minute_Bit);
+                }
+                time_temp.time.RTC_Seconds = 0u;
+                RTC_SetTime(&time_temp.time);
+                g_u8RTC_H = 0u;
+                Intermediate_Variable = 0u;
+                Dis_Timer_Set_(0);
+            }
+        }
+    }
+    else
+    {
+        timerk = 0u;
+    }
+    if (Led_Old_Staus != Intermediate_Variable)
+    {
+        Led_Old_Staus = Intermediate_Variable;
+        timerk = 0u;
+    }
+}
+	
+
+uint8_t Time_Set = 0u;
+void Time_Display_Service(void)//50ms  task
+{	
+
+	RTE_RTC_Get_CounterValue(&date_time);
+	counter_value.time.RTC_Hours = RTC_Bcd2ToByte(date_time.time.RTC_Hours);
+	counter_value.time.RTC_Minutes = RTC_Bcd2ToByte(date_time.time.RTC_Minutes);
+	counter_value.time.RTC_Seconds = RTC_Bcd2ToByte(date_time.time.RTC_Seconds);
+	if(Time_Set == 0u)
+	{
+		if((counter_value.time.RTC_Hours < 24) && (counter_value.time.RTC_Minutes < 60) && (counter_value.time.RTC_Seconds < 60))
+		{
+			Time_Set = 1u;
+			RTC_SetTime(&counter_value.time);
+		}
+	}
+}
+
+void Hour_Adjust(void)
+{
+	RTC_CounterTypeDef time_temp;
+	//更改时间
+	RTE_RTC_Get_CounterValue(&date_time);
+    
+	time_temp.time.RTC_Hours = RTC_Bcd2ToByte(date_time.time.RTC_Hours);
+	time_temp.time.RTC_Minutes = RTC_Bcd2ToByte(date_time.time.RTC_Minutes);
+	time_temp.time.RTC_Seconds = RTC_Bcd2ToByte(date_time.time.RTC_Seconds);
+    if( Common_Get_IG_Sts() == COMMON_POWER_ON )
+    {
+        if (g_u8RTC_H == 1u)
+        {
+            Intermediate_Variable++;
+            time_temp.time.RTC_Hours += 10u;
+        }
+        if (time_temp.time.RTC_Hours >= 30)
+        {
+            time_temp.time.RTC_Hours -= 30u;
+        }
+        if (g_u8RTC_H == 2)
+        {
+            Intermediate_Variable++;
+            time_temp.time.RTC_Hours++;
+        }
+
+        if (time_temp.time.RTC_Hours > 23u)
+        {
+            time_temp.time.RTC_Hours = 0u;
+        }
+        
+    }
+    time_temp.time.RTC_Seconds = 0u;
+    RTC_SetTime(&time_temp.time);
+}
+
+void Min_Adjust(void)
+{
+
+	RTC_CounterTypeDef time_temp;
+	//更改时间
+	RTE_RTC_Get_CounterValue(&date_time);   
+	time_temp.time.RTC_Hours = RTC_Bcd2ToByte(date_time.time.RTC_Hours);
+	time_temp.time.RTC_Minutes = RTC_Bcd2ToByte(date_time.time.RTC_Minutes);
+	time_temp.time.RTC_Seconds = RTC_Bcd2ToByte(date_time.time.RTC_Seconds);
+
+    if (Common_Get_IG_Sts() == COMMON_POWER_ON)
+    {
+        if (g_u8RTC_H == 3)
+        {
+            Intermediate_Variable++;
+            time_temp.time.RTC_Minutes += 10u;
+        }
+        if (time_temp.time.RTC_Minutes >= 60u)
+        {
+            time_temp.time.RTC_Minutes -= 60u;
+        }
+        if (g_u8RTC_H == 4)
+        {
+            Intermediate_Variable++;
+            time_temp.time.RTC_Minutes++;
+        }
+        if (time_temp.time.RTC_Minutes > 59u)
+        {
+            time_temp.time.RTC_Minutes = 0u;
+        }
+
+    }
+    time_temp.time.RTC_Seconds = 0u;
+    RTC_SetTime(&time_temp.time);
+}
+/*时间显示小时*/
+uint8_t Get_Dis_Hour_Time(void)
+{
+    uint8_t u8RTC_Hours = 0u;
+    u8RTC_Hours = counter_value.time.RTC_Hours;
+    if (u8RTC_Hours == 12U)
+    {
+        g_u8AMorPM = 2U;
+    }
+    else  if(u8RTC_Hours > 12U)
+    {
+        u8RTC_Hours -= 12U;
+        g_u8AMorPM = 2U;
+    }
+    else if (u8RTC_Hours == 0U)
+    {
+        u8RTC_Hours = 12U;
+        g_u8AMorPM = 1U;
+    }
+    else
+    {
+        g_u8AMorPM = 1u;
+    }
+    return u8RTC_Hours;
+}
+
+/*返回分钟时间*/
+uint8_t Get_Dis_Minute_Time(void)
+{
+	return counter_value.time.RTC_Minutes;
+}
+
+/*1AM，2PM*/
+uint8_t Get_AMorPM(void)
+{
+	return g_u8AMorPM;
+}
+
+/*：闪烁*/
+uint8_t Get_Time_Cocln(void)
+{
+	return g_u8Time_Cocln;
+}
+/*闪烁1小时十位，2小时个位，3分钟十位，4分钟个位*/
+uint8_t Get_Flicker(void)
+{
+	return g_u8Flicker;
+}
+/*行驶模式*/
+uint16_t Get_Driving_Mode()
+{
+    return Driving_mode;
+}

Application/Display.h

+#ifndef _DISPLAY_H_
+#define _DISPLAY_H_
+
+#include "common.h"
+#include "Components.h"
+
+typedef struct 
+{
+    uint8_t Dis_Seconds;
+    uint8_t Dis_Hour;
+    uint8_t Dis_Minute;
+    uint8_t RTC_H12;
+    uint8_t Dis_Timer_Set;
+    uint8_t ODO_KM_Memory;
+    uint8_t Size_Back_Light;
+    uint32_t Val_ServiceMil100m;
+    uint32_t Val_ServiceTimer1s;
+} DataTimeStruct;
+extern void Set_Timer_EE(DataTimeStruct *DataTime);
+extern void Display_KL15_KL30_Init(void);
+extern void Driving_Mode_Display(void);
+extern void Time_Display_Service(void);
+extern void Time_Cocln_server(void);
+extern void Double_Empvalue(void);
+extern void Time_Assignment(void);
+extern void TIME_Service(void);
+extern void Hour_Adjust(void);
+extern void Min_Adjust(void);
+// uint8_t D_Flash_Get(void);
+// uint8_t D_Flash_Set(void);
+extern void ODO_KM_Memory_Feature(void); 
+extern void Size_Back_Light_Feature(void);
+extern uint8_t Get_Dis_Minute_Time(void);
+extern uint16_t Get_Driving_Mode(void);
+extern uint8_t Get_Dis_Hour_Time(void);
+extern uint8_t Get_Time_Cocln(void);
+extern uint8_t Get_Flicker(void);
+extern uint8_t Get_AMorPM(void);
+#endif

Application/GpioUser.c

+#include "GpioUser.h"
+#include "Components.h"
+
+
+
+void Gpio_Init(_GpioUser_Enum InitMode)
+{
+    if (InitMode == Gpio_Uvalid)
+    {
+        return;
+    }
+
+    if ((InitMode == Gpio_KL30_Init) || (InitMode == Gpio_WakeUp_Init))
+    {
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN00, GpioOut_Low);  //1.8V电使能
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN01, RTE_GPIO_DIR_IN);  //KL15
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN02, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN03, GpioOut_Low);  
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN04, GpioOut_High);  
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN05, GpioOut_Low);  //L_BiasBitSW 里程百位---
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN06, GpioOut_Low);  //L_BiasBitSW 里程千位---
+
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN00, RTE_GPIO_DIR_IN);  //表盘背光-PWM
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN01, RTE_GPIO_DIR_IN);   //蜂鸣器控制
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN02, GpioOut_Low);      
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN03, RTE_GPIO_DIR_IN);     
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN04, RTE_GPIO_DIR_IN);  //ABS报警
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN05, RTE_GPIO_DIR_IN);  //机油压力报警
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN06, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN07, RTE_GPIO_DIR_IN); 
+
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN00, RTE_GPIO_DIR_IN);  //AVDD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN01, RTE_GPIO_DIR_IN);  //GND
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN02, RTE_GPIO_DIR_IN);  //KL30-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN03, RTE_GPIO_DIR_IN);  //KL15-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN04, RTE_GPIO_DIR_IN);  //NTC-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN05, RTE_GPIO_DIR_IN);  //燃油信号输入-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN06, RTE_GPIO_DIR_IN);  //水温信号输入-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN07, RTE_GPIO_DIR_IN);  //BiasBitSW-燃油-AD---
+
+        RTE_GPIO_Config(RTE_GPIO_PORT03_PIN00, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT03_PIN01, RTE_GPIO_DIR_OUT);      //SDB_LED_DRIVER
+
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN00, GpioOut_Low);      //SWDIO-编程
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN01, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN02, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN03, GpioOut_Low);      //VCC1V2_AMT_EN(630H电源)
+
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN00, RTE_GPIO_DIR_IN);  //
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN01, GpioOut_Low);     //
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN02, GpioOut_High);  
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN03, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN04, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN05, RTE_GPIO_DIR_IN);  
+
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN00, GpioOut_High);      //存储SCL
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN01, GpioOut_Low);      //存储SDA
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN02, GpioOut_Low);      //SCL_MCU
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN03, RTE_GPIO_DIR_IN);      //SDA_MCU
+
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN00, RTE_GPIO_DIR_IN);  //制动液位
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN01, RTE_GPIO_DIR_IN);  
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN02, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN03, RTE_GPIO_DIR_IN);  //L_BiasBitSW 里程万位---
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN04, RTE_GPIO_DIR_IN);  //近光灯
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN05, RTE_GPIO_DIR_IN);  //示宽灯信号输入-N-IN-MCU
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN06, RTE_GPIO_DIR_IN);     
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN07, GpioOut_Low);      
+
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN00, GpioOut_High);  //L_BiasBitSW_POW---
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN01, GpioOut_Low);      //X1
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN02, RTE_GPIO_DIR_IN);      //X2
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN03, GpioOut_Low);      //XT1
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN04, RTE_GPIO_DIR_IN);      //XT2
+
+        RTE_GPIO_Config(RTE_GPIO_PORT13_PIN00, GpioOut_High);  //燃油水温切电使能
+        RTE_GPIO_Config(RTE_GPIO_PORT13_PIN06, RTE_GPIO_DIR_IN);      //3004中断(未更改配置)
+        RTE_GPIO_Config(RTE_GPIO_PORT13_PIN07, GpioOut_Low);      //SWCLK-编程
+
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN00, GpioOut_Low);     //3.3V电使能
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN01, RTE_GPIO_DIR_IN);  //L_BiasBitSW_燃油_OUT---
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN06, RTE_GPIO_DIR_IN);  //硬件版本识别
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN07, GpioOut_Low);      
+    }
+    else 
+    {
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN00, GpioOut_High);//1.8V电使能
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN01, RTE_GPIO_DIR_IN);//KL15
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN02, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN03, GpioOut_High); 
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN04, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN05, RTE_GPIO_DIR_IN);//L_BiasBitSW 里程百位---
+        RTE_GPIO_Config(RTE_GPIO_PORT00_PIN06, RTE_GPIO_DIR_IN);//L_BiasBitSW 里程千位---
+
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN00, RTE_GPIO_DIR_OUT);//表盘背光-PWM
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN01, RTE_GPIO_DIR_IN);//蜂鸣器控制
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN02, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN03, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN04, RTE_GPIO_DIR_IN);//ABS报警
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN05, RTE_GPIO_DIR_IN);//机油压力报警
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN06, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT01_PIN07, RTE_GPIO_DIR_IN); 
+
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN00, RTE_GPIO_DIR_IN);//AVDD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN01, RTE_GPIO_DIR_IN);//GND
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN02, RTE_GPIO_DIR_IN);//KL30-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN03, RTE_GPIO_DIR_IN);//KL15-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN04, RTE_GPIO_DIR_IN);//NTC-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN05, RTE_GPIO_DIR_IN);//燃油信号输入-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN06, RTE_GPIO_DIR_IN);//水温信号输入-AD
+        RTE_GPIO_Config(RTE_GPIO_PORT02_PIN07, RTE_GPIO_DIR_IN);//BiasBitSW-燃油-AD---
+
+        RTE_GPIO_Config(RTE_GPIO_PORT03_PIN00, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT03_PIN01, RTE_GPIO_DIR_IN);//SDB_LED_DRIVER
+
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN00, RTE_GPIO_DIR_IN);//SWDIO-编程
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN01, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN02, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT04_PIN03, GpioOut_High);//VCC1V2_AMT_EN(630H电源)
+
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN00, RTE_GPIO_DIR_IN);//切电控制-MCU-OUT-2
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN01, RTE_GPIO_DIR_IN);//切电控制-MCU-OUT-1
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN02, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN03, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN04, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT05_PIN05, RTE_GPIO_DIR_IN); 
+
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN00, RTE_GPIO_DIR_IN);//存储SCL
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN01, RTE_GPIO_DIR_IN);//存储SDA
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN02, RTE_GPIO_DIR_IN);//SCL_MCU
+        RTE_GPIO_Config(RTE_GPIO_PORT06_PIN03, RTE_GPIO_DIR_IN);//SDA_MCU
+
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN00, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN01, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN02, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN03, RTE_GPIO_DIR_IN);//L_BiasBitSW 里程万位---
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN04, RTE_GPIO_DIR_IN);//近光灯
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN05, RTE_GPIO_DIR_IN);//ABS故障信号输入-N-IN-MCU
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN06, RTE_GPIO_DIR_IN); 
+        RTE_GPIO_Config(RTE_GPIO_PORT07_PIN07, RTE_GPIO_DIR_IN); 
+
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN00, RTE_GPIO_DIR_IN);//L_BiasBitSW_POW---
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN01, RTE_GPIO_DIR_IN);//X1
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN02, RTE_GPIO_DIR_IN);//X2
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN03, RTE_GPIO_DIR_IN);//XT1
+        RTE_GPIO_Config(RTE_GPIO_PORT12_PIN04, RTE_GPIO_DIR_IN);//XT2
+
+        RTE_GPIO_Config(RTE_GPIO_PORT13_PIN00, RTE_GPIO_DIR_IN);//燃油水温切电使能
+        RTE_GPIO_Config(RTE_GPIO_PORT13_PIN06, RTE_GPIO_DIR_IN);//3004中断(未更改配置)
+        RTE_GPIO_Config(RTE_GPIO_PORT13_PIN07, RTE_GPIO_DIR_IN);//SWCLK-编程
+
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN00, GpioOut_High);//3.3V电使能
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN01, RTE_GPIO_DIR_IN);//L_BiasBitSW_燃油_OUT---
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN06, RTE_GPIO_DIR_IN);//硬件版本识别
+        RTE_GPIO_Config(RTE_GPIO_PORT14_PIN07, RTE_GPIO_DIR_IN); 
+    }
+}

Application/GpioUser.h

+#ifndef _GPIOUSER_H_
+#define _GPIOUSER_H_
+
+#define GpioOut_High RTE_GPIO_DIR_OUT | RTE_GPIO_LEVEL_HIGH
+#define GpioOut_Low RTE_GPIO_DIR_OUT | RTE_GPIO_LEVEL_LOW
+/* GPIO映射 */
+#define ABS_Faulty_lights          RTE_GPIO_PORT00_PIN00   
+#define KL15_AD_IN                 RTE_GPIO_PORT00_PIN01   
+#define MCU_SPI_MOSI               RTE_GPIO_PORT00_PIN02   
+#define MCU_SPI_MISO               RTE_GPIO_PORT00_PIN03   
+#define MCU_SPI_CLK                RTE_GPIO_PORT00_PIN04   
+#define HighBeam_P_In              RTE_GPIO_PORT00_PIN05   
+#define VSPEED_TEN_OUT             RTE_GPIO_PORT00_PIN06   
+
+// #define Blacklight_PWM             RTE_GPIO_PORT01_PIN00   //ljs
+#define Buzzer_X                   RTE_GPIO_PORT01_PIN01   
+#define LIN_TXD_ESP                RTE_GPIO_PORT01_PIN02   
+#define Gears_N_MCU                RTE_GPIO_PORT01_PIN03   
+#define ABS_Faulty_lights_MCU      RTE_GPIO_PORT01_PIN04   
+#define Oil_Pressure_MUC           RTE_GPIO_PORT01_PIN05  //机油压力 
+#define ESPEED_TEN_IN              RTE_GPIO_PORT01_PIN06   
+#define VSPEED_TEN_IN              RTE_GPIO_PORT01_PIN07   
+
+#define AVDD                       RTE_GPIO_PORT02_PIN00   
+#define GND                        RTE_GPIO_PORT02_PIN01   
+#define KL30_AD_MCU_IN             RTE_GPIO_PORT02_PIN02     //ljs 
+#define KL15_AD_MCU_IN             RTE_GPIO_PORT02_PIN03     //ljs
+#define A_NTC_IN                   RTE_GPIO_PORT02_PIN04   
+#define A_FuelSender_BitSNSR1_IN   RTE_GPIO_PORT02_PIN05   
+#define A_WaterTemp_IN             RTE_GPIO_PORT02_PIN06   
+#define A_FULESTANDARDBitSW1_IN    RTE_GPIO_PORT02_PIN07   
+
+#define MAINTENANCE_LAMP_OUT       RTE_GPIO_PORT03_PIN00   
+#define L_FuelSender_OUT           RTE_GPIO_PORT03_PIN01   
+
+#define SWDIO_JTMS                 RTE_GPIO_PORT04_PIN00   
+#define Start_stop_MCU             RTE_GPIO_PORT04_PIN01   
+#define SELECT_MCU                 RTE_GPIO_PORT04_PIN02   
+#define VCC1V2_AMT_EN              RTE_GPIO_PORT04_PIN03      //ljs
+
+#define CAN_MCU_RXD                RTE_GPIO_PORT05_PIN00   
+#define CAN_MCU_TXD                RTE_GPIO_PORT05_PIN01   
+#define CAN_STB_MCU                RTE_GPIO_PORT05_PIN02   
+#define HighBeam_MCU               RTE_GPIO_PORT05_PIN03   
+#define LeftTurn_MUC_OUT           RTE_GPIO_PORT05_PIN04   
+#define RightTurn_MUC_OUT          RTE_GPIO_PORT05_PIN05   
+
+#define IIC_SCL_24G16              RTE_GPIO_PORT06_PIN00   
+#define IIC_SDA_24G16              RTE_GPIO_PORT06_PIN01   
+#define IIC_SCL_3004               RTE_GPIO_PORT06_PIN02   
+#define IIC_SDA_3004               RTE_GPIO_PORT06_PIN03   
+
+#define Brake_Level_MCU            RTE_GPIO_PORT07_PIN00   
+#define KEY_SELECT_MCU             RTE_GPIO_PORT07_PIN01   
+#define KEY_OK_MCU                 RTE_GPIO_PORT07_PIN02   
+#define MCU_Hand_Brake             RTE_GPIO_PORT07_PIN03       //ljs
+#define Dipped_Head_Light_MUC      RTE_GPIO_PORT07_PIN04   
+#define Width_Lamp_MCU             RTE_GPIO_PORT07_PIN05       //位置灯
+#define RXD_2                      RTE_GPIO_PORT07_PIN06       //ljs
+#define TXD_2                      RTE_GPIO_PORT07_PIN07       //ljs
+
+#define L_BiasBitSW_POW            RTE_GPIO_PORT12_PIN00 
+#define MCU_XI                     RTE_GPIO_PORT12_PIN01 
+#define MCU_XO                     RTE_GPIO_PORT12_PIN02 
+#define X32768_IN                  RTE_GPIO_PORT12_PIN03 
+#define X32768_OUT                 RTE_GPIO_PORT12_PIN04 
+
+#define MCU_SPI_CS                 RTE_GPIO_PORT13_PIN00 
+#define RESEVER5_OUT_LOW           RTE_GPIO_PORT13_PIN06 
+#define SWCLK                      RTE_GPIO_PORT13_PIN07 
+
+#define VCC_33_EN_MCU              RTE_GPIO_PORT14_PIN00        //ljs
+#define KEY_MCU                    RTE_GPIO_PORT14_PIN01 
+#define A_Version                  RTE_GPIO_PORT14_PIN06 
+#define Engine_Failure_MCU         RTE_GPIO_PORT14_PIN07 
+
+typedef enum
+{
+    Gpio_KL30_Init = 0,
+    Gpio_WakeUp_Init,
+    Gpio_Sleep_Init,
+    Gpio_Uvalid,
+}_GpioUser_Enum;
+
+extern void Gpio_Init(_GpioUser_Enum InitMode);
+
+#endif