/*!
 * @file uds_services.c
 * @brief UDS services definition
 *
 */
#include "uds_config.h"

#if BOOTLOADER_CODE_FLAG
uint32_t FBL_BaseAdrress = APP_FlashBaseAddress;
uint32_t FBL_AppSize = 0;
#endif

extern uint16_t  TP_Rx_Message_Length;
/*!
 * Enum Type. Service State
 */
typedef enum {
    UDS_SERVICE_NOT_START,                        /*!< Service not start */
    UDS_SERVICE_TRANSMITED,                       /*!< Service Request transmited */
    UDS_SERVICE_POSRSP_RECEIVED,                  /*!< Positive Response Received */
    UDS_SERVICE_NEGRSP_RECEIVED,                  /*!< Negtive Response Received */
    UDS_SERVICE_PENDING_RESPONSE                  /*!< Pending Response Received */
} UDS_SERVICE_STATE_T;
/*!
 * Struct Type. Service control
 */
typedef struct {
    uint8_t                 service;             /*!< Service ID */
    UDS_SERVICE_STATE_T     state;               /*!< Service state */
    uint8_t                 sn;                  /*!< Sequence Number */
    uint16_t                timer;               /*!< Timer */
} UDS_SERVICE_CTRL_T;

#define SERVICE_TIMEOUT_THRESSHOLD  30          /*!< Timeout Time */

static UDS_SERVICE_CTRL_T UDS_CurService;        /*!< Current service control */

static uint8_t service_buf[128];
/*!
 * @brief UDS_Service_Init
 * Initialization function for UDS service
 *
 */
void UDS_Service_Init(void)
{
#if BOOTLOADER_CODE_FLAG
    //memset(service_buf, 0x00, 10);

    if(GetUdsUpdataFlag() == true) {
        UdsService.SessionDiagModel = _UDS_PROGRAM_SESSION;
        UdsService.UpDataFlg=true;
        UdsService.SeedKeyIsOK = 0;
        UdsService.AlreadSendSeed = false;
        UdsService.SessionTimer=0;
        UdsService.NcmDisRxAndTx = 0;
        UdsService.NmcmDisRxAndTx = 0;
        UdsService.DisDTCRecord=0;
        UdsService.KeyErrLockTimer = 0;
		UdsService.KeyLockFlg = false;
        service_buf[0] = 0x50;
        service_buf[1] = UdsService.SessionDiagModel;
        service_buf[2] = (uint8_t)(UDS_P2Sever>>8);
        service_buf[3] = (uint8_t)(UDS_P2Sever);
        service_buf[4] = (uint8_t)(UDS_P2SeverMax>>8);
        service_buf[5] = (uint8_t)(UDS_P2SeverMax);
        HAL_UDS_Transmit_Physical_Request(6,service_buf);
    }
#endif

    UDS_CurService.service = 0;
    UDS_CurService.state = UDS_SERVICE_POSRSP_RECEIVED;
    UDS_CurService.sn =1;
    UDS_CurService.timer = 0;

    //TP_Init();
}
#if BOOTLOADER_CODE_FLAG

extern void RAMFLASHInit(void);

/*!
 * @brief UDS_Service_37
 * Service function for service 37
 *
 */
void UDS_Service_37(uint8_t *pdata,uint16_t length)
{
    uint8_t ucErrCode=0;
    service_buf[0] = 0x77;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
    	if (true == UdsService.PhyFlg) {
	        UDS_CurService.service= 0x77;
	        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
	        UDS_CurService.state = UDS_SERVICE_NOT_START;

	        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,0)) {
	            if(1==UdsService.SeedKeyIsOK) {
	                /*if(true == CheckUdsDlcIsOk(UdsService.RxDlc,5)) {
	                    if(true == CheckVechileStatus()) {
	                        service_buf[0] = 0x77;
	                        UdsUpData.GetCrc = (pdata[0]<<24) + (pdata[1] << 16) |(pdata[2]<<8) + pdata[3];
	                        HAL_UDS_Transmit_Physical_Request(1,service_buf);
	                    } else
	                        ucErrCode=0x22;
	                } else */
	                if(true == CheckUdsDlcIsOk(UdsService.RxDlc,1)) {
	                    //if(true == CheckVechileStatus()) {
	                    	if (UdsUpData.DownloadSeq == DOWNLOAD_SEQUENCE_36) {
		                        service_buf[0] = 0x77;
                                service_buf[1] = ~((uint8_t)UdsUpData.checksum);
		                        UdsUpData.DownloadSeq = DOWNLOAD_SEQUENCE_37;
		                        HAL_UDS_Transmit_Physical_Request(2,service_buf);
	                        } else {
	                        	ucErrCode=0x24;
	                        }                        
	                    //} else
	                    //    ucErrCode=0x22;
	                } else
	                    ucErrCode=0x13;
	            } else
	                ucErrCode=0x33;
	        } else
	            ucErrCode=0x7F;

	        if(ucErrCode) {
	            HAL_UDS_Transmit_Pending_Response(0x37,ucErrCode);
	        }
	        UdsService.TxTimerOut = 10;
	    }
    }
}

void UDS_Service_36_Ack(uint8_t* routine_buf, uint8_t bufLen)
{
    uint8_t ucErrCode=0;//Rsq=0;
	uint16_t len = 0;
	
    //memset(service_buf, 0x00, 10);

    //(void)bufLen;
    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service= 0x36;
        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;

		if (true == UdsService.PhyFlg) {
		
	        ucErrCode = Set0x36DiagData(routine_buf,bufLen,service_buf,(uint16_t*)&len);

	        if(ucErrCode) {
	            HAL_UDS_Transmit_Pending_Response(0x36,ucErrCode);
	        }
	        UdsService.TxTimerOut = SERVICE_TIMEOUT_THRESSHOLD;
        }
    }
}

