hejie/1.5wuling_zhuanjietou
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
9227eedc69
1.5wuling_zhuanjietou/UDS/uds_services.c

1221 lines
45 KiB
C
Raw Normal View History

[五菱1.5代，同步奇瑞]
2024-10-17 01:06:51 +00:00
/*!
* @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;
//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>ҳ<EFBFBD><D2B3>2K<32><4B>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<32>η<EFBFBD>һ<EFBFBD><D2BB>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));//<2F><><EFBFBD><EFBFBD>ջ<EFBFBD><D5BB><EFBFBD><EFBFBD>ַ
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У<36><D0A3>
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)) {
// //<2F>ڱ<EFBFBD><DAB1>̻Ựģʽ<C4A3>£<EFBFBD><C2A3><EFBFBD>0x10 0x01<30><31><EFBFBD>ᵼ<EFBFBD><E1B5BC> ECU <20><><EFBFBD><EFBFBD>
// 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);
}
}
Reference in New Issue Copy Permalink