/*!
 * @brief UDS_Service_34
 * Service function for service 34
 *
 * @param dataformat data format
 * @param addrLenFormat address and length format
 * @param memBuf address data buffer pointer
 * @param sizeBuf size data buffer pointer
 */
void UDS_Service_34_Ack(uint8_t *pDst,uint16_t pLen)
{
    uint8_t ErrCode=0x0/*,hlen=0,lLen=0,aLen=0*/;
    uint8_t dataFormatIdentifier, addressAndLengthFormatIdentifier;
    //(void)pLen;
    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
		if (false == UdsService.PhyFlg) {
			return;
		}
        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,0)) {
            if(1==UdsService.SeedKeyIsOK) {
            	dataFormatIdentifier = pDst[0];
            	addressAndLengthFormatIdentifier = pDst[1];
            	
//                service_buf[0] = 0x74;
//                service_buf[1] = pDst[0];
//                hlen = ((pDst[1]>>4)&0x0F);
//                lLen = (pDst[1]&0x0F);
//                aLen = hlen+lLen;
                //if(true == CheckUdsDlcIsOk(pLen,8))
                if(pLen == (0x0B-1)) {
                    //if(true == CheckVechileStatus()) {
                        if((dataFormatIdentifier!=0x0) || (addressAndLengthFormatIdentifier != 0x44)) {
                            ErrCode=0x31;
                        } else {                       
                            FBL_BaseAdrress = ((uint32_t)pDst[2]<<24) | ((uint32_t)pDst[3]<<16) | ((uint32_t)pDst[4]<<8) | ((uint32_t)pDst[5]<<0);
                            FBL_AppSize = ((uint32_t)pDst[6]<<24) | ((uint32_t)pDst[7]<<16) | ((uint32_t)pDst[8]<<8) | ((uint32_t)pDst[9]<<0);
							service_buf[0] = 0x74;
							service_buf[1] = dataFormatIdentifier;
                            service_buf[1] = 0x20;
                            service_buf[2] = MSB(FMC_PAGE_SIZE+2);
                            service_buf[3] = LSB((FMC_PAGE_SIZE+2));
							UdsUpData.Sn = 1;
							UdsUpData.totalRecvLength = 0;
							UdsUpData.OffSetAdd = 0;
                            if ((FBL_BaseAdrress == APP_FlashBaseAddress) && (FBL_AppSize < BOOTLOADER_APP_DATA_LEN_MAX)) {
                            	if (UdsUpData.RoutineEraseMemoryFlg) {
                                	HAL_UDS_Transmit_Physical_Request(4, service_buf);
                                } else {
									ErrCode=0x22;
                                }
                            } else {
                                ErrCode=0x70;
                            }
                        }
                    //} else
                    //    ErrCode=0x22;
                } else {
                    ErrCode=0x13;
                }
            } else {
                ErrCode=0x33;
            }
        } else {
            ErrCode=0x7F;
        }

        if(ErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x34,ErrCode);
        } else {
			UdsUpData.DownloadSeq = DOWNLOAD_SEQUENCE_34;
        }

        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        UdsService.TxTimerOut = 20;
    }
}

#endif
/*!
 * @brief UDS_Service_31
 * Service function for service 31
 *
 * @param routine_buf routine buffer pointer
 * @param bufLen routine buffer length
 */
void UDS_Service_31(uint8_t* routine_buf, uint8_t bufLen)
{
    uint8_t ucErrCode=0;
    uint16_t len = 0;
    // uint16_t ReqId = 0;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service= 0x31;
        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;

		if (true == UdsService.PhyFlg) {
			if (true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_DEFAULT_SESSION,1)) {
                ucErrCode = Set0x31DiagData(routine_buf,bufLen,service_buf,(uint16_t*)&len);
	        } else {
	        	ucErrCode = 0x7F;
	        }
	        if(ucErrCode) {
	            HAL_UDS_Transmit_Pending_Response(0x31,ucErrCode);
	            // Debug("@0x31 NG Repose!!! \r\n");
	        } else {
	            HAL_UDS_Transmit_Physical_Request(len, service_buf);
	        }
	        UdsService.TxTimerOut = 10;
        }
    }
}
void UDS_Service_28(uint8_t* requ, uint8_t bufLen)
{
    uint8_t ucErrCode=0,ucRsp=0;
    uint8_t comCrtlType = 0;
    (void)bufLen;

    service_buf[0] = 0x68;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service= 0x28;
        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_DEFAULT_SESSION,1)) {
            if(true == CheckUdsDlcIsOk(UdsService.RxDlc,3)) {
                if(true == CheckVechileStatus()) {
                    ucRsp=requ[0]&0x7F;
                    comCrtlType = requ[1];
                    if ((0x0 == ucRsp) || (0x03 == ucRsp)) {
                        if ((comCrtlType == 1) || (comCrtlType == 3)) {
                            if (0x0 == ucRsp) {
                                if (comCrtlType == 1) {
                                    UdsService.NcmDisRxAndTx = 0;
//                                } else if (comCrtlType == 2) {
//                                    UdsService.NmcmDisRxAndTx = 0;
                                } else {
                                    UdsService.NcmDisRxAndTx = 0;
                                    UdsService.NmcmDisRxAndTx = 0;
                                } 
                            } else if(0x03 == ucRsp) {
                                if (comCrtlType == 1) {
                                    UdsService.NcmDisRxAndTx = 1;
//                                } else if (comCrtlType == 2) {
//                                    UdsService.NmcmDisRxAndTx = 1;
                                } else {
                                    UdsService.NcmDisRxAndTx = 1;
                                    UdsService.NmcmDisRxAndTx = 1;
                                }  
                            }
                            if (true == CheckSubSidNeedPosResp(requ[0])) {
	                            service_buf[1] = requ[0];
	                            HAL_UDS_Transmit_Physical_Request(2, service_buf);
                            }
                        } else {
                            if (UdsService.CanID == UDS_PHY_TX_ID) {
                                ucErrCode=0x31;
                            }
                        }
                    } else {
                        if(true== UdsService.PhyFlg) {
                            UdsService.PhyFlg = false;
                            ucErrCode = 0x12;
                        }
                    }
                } else
                    ucErrCode = 0x22;
            } else
                ucErrCode = 0x13;
        } else {
            if (UdsService.CanID == UDS_PHY_TX_ID) {
                ucErrCode = 0x7F;
            }
        }

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x28,ucErrCode);
        }

        UdsService.TxTimerOut = 10;
    }
}

void UDS_Service_85(uint8_t* routine_buf, uint8_t bufLen)
{
    uint8_t ucErrCode=0,Rsq=0;

    (void)bufLen;
    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service= 0x85;
        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        //UdsService.SessionDiagModel=3;
        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_DEFAULT_SESSION,1)) {
            if(true == CheckUdsDlcIsOk(UdsService.RxDlc,2)) {
                if(true != CheckVechileStatus()) ucErrCode = 0x22;
                else {
                    Rsq = routine_buf[0]&0x7F;
                    if((0x01 == Rsq)||(0x02 == Rsq)) {
                    	if(0x01 == Rsq) {
                            UdsService.DisDTCRecord=0;
                        } else {
                            UdsService.DisDTCRecord=1;
                        }
                        if(true == CheckSubSidNeedPosResp(routine_buf[0])) {
                            service_buf[0] = 0xC5;
                            service_buf[1] = routine_buf[0];                          
                            HAL_UDS_Transmit_Physical_Request(2,service_buf);
                        }
                        //else
                        //ucErrCode = 0x12;
                    } else {
                        if(true== UdsService.PhyFlg)

                        {
                            UdsService.PhyFlg = false;
                            ucErrCode = 0x12;
                        }
                    }
                }
            } else
                ucErrCode=0x13;
        } else {
            if (UdsService.CanID == UDS_PHY_TX_ID) {
                ucErrCode = 0x7F;
            }
        }

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x85,ucErrCode);
        }
        UdsService.TxTimerOut = 10;
    }
}

extern DIDs gDIDCache;

void UDS_Nrc78PostProcessing(void)
{
	uint8_t dlen = 0;
#if BOOTLOADER_CODE_FLAG
    //uint32_t address = 0;
    //uint16_t len = 0;
    status_t ret = STATUS_ERROR;
    uint8_t result = 0;
    uint32_t dataLen = 0;
    uint32_t eraseSize = 0;
    static uint32_t eraseAddress = 0, eraseLength = 0;
    static uint32_t eraseAddrOffset = 0;
    static uint16_t erasePageCnt = 0;
    // const uint8_t app_flag[] = BCM_APP_FLAG;
    // uint8_t buffer[36] = {0};

//    memset(service_buf, 0x00, 10);
	
    if (UdsUpData.RxEraseFlg == true) {
        UdsUpData.RxEraseFlg = false;
        if (UdsUpData.EraseMemoryFlg == false) {
            UdsUpData.EraseMemoryFlg = true;
            eraseAddress = UdsUpData.EraseAddress;
            eraseLength = UdsUpData.EraseLength;
            eraseAddrOffset = 0;
            erasePageCnt = 0;
            UdsUpData.EraseMemorySts = ERASE_MEMORY_STS_NONE;
        } else {
            UdsUpData.EraseMemorySts = ERASE_MEMORY_STS_FAILURE;
            UdsUpData.EraseMemoryFlg = false;
        }
    } else if (UdsUpData.EraseMemoryFlg == true) {
        UdsUpData.EraseMemorySts = ERASE_MEMORY_STS_IN_PROGRESS;
        //擦除一个页（2K）40ms
        if (eraseLength) {
            if (eraseLength > FMC_PAGE_SIZE) {
                eraseLength -= FMC_PAGE_SIZE;
                eraseSize = FMC_PAGE_SIZE;
            } else {
                eraseSize = eraseLength;
                eraseLength = 0;
            }
        }
        ret = EraseApplicationSoftwareCode(eraseAddress + eraseAddrOffset, eraseSize);
        eraseAddrOffset += eraseSize;
        erasePageCnt++;

        if (ret != STATUS_SUCCESS) {
            UdsUpData.EraseMemorySts = ERASE_MEMORY_STS_FAILURE;
            UdsUpData.EraseMemoryFlg = false;
        } else if (eraseLength == 0) {
            UdsUpData.EraseMemorySts = ERASE_MEMORY_STS_COMPLETED;
            UdsUpData.EraseMemoryFlg = false;
            service_buf[dlen++] = 0x71;
            service_buf[dlen++] = 0x01;
            service_buf[dlen++] = 0xFF;
            service_buf[dlen++] = 0x00;
            service_buf[dlen++] = 0x01;
            HAL_UDS_Transmit_Physical_Request(dlen,service_buf);
        } else if ((erasePageCnt % 20) == 0) {
            //20次发一次78NRC  20*40ms=800ms
            HAL_UDS_Transmit_Pending_Response(0x31,0x78);
        } 
    } else if (UdsUpData.RxProgramFlag == true) {
    	service_buf[dlen++] = 0x76;
        service_buf[dlen++] = UdsUpData.Sn;
        dataLen = UdsService.RxDlc-2;

        CalcCheckSum(&UdsUpData.checksum, UdsUpData.Buf, dataLen);
        if (UdsUpData.OffSetAdd == 0) {
            CRC16_CCITT_1021_Init(&UdsUpData.CalcCrc);
            CRC16_CCITT_1021_Update(&UdsUpData.CalcCrc, UdsUpData.Buf, 4);
            UdsUpData.StackTopAdr = (*(__IO uint32_t*)((uint32_t)UdsUpData.Buf));//保存栈顶地址
            memset(UdsUpData.Buf, 0xFF, 4);
        } 
       
        ret = ProgramApplicationSoftware(APP_FlashBaseAddress + UdsUpData.OffSetAdd, UdsUpData.Buf, dataLen);
        UdsUpData.OffSetAdd += dataLen;
        if (UdsUpData.totalRecvLength >= FBL_AppSize) {
            dataLen = FBL_AppSize - 4;
            //crc16校验
            CRC16_CCITT_1021_Update(&UdsUpData.CalcCrc, (uint8_t*)(APP_FlashBaseAddress+4), dataLen);
        }

        if (ret == STATUS_SUCCESS) {
            HAL_UDS_Transmit_Physical_Request(dlen, service_buf);
        } else {
            UdsUpData.StackTopAdr = 0;
            HAL_UDS_Transmit_Pending_Response(0x36,0x72);
        }
        UdsUpData.Sn++;
        UdsUpData.RxProgramFlag = false;
    }
#else 
	
#endif

}

//////////////////////////////////////////////////////////////////////
void UDS_Service_11(uint8_t* requ)
{
    uint8_t ucErrCode=0,ucResp=0;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service= 0x11;
        UDS_CurService.state = UDS_SERVICE_NOT_START;
        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        if (true == UdsService.PhyFlg) {
            if(true == CheckUdsDlcIsOk(UdsService.RxDlc,2)) {
                ucResp=requ[0]&0x7F;
                if(CheckIsSupportSubFunc_Sid11(ucResp)) {
                    if(true == CheckVechileStatus()) {
                        if(true == CheckSubSidNeedPosResp(requ[0])) {
                            service_buf[0] = 0x51;
                            service_buf[1] = requ[0];
                            HAL_UDS_Transmit_Physical_Request(2,service_buf);
                        }
                        if(true == UdsUpData.UpModleFlg) {
                            UdsUpData.UpModleFlg = false;
                            service_buf[0]=0x00;
                            service_buf[1]=0x00;
                            //EEPROM_write(UDS_UPDATE_ADD,service_buf,2);
                            //UdsUpData.UpCompFlg = true;
                        }
                        UdsService.ResetMcuFlg=TRUE;
                        UdsService.RstTimer=200;
                        //Debug("Mcu Rst of Uds\r\n");
                    } else {
                        ucErrCode = 0x22;
                    }
                } else {
                    if(true== UdsService.PhyFlg)

                    {
                        UdsService.PhyFlg = false;
                        ucErrCode = 0x12;
                    }
                }
            } else {

                ucErrCode = 0x13;
            }
	        if(ucErrCode) {
	            HAL_UDS_Transmit_Pending_Response(0x11,ucErrCode);
	        }
	        UdsService.TxTimerOut = 10;
	    }
    }
}

void UDS_Service_27(UDS_SERVICE_27_T in_service, uint8_t *requ, uint8_t* keyBuf)
{
    uint8_t ucErrCode=0;
    uint8_t ret = 0xFF;
    uint16_t key;
    static uint8_t s_get_seed_flag;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
	    if (true == UdsService.PhyFlg) {
	        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_DEFAULT_SESSION,1)) {
	            //memset(service_buf,0x0,18);
	        #if BOOTLOADER_CODE_FLAG
	            if(UDS_SERVICE_27_REQUEST_FBL_SEED==requ[0]) {
	        #else 
	       		if(UDS_SERVICE_27_REQUEST_SEED==requ[0]) {
	        #endif
	                s_get_seed_flag = 0;
	                if(true == CheckUdsDlcIsOk(UdsService.RxDlc,2)) {                    
	                    if(UdsService.KeyLockFlg==true) ucErrCode = 0x37;
	                    else {
                        	if(true != CheckVechileStatus()) ucErrCode = 0x22;
                    		else {
	                            service_buf[0] = 0x67;
	                            service_buf[1] = requ[0];
	                            ret = GenerateSID27SeedValue(seed_value);
	                            if( ret == 0) {
	                                if((1==UdsService.SeedKeyIsOK)&&(true==UdsService.AlreadSendSeed)) {
	                                    memset(&service_buf[2],0x0,sizeof(seed_value));
	                                    //memcpy(&service_buf[2],seed_value,sizeof(seed_value));
	                                //} else if  (UdsService.SeedKeyLevel == UDS_SERVICE_27_SEND_KEY) {
	                                //    memset(&service_buf[2],0x0,sizeof(seed_value));
	                                } else {
	                                    memcpy(&service_buf[2],seed_value,sizeof(seed_value));
	                                }
	                                s_get_seed_flag = 1;
	                                UdsService.AlreadSendSeed = true;
	                                UDS_CurService.service= 0x67;
	                                UDS_CurService.state = UDS_SERVICE_NOT_START;
	                                HAL_UDS_Transmit_Physical_Request(2+2, service_buf);
	                            }
                            }
	                    }
	                } else
	                    ucErrCode = 0x13;
	        #if BOOTLOADER_CODE_FLAG
	            } else if(UDS_SERVICE_27_SEND_FBL_KEY == requ[0]) {
	        #else
	        	} else if(UDS_SERVICE_27_SEND_KEY == requ[0]) {
	        #endif
	                if(CheckUdsDlcIsOk(UdsService.RxDlc,sizeof(key_value)+2)) {
	                    if(true != CheckVechileStatus()) ucErrCode = 0x22;
	                    else {
	                        if (/*(UdsService.KeyLockFlg == true) || */(UdsService.KeyErrCnt > UDS_27SERVICE_ERR_NUM_MAX) || (s_get_seed_flag == 0)) {
	                            if(UdsService.KeyErrCnt >= 3)    ucErrCode = 0x36;
	                            if(s_get_seed_flag == 0)        ucErrCode = 0x24;
	                        } else {
	                            if (s_get_seed_flag == 1)   s_get_seed_flag = 0;
	                            memset(service_buf,0x0,sizeof(key_value)+2);
	                            if(memcmp(service_buf,seed_value,sizeof(seed_value))) { //Bug
	                                key = GenerateSID27KeyValue(WORD(seed_value[0], seed_value[1]));
	                                
//	                                if (ret == 0) {
	                                    keyBuf[0] = requ[1];
	                                    keyBuf[1] = requ[2];
	                                    keyBuf[2] = requ[3];
	                                    keyBuf[3] = requ[4];

	                                    key_value[0] = MSB(key);
	                                    key_value[1] = LSB(key);

	                                    if(!memcmp(keyBuf,key_value,sizeof(key_value))) {
	                                        UdsService.KeyErrCnt=0;
	                                        service_buf[0] = 0x67;
	                                        service_buf[1] = requ[0];  //
	                                        UdsService.SeedKeyLevel = (UDS_SERVICE_27_SEND_KEY == requ[0])?SECURITY_LEVEL_1:SECURITY_LEVEL_FBL; 
	                                        UDS_CurService.service= 0x67;
	                                        UDS_CurService.state = UDS_SERVICE_NOT_START;
	                                        UdsService.SeedKeyIsOK = TRUE;
	                                        HAL_UDS_Transmit_Physical_Request(2, service_buf);
	                                    } else { //
	                                        if(UdsService.KeyErrCnt<0xFF) UdsService.KeyErrCnt++;

	                                        if((UDS_27SERVICE_ERR_NUM_MAX-1) >= UdsService.KeyErrCnt) ucErrCode = 0x35;

	                                        else if(UDS_27SERVICE_ERR_NUM_MAX == UdsService.KeyErrCnt) {
	                                            ucErrCode = 0x36;
	                                            UdsService.KeyErrLockTimer=10;
	                                            UdsService.KeyLockFlg=true;
	                                        }
	                                   	}
//	                                } else {
//	                                    ucErrCode = 0x12;
//	                                }

	                            } else {
	                                ucErrCode = 0x24;
	                            }

	                            memset(seed_value,0x0,sizeof(key_value)+2);
	                        }
	                    }
	                } else
	                    ucErrCode = 0x13;
	            } else {
	                if(UdsService.RxDlc<2) {
	                    ucErrCode = 0x13;
	                } else
	                    ucErrCode = 0x12;
	            }
	        } else
	            ucErrCode = 0x7F;

	        if(ucErrCode) {
	            HAL_UDS_Transmit_Pending_Response(0x27,ucErrCode);
	        }
	        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
	        UdsService.TxTimerOut = SERVICE_TIMEOUT_THRESSHOLD;
	    }
	}
}



void UDS_Service_10_Response(uint8_t in_session)
{
    uint8_t Len=2,ucErrCode=0,ucResp=0;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service = 0x10;
        UDS_CurService.state = UDS_SERVICE_NOT_START;

        if( true == CheckUdsDlcIsOk(UdsService.RxDlc,2) ) {
            //memset(service_buf,0x0,8);
            ucResp = in_session&0x7F;
            if((_UDS_DEFAULT_SESSION == ucResp)||(_UDS_PROGRAM_SESSION == ucResp)||(_UDS_EXT_SESSION == ucResp)) {
                if(UdsService.SessionDiagModel == _UDS_EXT_SESSION && ucResp == _UDS_PROGRAM_SESSION) {
                    if (CheckVechileStatus()) {
                        UdsService.SessionDiagModel = ucResp;
#if  (BOOTLOADER_CODE_FLAG == 0)
                        SetUdsUpdataFlag();
                        //Debug("Goto App1 Uds Updata\r\n");
                        UdsService.UpDataFlg=true;
                        UdsService.ResetMcuFlg=TRUE;
                        UdsService.RstTimer=200;
                        ucErrCode = 0x78;
#else
                        UdsService.SessionDiagModel=ucResp;
                        UdsService.SeedKeyIsOK = 0;
                        UdsService.AlreadSendSeed = false;
                        UdsService.SessionTimer=0;
                        UdsService.NcmDisRxAndTx = 0;
                        UdsService.NmcmDisRxAndTx = 0;
                        UdsService.DisDTCRecord=0;
                        if(true == CheckSubSidNeedPosResp(in_session)) {
	                        service_buf[0] = 0x50;
	                        service_buf[1] = (uint8_t)in_session;
	                        service_buf[2] = (uint8_t)(UDS_P2Sever>>8);
	                        service_buf[3] = (uint8_t)(UDS_P2Sever);
	                        service_buf[4] = (uint8_t)(UDS_P2SeverMax>>8);
	                        service_buf[5] = (uint8_t)(UDS_P2SeverMax);
	                        Len = 6;
	                        HAL_UDS_Transmit_Physical_Request(Len,service_buf);
                        }
                        UdsUpData.RoutineEraseMemoryFlg = false;
                        UdsUpData.RoutineChkProgIntegrityFlg = false;
                        UdsUpData.RoutineChkProgIntegrityPass = false;
                        UdsUpData.RoutineEraseMemoryErr = false;
                        UdsUpData.PrintFingerFlg = false;
                        UdsUpData.DownloadSeq = DOWNLOAD_SEQUENCE_IDLE;
#endif
                    } else {
                        ucErrCode = 0x22;
                    }
                } else if ((UdsService.SessionDiagModel == _UDS_DEFAULT_SESSION && ucResp == _UDS_PROGRAM_SESSION) \
                		|| (UdsService.SessionDiagModel == _UDS_PROGRAM_SESSION && ucResp == _UDS_EXT_SESSION)) {
                    ucErrCode = 0x22;
                } else {
                    if (CheckVechileStatus()) {
                    	if (ucResp == _UDS_EXT_SESSION) {
                    		UdsService.ChkProgPreconditionFlg = false;
                    #if BOOTLOADER_CODE_FLAG == 0
                    	} else if (ucResp == _UDS_DEFAULT_SESSION) {
                    		IO_InputOutputRelease();
                    #else
                    	} else if ((ucResp == _UDS_DEFAULT_SESSION) && (UdsService.SessionDiagModel == _UDS_PROGRAM_SESSION)) {
//                    		//在编程会话模式下，“0x10 0x01”会导致 ECU 重启
//                    		UdsService.ResetMcuFlg=TRUE;
//                        	UdsService.RstTimer=200;
                    #endif
                    	}
                        UdsService.SessionDiagModel=ucResp;
                        UdsService.SessionTimer=0;
                        UdsService.SeedKeyIsOK = 0;
                        UdsService.AlreadSendSeed = false;
                        if (!(UdsService.SessionDiagModel == _UDS_EXT_SESSION && ucResp == _UDS_EXT_SESSION)) {
                            UdsService.NcmDisRxAndTx = 0;
                            UdsService.NmcmDisRxAndTx = 0;
                            UdsService.DisDTCRecord=0;
                        }
                        if(true == CheckSubSidNeedPosResp(in_session)) {
	                        service_buf[0] = 0x50;
	                        service_buf[1] = (uint8_t)in_session;
	                        service_buf[2] = (uint8_t)(UDS_P2Sever>>8);
	                        service_buf[3] = (uint8_t)(UDS_P2Sever);
	                        service_buf[4] = (uint8_t)(UDS_P2SeverMax>>8);
	                        service_buf[5] = (uint8_t)(UDS_P2SeverMax);
	                        Len = 6;
	                        HAL_UDS_Transmit_Physical_Request(Len,service_buf);
                        }
                    } else {
                        ucErrCode = 0x22;
                    }
                }
            } else {
                if(true== UdsService.PhyFlg) {
                    UdsService.PhyFlg = false;
                    ucErrCode = 0x12;
                }
            }
        } else
            ucErrCode = 0x13;

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x10,ucErrCode);
        }

        UDS_CurService.timer = 10;
        UdsService.TxTimerOut = UDS_CurService.timer;
    }
}

void UDS_Service_0x22_Response(void)
{
    uint8_t ucErrCode=0;
    uint16_t Len=0;

    if ((UDS_CurService.state > UDS_SERVICE_TRANSMITED) && (true == UdsService.PhyFlg)) {
        //if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,1)) {
            //if(true == CheckUdsDlcIsOk(UdsService.RxDlc,3))
            if(UdsService.RxDlc>=3) {
                //if(true != CheckVechileStatus()) ucErrCode = 0x22;
                //else {
                    if(1==(UdsService.RxDlc%2) && UdsService.RxDlc <= 3) {
                        //memset(service_buf,0x0,128);
                        Len = Get0x22SerDiagData(service_buf);
                        if(Len>=3) {
                            HAL_UDS_Transmit_Physical_Request(Len, service_buf);
                        } else {
                            if (UdsService.CanID == UDS_PHY_TX_ID) {
                                ucErrCode = 0x31;
                            }
                        }
                    } else
                        ucErrCode = 0x13;
                //}
            //} else
            //    ucErrCode = 0x13;
        } else {
            ucErrCode = 0x13;
        }

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x22,ucErrCode);
        }

        //UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        UdsService.TxTimerOut = 30 ;
    }
}
void UDS_Service_0x2E_Response(INT8U *pIn,INT16U pLen)
{
    uint8_t rst=0,ucErrCode=0;

    if ((UDS_CurService.state > UDS_SERVICE_TRANSMITED) && (true == UdsService.PhyFlg)) {
    #if BOOTLOADER_CODE_FLAG
        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,0)) {
    #else
    	if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_EXT_SESSION,0)) {
    #endif
            if( pLen < 3 ) {
                ucErrCode = 0x13;
            } else {
                rst = Set0x2EDidDiagData(pIn,pLen-2);
                if(rst == 0) {
                    service_buf[0]=0x6E;
                    service_buf[1]=pIn[0];
                    service_buf[2]=pIn[1];
                    HAL_UDS_Transmit_Physical_Request(3,service_buf);
                } else {
                    ucErrCode = rst;
                }
            }
            
        } else
            ucErrCode = 0x7F;

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x2E,ucErrCode);
        }
        //UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        UdsService.TxTimerOut = 40;
    }
}
void UDS_Service_0x3E_Response(INT8U *pIn)
{
    uint8_t ucErrCode=0,Rsp=0;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        if(true == CheckUdsDlcIsOk(UdsService.RxDlc,2)) {
            Rsp = pIn[0]&0x7F;
            if(0==Rsp) {
                if(true == CheckSubSidNeedPosResp(pIn[0])) {
                    service_buf[0]=0x7E;
                    service_buf[1]=pIn[0];
                    HAL_UDS_Transmit_Physical_Request(2,service_buf);
                }
            } else { //
                if(true== UdsService.PhyFlg)

                {
                    UdsService.PhyFlg = false;
                    ucErrCode = 0x12;
                }
            }
        } else
            ucErrCode = 0x13;

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x3E,ucErrCode);
        }
        UdsService.TxTimerOut = 10;
    }
}

#if BOOTLOADER_CODE_FLAG == 0

void UDS_Service_14(uint8_t* routine_buf, uint8_t bufLen)
{
    uint8_t ucErrCode=0;
    uint32_t jj;

    (void)bufLen;
    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
        UDS_CurService.service= 0x14;
        UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;

        jj = (routine_buf[0]<<16)+(routine_buf[1]<<8)+routine_buf[2];
        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,1)) {
            if(true == CheckUdsDlcIsOk(UdsService.RxDlc,4)) {
                if(true == CheckVechileStatus()) {
                    if(0xFFFFFF==jj) { //
						ClearDtc();
                        service_buf[0] = 0x54;
                        HAL_UDS_Transmit_Physical_Request(1,service_buf);
                    } else {
                        if (UdsService.CanID == UDS_PHY_TX_ID) {
                            ucErrCode = 0x31;
                        }
                    }
                } else
                    ucErrCode = 0x22;
            } else
                ucErrCode = 0x13;
        } else
            ucErrCode = 0x7F;

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x14,ucErrCode);
        }
        UdsService.TxTimerOut = 10;
    }
}

void UDS_Service_0x19_Response(void)
{
    uint8_t Len=0,ucErrCode=0,Rsp=0;

    if ((UDS_CurService.state > UDS_SERVICE_TRANSMITED) && (true == UdsService.PhyFlg)) {
        UDS_CurService.service = 0x19;
        UDS_CurService.state = UDS_SERVICE_NOT_START;
        if(true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,1)) {
            if( UdsService.RxDlc >= 2 ) {
                Rsp = UdsService.ReqCmdBuf[0]&0x7F;
                switch(Rsp) {
                case 0x01:
                case 0x02:
                    if (CheckIsSupportSubFunc_Sid19(Rsp)) {
                    	if (true == CheckUdsDlcIsOk(UdsService.RxDlc,3)) {
                            Len = Get0x19SerDiagData(service_buf,Rsp,&UdsService.ReqCmdBuf[0]); //
                            if(Len) {
                                HAL_UDS_Transmit_Physical_Request(Len, service_buf);
                            } else {
                            	ucErrCode = 0x31;
                            }
                        } else 
                        	ucErrCode = 0x13;
                    } else
                        ucErrCode = 0x12;
                    break;
                case 0x04:
                    if (CheckIsSupportSubFunc_Sid19(Rsp)) {
                    	if (true == CheckUdsDlcIsOk(UdsService.RxDlc,6)) {
                            Len = Get0x19SerDiagData(service_buf,Rsp,&UdsService.ReqCmdBuf[0]); //
                            if(Len > 3) {
                                //for(int i=0;i<Len;i++)
                                //{Sprintf("-%0x",service_buf[i]);}
                                HAL_UDS_Transmit_Physical_Request(Len, service_buf);
                            } else
                                ucErrCode = 0x31;
                        } else 
                        	ucErrCode = 0x13;
                    } else
                        ucErrCode = 0x12;
                    break;
                case 0x06:
                    if (CheckIsSupportSubFunc_Sid19(Rsp)) {
                    	if (true == CheckUdsDlcIsOk(UdsService.RxDlc,6)) {
                            Len = Get0x19SerDiagData(service_buf,Rsp,&UdsService.ReqCmdBuf[0]); //
                            if(Len > 3) {
                                //for(int i=0;i<Len;i++)

                                HAL_UDS_Transmit_Physical_Request(Len, service_buf);
                            } else
                                ucErrCode = 0x31;
                        } else 
                        	ucErrCode = 0x13;
                    } else
                        ucErrCode = 0x12;
                    break;
                case 0x0A:
                    if (CheckIsSupportSubFunc_Sid19(Rsp)) {
                    	if (true == CheckUdsDlcIsOk(UdsService.RxDlc,2)) {
                            Len = Get0x19SerDiagData(service_buf,Rsp,&UdsService.ReqCmdBuf[0]); //
                            if(Len) {
                                HAL_UDS_Transmit_Physical_Request(Len, service_buf);
                            } else {
                            	ucErrCode = 0x31;
                            }
                        } else 
                        	ucErrCode = 0x13;
                    } else
                        ucErrCode = 0x12;
                    break;
                default:
                    //if(true != CheckUdsDlcIsOk(UdsService.RxDlc,3))
                    if(UdsService.RxDlc<2) {
                        ucErrCode = 0x13;
                    } else {
                        if(true== UdsService.PhyFlg)

                        {
                            UdsService.PhyFlg = false;
                            ucErrCode = 0x12;
                        }
                    }
                    break;

                }
            } else
                ucErrCode = 0x13;
        } else
            ucErrCode = 0x7F;

        if (ucErrCode == 0x12) {
			if (true != UdsService.PhyFlg) {
				ucErrCode = 0;
			}
		}
        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(0x19,ucErrCode);
        }
        //UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        UdsService.TxTimerOut = 10 ;
    }
}


void UDS_Service_0x2F_Response(void)
{
    uint8_t ucErrCode=0/*,Rsp=0*/;
    uint16_t len = 0;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
	    if (true == UdsService.PhyFlg) {
	        if (true == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_EXT_SESSION,0)) {
	            if (1 == UdsService.SeedKeyIsOK) {
	                ucErrCode = Set0x2FDiagData(UdsService.ReqCmdBuf,UdsService.RxDlc,service_buf,&len);
	            } else {
	            	ucErrCode = 0x33;
	            }
	        } else {
	            ucErrCode = 0x7F;
			}
	        if(ucErrCode) {
	            HAL_UDS_Transmit_Pending_Response(0x2F,ucErrCode);
	        } else {
				HAL_UDS_Transmit_Physical_Request(len,service_buf);
	        }
	        UdsService.TxTimerOut = 10;
	    }
    }
}
#endif

void UDS_Service_NonSupport_Response(INT8U pIn)
{
    uint8_t ucErrCode=0;

    if(UDS_CurService.state > UDS_SERVICE_TRANSMITED) {
    	#if BOOTLOADER_CODE_FLAG == 1
        if((0x34==UdsService.Id)||(0x36==UdsService.Id)||(0x37==UdsService.Id)) {
            if(false == CheckIsBeyonSession(UdsService.SessionDiagModel,_UDS_PROGRAM_SESSION,0))
                ucErrCode=0x7f;
        } else
        #endif
       	{
            if(true== UdsService.PhyFlg)

            {
                UdsService.PhyFlg = false;
                ucErrCode = 0x11;
            }
        }

        if(ucErrCode) {
            HAL_UDS_Transmit_Pending_Response(pIn,ucErrCode);
        }
        //UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
        UdsService.TxTimerOut = 10;
    }
}

/*!
 * @brief UDS_Service_PosRsp_Handler
 * Posive response handler
 *
 * @param length data length
 * @param rsp_buf response data buffer pointer
 */

static void UDS_Service_PosRsp_Handler(uint16_t length, uint8_t* rsp_buf)
{
    (void)length;
    //demo here
    //define the handler behavior by customer.
    if(UDS_CurService.service == 0x27) {
        if(rsp_buf[1] == 0x01) {
            UDS_Demo_Calculate_Key(rsp_buf);
        }
    }
    //UDS_Pos_Response_Callback();
}

/*!
 * @brief UDS_Service_NegRsp_Handler
 * Negtive response handler
 *
 * @param negRsp Negtive response code
 */

static void UDS_Service_NegRsp_Handler(uint8_t negRsp)
{
    (void)negRsp;
    //define the handler behavior by customer.
    UDS_Neg_Response_Callback();
}

/*!
 * @brief UDS_Service_Pending
 * Send pending request
 *
 */

void UDS_Service_Pending(void)
{
    //define the handler behavior by customer.
    UDS_CurService.timer = SERVICE_TIMEOUT_THRESSHOLD;
}
/*!
 * @brief UDS_Service_Transmit_Confirmed
 * Callback function after the message is transmitted
 *
 */

void UDS_Service_Transmit_Confirmed(void)
{
    UDS_CurService.state = UDS_SERVICE_TRANSMITED;
}

/*!
 * @brief UDS_Service_Response_Handler
 * UDS Service Response handler
 *
 * @param TPReceivexMessageLength TP Receive Message Length
 * @param N_Result TP Result
 * @param Rec_Bufer TP Receive Buffer pointer
 */

void UDS_Service_Response_Handler(uint16_t TPReceivexMessageLength,
                                  uint8_t N_Result, uint8_t* Rec_Bufer)
{
	uint8_t i;
	
    if((0 == N_Result)
       &&(UDS_CurService.state == UDS_SERVICE_TRANSMITED)) {
        if((UDS_CurService.service+0x40) == Rec_Bufer[0]) {
            UDS_Service_PosRsp_Handler(TPReceivexMessageLength, Rec_Bufer);
            UDS_CurService.state = UDS_SERVICE_POSRSP_RECEIVED;
        } else if(Rec_Bufer[0] == 0x7F) {
            if(UDS_CurService.service == Rec_Bufer[1]) {
                if(Rec_Bufer[2] == 0x78) {
                    UDS_Service_Pending();
                    UDS_CurService.state = UDS_SERVICE_PENDING_RESPONSE;
                } else {
                    UDS_Service_NegRsp_Handler(Rec_Bufer[2]);
                    UDS_CurService.state = UDS_SERVICE_NEGRSP_RECEIVED;
                }
            }
        } else {
        }
    } else if((0 == N_Result)&&(UDS_CurService.state == UDS_SERVICE_POSRSP_RECEIVED)) {
        if(0x10 == Rec_Bufer[0]) {
            //UDS_Service_PosRsp_Handler(TPReceivexMessageLength, Rec_Bufer);
            UDS_CurService.state = UDS_SERVICE_POSRSP_RECEIVED;
            UdsService.RxSessionDiagModel = Rec_Bufer[1];
        }
        UdsService.Id = Rec_Bufer[0];

		for (i=0; i<UDS_SERVICE_NUM; i++) {
			if (UDSsid[i] == UdsService.Id) {
				if (/*(UdsService.Id == 0x2E) || */(UdsService.Id == 0x34) || (UdsService.Id == 0x36)) {
					if (0 == TP_Rx_Message_Length) {
						Service_Ctrl.index = i;
					}
				} else {
					Service_Ctrl.index = i;
				}
				break;
			}
		}
		if (UDS_SERVICE_NUM == i) {
			Service_Ctrl.index = UDS_SERVICE_NUM - 1;
		}
		
//        if(0x10 == UdsService.Id) Service_Ctrl.index = 0;
//        else if(0x11 == UdsService.Id) Service_Ctrl.index = 1;
//        else if(0x14 == UdsService.Id) Service_Ctrl.index = 2;
//        else if(0x19 == UdsService.Id) Service_Ctrl.index = 3;//(1==UdsService.MultFrameComp)
//        else if(0x22 == UdsService.Id) Service_Ctrl.index = 4;//(0==TP_Rx_Message_Length)
//        else if((0x2E == UdsService.Id)&&(0==TP_Rx_Message_Length)) Service_Ctrl.index = 5;
//        else if((0x27 == UdsService.Id)) Service_Ctrl.index = 6;
//        else if(0x3E == UdsService.Id) Service_Ctrl.index = 7;
//        else if(0x31 == UdsService.Id) Service_Ctrl.index = 8;
//        else if(0x28 == UdsService.Id) Service_Ctrl.index = 9;
//        else if(0x85 == UdsService.Id) Service_Ctrl.index = 10;
//        else if((0x34 == UdsService.Id)&&(0==TP_Rx_Message_Length)) Service_Ctrl.index = 11;
//        else if((0x36 == UdsService.Id)&&(0==TP_Rx_Message_Length)) Service_Ctrl.index = 12;
//        else if((0x37 == UdsService.Id)) Service_Ctrl.index = 13;
//        else {
//            Service_Ctrl.index = 14;
//        }
        memset(UdsService.ReqCmdBuf,0x0,20);
        memcpy(UdsService.ReqCmdBuf,&Rec_Bufer[1],20);
//        if(Service_Ctrl.index == 7) {
//            memcpy(UDS_SeedKeyBuf,&Rec_Bufer[2],8);
//        }
        //Debug("&&& TP_Rx_Message_Length=%d",TP_Rx_Message_Length);
        UdsService.RequestFlg = 1;
        //UdsService.SessionTimer=0;
        UdsService.RxDlc = TPReceivexMessageLength;
        //Debug("UdsService.Id = %x ,UdsService.SessionDiagModel=%x\r\n",UdsService.Id,UdsService.SessionDiagModel); //
    } else if((N_WRONG_DLC == N_Result)&&(TpRxFlg==true)) {
        TpRxFlg = false;
        //HAL_UDS_Transmit_Pending_Response(Rec_Bufer[0],0x13);
        memset(TP_Buffer,0x0,255);
    }
}