|
/***************************************************
|
* Include files
|
***************************************************/
|
#include <stddef.h>
|
#include <stdbool.h>
|
#include <string.h> /* For memcpy */
|
#include "cantp.h"
|
#include "cantp_user.h"
|
#include "xl_mcan.h"
|
#include "uds.h"
|
#include "did.h"
|
#include "fbl_ap.h"
|
#include "fbl_def.h"
|
#include "nvm.h"
|
#include "countdowntimer.h"
|
#ifdef ENABLE_BOOTLOADER
|
#endif
|
|
/***************************************************
|
* Local Defines
|
***************************************************/
|
typedef enum
|
{
|
SESSION_CONTROL = 0x10,
|
ECU_RESET = 0x11,
|
CLEAR_DIAGNOSTIC_INFORMATION = 0x14,
|
READ_DTC_INFORMATION = 0x19,
|
READ_DATA_BY_IDENTIFIER = 0x22,
|
SECURITY_ACCESS = 0x27,
|
COMMUNICATION_CONTROL = 0x28,
|
WRITE_DATA_BY_IDENTIFIER = 0x2E,
|
ROUTINE_CONTROL = 0x31,
|
TESTER_PRESENT = 0x3E,
|
CONTROL_DTC_SETTING = 0x85,
|
IN_OUT_CONTROL_BY_IDENTIFIER = 0x2F,
|
/*
|
READDATASTREAM = 0x2A,
|
READMEMORYBYADDRESS = 0x23,
|
WRITEMEMORYBYADDRESS = 0x3D,*/
|
REQUEST_DOWNLOAD = 0x34,
|
TRANSFER_DATA = 0x36,
|
REQUEST_TRANSFER_EXIT = 0x37,
|
|
} UDS_SID_e;
|
|
typedef enum READ_SID
|
{
|
READ_DATA_BY_ID = 0x22,
|
READ_DATA_BY_ADDRESS = 0x23,
|
MAX_READ_SID = 0
|
} READ_SID_e;
|
|
typedef enum UDS_SESSION
|
{
|
DEFAULT = 1,
|
PROGRAMMING = 2,
|
EXTENDED = 3,
|
} UDS_SESSIONS_e;
|
|
typedef enum UDS_RESP_PENDING
|
{
|
ERASE_RESP_PENDING = 0x01,
|
WRITE_RAM_RESP_PENDING = 0x02,
|
WRITE_FLASH_RESP_PENDING = 0x04,
|
CHECK_PROGRAMMING_INTERGRITY_PENDING = 0x08,
|
RESP_PENDING_MAX = 0x00
|
} UDS_RESP_PENDING_Te;
|
|
/* These define the index into */
|
enum UDS_RQ_FRAME_IDX
|
{
|
UDS_RQ_BYTE0,
|
UDS_RQ_BYTE1,
|
UDS_RQ_BYTE2,
|
UDS_RQ_BYTE3,
|
UDS_RQ_BYTE4,
|
UDS_RQ_BYTE5,
|
UDS_RQ_BYTE6,
|
UDS_RQ_BYTE7,
|
UDS_RQ_BYTE8,
|
UDS_RQ_BYTE9,
|
UDS_RQ_BYTE10,
|
UDS_RQ_BYTE11
|
};
|
|
typedef enum
|
{
|
NRC_GENERAL_REJECT = 0x10,
|
NRC_SERVICE_NOT_SUPPORTED = 0x11,
|
NRC_SUBFUNCTION_NOT_SUPPORTED = 0x12,
|
NRC_INVALID_MESSAGE_LENGTH_OR_FORMAT = 0x13,
|
NRC_CONDITIONS_NOT_CORRECT = 0x22,
|
NRC_REQUEST_SEQUENCE_ERROR = 0x24,
|
NRC_REQUEST_OUT_OF_RANGE = 0x31,
|
NRC_SECURITY_ACCESS_DENIED = 0x33,
|
NRC_INVALID_KEY = 0x35,
|
NRC_EXCEEDED_NUMBER_OF_ATTEMPTS = 0x36,
|
NRC_BUSY_REPEAT_REQUEST = 0x21,
|
NRC_REQUIRED_TIME_DELAY_NOT_EXPIRED = 0x37,
|
NRC_TRANSFER_DATA_SUSPENDED = 0x71,
|
NRC_GENERAL_PROGRAMMING_FAILURE = 0x72,
|
NRC_WRONG_BLOCK_SEQUENCE_COUNTER = 0x73,
|
NRC_SERVICE_BUSY = 0x78,
|
NRC_SERVICE_NOT_SUPPORTED_IN_ACTIVE_SESSION = 0x7F
|
} NEGA_RESP_Code_e;
|
|
typedef struct Read_DID_set
|
{
|
uint16_t DID_Value;
|
uint16_t DID_Table_Index;
|
|
} Read_DID_set_t;
|
|
#define REQUEST_LEVEL_ONE_SEED 0x01
|
#define SEND_LEVEL_ONE_KEY 0x02
|
#define REQUEST_LEVEL_TWO_SEED 0x09
|
#define SEND_LEVEL_TWO_KEY 0x0A
|
#define SECURITY_ACCESS_STEP_MAX 0xff
|
|
typedef enum SECURITY_ACCESS_STATE
|
{
|
SECURITY_ACCESS_LOCKED,
|
/* SECURITY_ACCESS_WAIT_KEY1, */
|
/* SECURITY_ACCESS_WAIT_KEY2, */
|
SECURITY_ACCESS_UNLOCK_LEVEL_1,
|
SECURITY_ACCESS_UNLOCK_LEVEL_2
|
} SECURITY_ACCESS_STATE_e;
|
|
typedef enum
|
{
|
TRANFER_IDLE,
|
TRANFER_START,
|
TRANFER_END
|
} UDS_TRANFER_DATA_STATE_Te;
|
|
typedef enum
|
{
|
PRGRAMMING_FAIL,
|
PRGRAMMING_OK,
|
PRGRAMMING_STATE_MAX
|
} FBL_PRGRAMMING_STATE_Te;
|
|
typedef struct Program_State
|
{
|
uint8_t ECU_SW_State;
|
uint8_t ECU_RAM_ROM_State;
|
} Program_State_t;
|
typedef struct Calibration_state
|
{
|
uint32_t cmd;
|
uint32_t calibrating_flag;
|
} Calibration_state_t;
|
|
#define RSP_DATA_LEN (6)
|
#define UDS_TASK_RATE (10)
|
|
#define CANTP_RX_BUFFER_SIZE (128)
|
#define FBL_RX_BUFFER_SIZE (256)
|
#define CANTP_TX_BUFFER_SIZE (128)
|
|
#define MAX_READ_DID_SET_SIZE (25)
|
#define SID_SIZE (1)
|
|
// ÕýÏìÓ¦ID
|
#define GET_RESPONSE_SERVICE_ID(SID) (0x40 + SID)
|
|
#define P2SERVER_TIMEROUT (50u)
|
#define P2SERVER_PENDING_TIMEROUT (5000u)
|
#define ENTRY_SLEEP_MODE_TIMEOU (30000 / UDS_TASK_RATE)
|
#define SECURITY_ACCESS_WAIT_TIME (10000 / UDS_TASK_RATE)
|
#define MAX_SECURITY_FAULT_CNT (3)
|
#define STOPALLDIDREQSIZE (2)
|
#define SIZE_OF_SID_DID (3)
|
|
#if 0
|
#define SEED_SIZE sizeof(uint32_t)
|
#define KEY_SIZE sizeof(uint32_t)
|
|
#define LEVEL1_SEED_MASK 0x521025A0
|
#define LEVEL1_KEY 0x6dfb5320u
|
|
#define LEVEL2_SEED_MASK 0x2035446A
|
#define LEVEL2_KEY 0x9e8e7b22u
|
#else /* дËÀµÄseed key */
|
// #define SEED_SIZE sizeof(uint16_t)
|
// #define KEY_SIZE sizeof(uint16_t)
|
|
// #define LEVEL1_SEED 0x0CA2u
|
// #define LEVEL1_KEY 0xB342u
|
|
// #define LEVEL2_SEED 0x0CA2u
|
// #define LEVEL2_KEY 0xB342u
|
|
#define SEED_SIZE sizeof(uint32_t)
|
#define KEY_SIZE sizeof(uint32_t)
|
|
#define LEVEL1_MASK 0x521025a0u
|
#define LEVEL2_MASK 0x2035446au
|
|
#define LEVEL1_SEED 0x11223344u
|
#define LEVEL1_KEY 0x20AA097Bu
|
|
#define LEVEL2_SEED 0x11223344u
|
#define LEVEL2_KEY 0x70237577u
|
|
#endif
|
|
#define REQUEST_DOWNLOAD_MSG_SIZE (0x0B)
|
#define DOWNLOAD_RAM ((uint8_t)0x10u)
|
#define DOWNLOAD_FLASH ((uint8_t)0x40u)
|
|
/*****************************************************************************/
|
/* Global Variable Declaration */
|
/*****************************************************************************/
|
static uint32_t eraseAddress; /* Actual transfer address */
|
static uint32_t eraseRemainder; /* Number of remaining transfer bytes */
|
static UDS_RESP_PENDING_Te UDS_L_ResponsePendingRequest_e;
|
static UDS_RESP_PENDING_Te UDS_L_ResponsePendingRelease_e;
|
|
static SECURITY_ACCESS_STATE_e UDS_O_SecurityAccessState_e = SECURITY_ACCESS_LOCKED;
|
static bool UDS_L_ProgrammingPreconditionCheckOK_b = true;
|
static UDS_CONTOL_TYPE_e UDS_L_CommunicationControlType_e = EnableRxAndTx;
|
|
static uint8_t UDS_L_SecurityFault_cnt;
|
static uint8_t UDS_L_SecurityStartDelay = 0;
|
static uint8_t UDS_L_SecurityAccessStep_e = SECURITY_ACCESS_STEP_MAX;
|
/*****************************************************************************/
|
/* Local Variables Definition */
|
/*****************************************************************************/
|
static uint8_t UDS_L_SupplyVoltage = 120u;
|
static uint16_t UDS_L_VehicleSpeed = 0u;
|
/* Timer value to keep the session in extended session */
|
static uint16_t TesterPresentTimer_u16;
|
|
/* Current diagnostic session */
|
static UDS_SESSIONS_e UDS_L_Diag_session_e;
|
/* Read data stream request received */
|
static uint16_t SecurityAcessTimer_u16;
|
static uint16_t UDS_NS_SessionTimeout_u16;
|
|
/* CANTP buffer */
|
static uint8_t UDS_L_rx_buffer[CANTP_RX_BUFFER_SIZE];
|
static uint8_t UDS_L_tx_buffer[CANTP_TX_BUFFER_SIZE];
|
|
/* Message buffer */
|
static uint8_t UDS_L_rx_msg_buffer[CANTP_RX_BUFFER_SIZE];
|
static uint16_t UDS_L_rx_msg_size;
|
static uint8_t UDS_L_tx_msg_buffer[CANTP_TX_BUFFER_SIZE];
|
static uint16_t UDS_L_tx_msg_size;
|
|
/* CANTP Stack */
|
static CANTP_Stack_t UDS_L_tp_stack;
|
|
/* static uint16_t UDS_L_ReadDidSetSize_u16 = 0U; */
|
static Read_DID_set_t UDS_L_ReadDIDSet_t;
|
|
/* Current processing request SID */
|
static uint8_t UDS_L_Current_SID __attribute__((__unused__));
|
static uint16_t ResponsePendingTimer_u16;
|
static bool UDS_L_TransferDataInProgressing_b = false;
|
static bool UDS_L_CRCCheckFail_b = false;
|
static uint32_t UDS_L_CRCReceived = 0;
|
static UDS_TRANFER_DATA_STATE_Te UDS_L_TransferDataState_e;
|
|
static uint8_t expectedSequenceCnt; /* Block sequence counter */
|
static uint8_t currentSequenceCnt; /* Current Block sequence counter */
|
static FBL_ADDR_TYPE transferAddress; /* Actual transfer address */
|
static FBL_MEMSIZE_TYPE transferRemainder; /* Number of remaining transfer bytes */
|
static uint8_t transferType; /* Download into RAM/Flash or upload */
|
static uint8_t currentbuffId; /* Download into RAM/Flash or upload */
|
static FBL_ADDR_TYPE eraseAddress; /* Actual transfer address */
|
static FBL_MEMSIZE_TYPE eraseRemainder; /* Number of remaining transfer bytes */
|
|
static FBL_ADDR_TYPE DownloadAddress; /* Actual transfer address */
|
static FBL_MEMSIZE_TYPE DownloadLength; /* Number of remaining transfer bytes */
|
|
/*****************************************************************************/
|
/* Local Function Prototypes */
|
/*****************************************************************************/
|
static void UDS_UpdateVehicleStatus(void);
|
/* Read data by DID */
|
static void UDS_ReadData(uint8_t *payload);
|
/* Write data by DID */
|
static void UDS_WriteDataByIdentifier(uint8_t *payload);
|
static void UDS_WriteF1DIDdata(uint8_t *p_src, uint16_t DID_TableIndex) __attribute__((__unused__));
|
/*0x11 service*/
|
static void UDS_ECURest(uint8_t *payload);
|
/*0x31 service*/
|
static void UDS_RoutineControl(uint8_t *payload);
|
/* Tester present(SID:3E) message handling */
|
static void UDS_TesterPresent(uint8_t *payload);
|
/* Diagnostic session control */
|
static void UDS_SessionControl(uint8_t *payload);
|
/* Extended session timer handling */
|
static void UDS_SessionTiming(void);
|
/*security Access fault timer*/
|
static void UDS_SecurityAccessTiming(void);
|
/*calibration respons wait calibration finsh command*/
|
static void UDS_CalibrationResp(void);
|
|
/* Dispatcher when a CAN message is received */
|
/* static void UDS_MsgDispatch(void); */
|
/* Compose and send negative response */
|
static void UDS_SendNegResp(NEGA_RESP_Code_e reason);
|
/* Flip endianness of memory locations based on the size */
|
static void UDS_FlipEndian(void *address, uint16_t size);
|
/* Compose and send out the requested DID data */
|
static void UDS_SendDidData(void);
|
/* Build DID data set */
|
static bool UDS_BuildDidSet(uint8_t *payload);
|
/* Switch to default session */
|
static void UDS_SwitchtoDefaultSession(uint8_t resetcmd);
|
/*Security access*/
|
|
static void UDS_ControlDTCSetting(uint8_t *payload);
|
static void UDS_CommunicationControl(uint8_t *payload);
|
static void UDS_ReadDTCInformation(uint8_t *payload);
|
static void UDS_ReportDTCNumByStatusMask(uint8_t *payload);
|
static void UDS_ReportDTCByStatusMask(uint8_t *payload);
|
static void UDS_ReportSupportedDTCs(uint8_t *payload);
|
static void UDS_ClearDTCInformation(uint8_t *payload);
|
static void UDS_IOControlByIdentifierg(uint8_t *payload);
|
#if 0
|
static void CANTP_zeroRestOfFrame(TP_PDU_t *msg);
|
#endif
|
static void UDS_RespTxMessage(void);
|
static void UDS_SecurityAccess(uint8_t *payload);
|
static void UDS_CheckProgrammingIntergrity(uint8_t *payload);
|
static void UDS_CheckProgrammingDependence(uint8_t *payload);
|
static void UDS_CheckProgrammingPrecondition(void);
|
static void UDS_EraseMemory(uint8_t *payload);
|
static void UDS_HardwareReset(void) __attribute__((__unused__));
|
static void UDS_SoftwareReset(void) __attribute__((__unused__));
|
static void UDS_RequestDownload(uint8_t *payload) __attribute__((__unused__));
|
static void UDS_TransferData(uint8_t *payload) __attribute__((__unused__));
|
static void UDS_RequestTransferExit(uint8_t *payload) __attribute__((__unused__));
|
static uint8_t UDS_SendF1DIDdata(uint8_t *Copy_position, uint16_t DID_idx);
|
static void UDS_StringCopy(char *p_src, char *p_dest, uint8_t max_size);
|
static void UDS_ResponseTiming(void);
|
|
/*
|
static void UDS_SetEraseResult(uint8_t mem_operation_type, uint8_t partition, int8_t success);
|
static void UDS_SetWriteResult(uint8_t mem_operation_type, uint8_t partition, int8_t success);
|
static void UDS_SetCRCCheckResult(uint8_t mem_peration_type, uint8_t partition, int8_t success);
|
*/
|
|
/************************ new add ************************/
|
#define SESSION_CONTROL_MIN_LEN (0x02u)
|
#define ECU_RESET_MIN_LEN (0x02u)
|
#define CLEAR_DIAGNOSTIC_INFORMATION_MIN_LEN (0x04u) /* 3 Bytes DTC */
|
#define READ_DTC_INFORMATION_MIN_LEN (0x02u)
|
#define READ_DATA_BY_IDENTIFIER_MIN_LEN (0x03u)
|
#define SECURITY_ACCESS_MIN_LEN (0x02u)
|
#define COMMUNICATION_CONTROL_MIN_LEN (0x03u)
|
#define WRITE_DATA_BY_IDENTIFIER_MIN_LEN (0x04u)
|
#define ROUTINE_CONTROL_MIN_LEN (0x04u)
|
#define TESTER_PRESENT_MIN_LEN (0x02u)
|
#define CONTROL_DTC_SETTING_MIN_LEN (0x02u)
|
#define REQUEST_DOWNLOAD_MIN_LEN (0xB)
|
#define TRANSFER_DATA_MIN_LEN (0XC)
|
#define REQUEST_TRANSFER_EXIT_MIN_LEN (0X01)
|
|
typedef struct
|
{
|
uint8_t uds_sid;
|
/* uint8_t uds_min_len; */
|
// void (*uds_service)(uint8_t msg_buf[]);
|
void (*uds_service)(uint8_t *payload);
|
bool std_spt; /* default session support */
|
bool ext_spt; /* extended session support */
|
bool fun_spt; /* function address support */
|
bool ssp_spt; /* subfunction suppress PosRsp bit support */
|
SECURITY_ACCESS_STATE_e uds_sa; /* security access */
|
} uds_service_t;
|
|
/* clang-format off */
|
static const uds_service_t uds_service_list[] = {
|
// service id function default extend fun_add ssp_spt SECURITY LEVEL
|
{SESSION_CONTROL, UDS_SessionControl, true, true, false, true, SECURITY_ACCESS_LOCKED},
|
{ECU_RESET, UDS_ECURest, false, true, false, true, SECURITY_ACCESS_LOCKED},
|
{READ_DATA_BY_IDENTIFIER, UDS_ReadData, true, true, false, false, SECURITY_ACCESS_LOCKED},
|
{SECURITY_ACCESS, UDS_SecurityAccess, false, true, false, false, SECURITY_ACCESS_LOCKED},
|
// {COMMUNICATION_CONTROL, UDS_CommunicationControl, false, true, true, true, SECURITY_ACCESS_LOCKED},
|
{WRITE_DATA_BY_IDENTIFIER, UDS_WriteDataByIdentifier, false, true, false, false, SECURITY_ACCESS_UNLOCK_LEVEL_1},
|
{ROUTINE_CONTROL, UDS_RoutineControl, false, true, false, false, SECURITY_ACCESS_UNLOCK_LEVEL_2},
|
{TESTER_PRESENT, UDS_TesterPresent, true, true, true, true, SECURITY_ACCESS_LOCKED},
|
// {CONTROL_DTC_SETTING, UDS_ControlDTCSetting, false, true, false, true, SECURITY_ACCESS_LOCKED},
|
{REQUEST_DOWNLOAD, UDS_RequestDownload, false, true, false, true, SECURITY_ACCESS_UNLOCK_LEVEL_2},
|
{TRANSFER_DATA, UDS_TransferData, false, true, false, true, SECURITY_ACCESS_UNLOCK_LEVEL_2},
|
{REQUEST_TRANSFER_EXIT, UDS_RequestTransferExit, false, true, false, true, SECURITY_ACCESS_UNLOCK_LEVEL_2},
|
|
};
|
/* clang-format on */
|
|
#define UDS_SERVICE_NUM (sizeof(uds_service_list) / sizeof(uds_service_list[0]))
|
|
typedef enum
|
{
|
/* net target address type ÍøÂçÄ¿µÄµØÖ·ÀàÐÍ */
|
N_TATYPE_NONE = 0,
|
N_TATYPE_PHYSICAL, /* ÎïÀíÑ°Ö· */
|
N_TATYPE_FUNCTIONAL /* ¹¦ÄÜÑ°Ö· */
|
} n_tatype_t;
|
|
#define REPORT_DTC_NUMBER_BY_STATUS_MASK (0x01)
|
#define REPORT_DTC_BY_STATUS_MASK (0x02)
|
#define REPORT_DTC_SNOPSHOT_BY_DTC_NUMBER (0x04)
|
#define REPORT_DTC_EXTENDED_DATA_RECORD_BY_DTC_NUMBER (0x06)
|
#define REPORT_SUPPORTED_DTC (0x0a)
|
|
#define UDS_REQUEST_SEED (0x01)
|
#define UDS_SEND_KEY (0x02)
|
|
/* »ñÈ¡ÒÖÖÆÕýÏìÓ¦±êʶλ =0²»ÒÖÖÆ =1ÒÖÖÆ */
|
#define UDS_GET_SUB_FUNCTION_SUPPRESS_POSRSP(byte) (((byte) >> 7u) & 0x01u)
|
/* »ñÈ¡×Ó¹¦ÄÜ */
|
#define UDS_GET_SUB_FUNCTION(byte) ((byte)&0x7fu)
|
|
/* Õý·´À¡ÒÖÖƱêʶλ =true ²»·¢ËÍÕýÏìÓ¦ =false ·¢ËÍÕýÏìÓ¦ */
|
static bool ssp_flg;
|
|
static bool uds_check_len(uint8_t msg_buf[], uint16_t msg_dlc)
|
{
|
bool result;
|
uint8_t subfunction;
|
uint8_t sid;
|
sid = msg_buf[0];
|
|
subfunction = UDS_GET_SUB_FUNCTION(msg_buf[1]);
|
|
switch (sid)
|
{
|
case SESSION_CONTROL:
|
{
|
if (msg_dlc == SESSION_CONTROL_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case ECU_RESET:
|
{
|
if (msg_dlc == ECU_RESET_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case CLEAR_DIAGNOSTIC_INFORMATION:
|
{
|
if (msg_dlc == CLEAR_DIAGNOSTIC_INFORMATION_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case READ_DTC_INFORMATION:
|
{
|
if ((subfunction == REPORT_DTC_NUMBER_BY_STATUS_MASK && msg_dlc != (READ_DTC_INFORMATION_MIN_LEN + 1)) ||
|
(subfunction == REPORT_DTC_BY_STATUS_MASK && msg_dlc != (READ_DTC_INFORMATION_MIN_LEN + 1)) ||
|
(subfunction == REPORT_SUPPORTED_DTC && msg_dlc != READ_DTC_INFORMATION_MIN_LEN))
|
{
|
result = false;
|
}
|
else
|
{
|
result = true;
|
}
|
}
|
break;
|
case READ_DATA_BY_IDENTIFIER:
|
{
|
if (msg_dlc == READ_DATA_BY_IDENTIFIER_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case SECURITY_ACCESS:
|
{
|
if ((subfunction == UDS_REQUEST_SEED && msg_dlc != SECURITY_ACCESS_MIN_LEN) ||
|
(subfunction == UDS_SEND_KEY && msg_dlc != (SECURITY_ACCESS_MIN_LEN + KEY_SIZE)))
|
{
|
result = false;
|
}
|
else
|
{
|
result = true;
|
}
|
}
|
break;
|
case COMMUNICATION_CONTROL:
|
{
|
if (msg_dlc == COMMUNICATION_CONTROL_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case WRITE_DATA_BY_IDENTIFIER:
|
{
|
if (msg_dlc >= WRITE_DATA_BY_IDENTIFIER_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case ROUTINE_CONTROL:
|
if (msg_dlc >= ROUTINE_CONTROL_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
break;
|
case TESTER_PRESENT:
|
{
|
if (msg_dlc == TESTER_PRESENT_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case CONTROL_DTC_SETTING:
|
{
|
if (msg_dlc == CONTROL_DTC_SETTING_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
}
|
break;
|
case REQUEST_DOWNLOAD:
|
if (msg_dlc == REQUEST_DOWNLOAD_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
break;
|
case TRANSFER_DATA:
|
if (msg_dlc >= TRANSFER_DATA_MIN_LEN)
|
{
|
result = true;
|
}
|
else
|
{
|
result = false;
|
}
|
break;
|
case REQUEST_TRANSFER_EXIT:
|
result = true;
|
|
break;
|
default:
|
result = false;
|
break;
|
}
|
return result;
|
}
|
|
static void uds_data_indication(uint8_t msg_buf[], uint16_t msg_dlc, uint8_t ta_type)
|
{
|
/* uint8_t *payload = UDS_L_rx_msg_buffer; */
|
/* On any request, reset the S3 timer if current session is extended */
|
/* session */
|
if ((UDS_L_Diag_session_e == EXTENDED) || (UDS_L_Diag_session_e == PROGRAMMING))
|
{
|
/* Reset the tester present waiting timer. If current session is */
|
/* extended session */
|
CDT_RESET(TesterPresentTimer_u16,
|
UDS_NS_SessionTimeout_u16 / UDS_TASK_RATE);
|
}
|
|
uint8_t i;
|
uint8_t sid;
|
uint8_t ssp;
|
bool find_sid;
|
bool session_spt;
|
|
sid = msg_buf[0];
|
UDS_L_Current_SID = sid;
|
ssp = UDS_GET_SUB_FUNCTION_SUPPRESS_POSRSP(msg_buf[1]);
|
find_sid = false;
|
for (i = 0; i < UDS_SERVICE_NUM; i++)
|
{
|
if (sid == uds_service_list[i].uds_sid)
|
{
|
/* UDS_L_Diag_session_e = EXTENDED; */
|
if (UDS_L_Diag_session_e == DEFAULT)
|
{
|
session_spt = uds_service_list[i].std_spt;
|
}
|
else
|
{
|
session_spt = uds_service_list[i].ext_spt;
|
}
|
|
if (session_spt == true)
|
{
|
if (ta_type == N_TATYPE_FUNCTIONAL && uds_service_list[i].fun_spt == false)
|
{ /* ¹¦ÄÜÑ°Ö·ÇҸ÷þÎñ²»Ö§³Ö¹¦ÄÜÑ°Ö· */
|
/* uds_no_response(); */
|
}
|
else
|
{
|
if (uds_check_len(msg_buf, msg_dlc))
|
{
|
if (UDS_O_SecurityAccessState_e >= uds_service_list[i].uds_sa)
|
{
|
if (uds_service_list[i].ssp_spt == true && ssp == 0x01)
|
{
|
ssp_flg = true;
|
}
|
else
|
{
|
ssp_flg = false;
|
}
|
uds_service_list[i].uds_service(msg_buf);
|
}
|
else
|
{
|
/* uds_negative_rsp(sid, NRC_SECURITY_ACCESS_DENIED); */
|
UDS_SendNegResp(NRC_SECURITY_ACCESS_DENIED);
|
}
|
}
|
else
|
{
|
/* uds_negative_rsp(sid, NRC_INVALID_MESSAGE_LENGTH_OR_FORMAT); */
|
UDS_SendNegResp(NRC_INVALID_MESSAGE_LENGTH_OR_FORMAT);
|
}
|
}
|
}
|
else
|
{
|
/* uds_negative_rsp(sid, NRC_SERVICE_NOT_SUPPORTED_IN_ACTIVE_SESSION); */
|
UDS_SendNegResp(NRC_SERVICE_NOT_SUPPORTED_IN_ACTIVE_SESSION);
|
}
|
find_sid = true;
|
break;
|
}
|
}
|
|
if (find_sid == false)
|
{
|
/* uds_negative_rsp(sid, NRC_SERVICE_NOT_SUPPORTED); */
|
UDS_SendNegResp(NRC_SERVICE_NOT_SUPPORTED);
|
}
|
}
|
|
/*********************** new add end ***********************/
|
|
/***************************************************
|
* Extern Function Definition Starts Here
|
***************************************************/
|
/* extern void UDS_GetCommunicationControlType(unsigned char *type);
|
extern void UDS_RxFunIdMessage(TP_PDU_t *msg); */
|
/*****************************************************************************/
|
/* NAME : extern void UDS_Init(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* Initialization function for FACT module */
|
/* INPUTS : */
|
/* None */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] Initialize the variables */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/16/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/* (2) Date: 08/16/2014 Fogbugz: case#: 1766 */
|
/* Add version registration by Tom Tao */
|
/*****************************************************************************/
|
extern void UDS_Init(void)
|
{
|
/* uint8_t i; */
|
/* Tester present timer */
|
CDT_RESET(SecurityAcessTimer_u16,
|
SECURITY_ACCESS_WAIT_TIME); // power on wait 10s
|
TesterPresentTimer_u16 = 0;
|
UDS_NS_SessionTimeout_u16 = 5000;
|
UDS_L_SecurityFault_cnt = 0;
|
UDS_L_SecurityStartDelay = 0;
|
UDS_L_Diag_session_e = DEFAULT;
|
UDS_O_SecurityAccessState_e = SECURITY_ACCESS_LOCKED;
|
UDS_L_Current_SID = 0;
|
UDS_L_ProgrammingPreconditionCheckOK_b = true;
|
UDS_L_TransferDataState_e = TRANFER_IDLE;
|
UDS_L_CRCCheckFail_b = false;
|
UDS_L_ResponsePendingRequest_e = RESP_PENDING_MAX;
|
UDS_L_ResponsePendingRelease_e = RESP_PENDING_MAX;
|
|
UDS_L_TransferDataInProgressing_b = false;
|
UDS_L_ReadDIDSet_t.DID_Table_Index = 0;
|
UDS_L_ReadDIDSet_t.DID_Value = 0;
|
|
/* Initialize CANTP stack with FACT CAN buffer */
|
CANTP_Init(&UDS_L_tp_stack,
|
UDS_L_rx_buffer,
|
CANTP_RX_BUFFER_SIZE,
|
UDS_L_tx_buffer,
|
CANTP_TX_BUFFER_SIZE);
|
|
CANTP_InitIds(&UDS_L_tp_stack,
|
0, /* CAN channel 0 */
|
UDS_PHY_REQ_RID, /* phy req id*/
|
UDS_RESP_TID, /* phy resp id*/
|
UDS_FUN_REQ_RID); /* fun req id*/
|
|
UDS_InitDIDMapRO(DID_NS_ActiveDiagSession, &UDS_L_Diag_session_e, 1);
|
}
|
|
/*****************************************************************************/
|
/* NAME : extern void UDS_Task_10ms(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* Factory diagnosis task called in every 10ms */
|
/* INPUTS : */
|
/* None */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] Call routine function in FACT module */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/16/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
extern void UDS_Task_10ms(void *p)
|
{
|
UDS_SessionTiming();
|
UDS_SecurityAccessTiming();
|
UDS_ResponseTiming();
|
}
|
|
static void UDS_RxTask_1ms(void)
|
{
|
static TP_PDU_t msg_rx_temp = {0};
|
CAN_PDU_t msg_can_temp = {0};
|
uint8_t msg_num = MCAN_GetReceiveMessageCounter(MCAN);
|
while (msg_num--)
|
{
|
MCAN_ReceiveData(MCAN, (MCAN_MsgTypeDef *)(&msg_can_temp));
|
|
msg_rx_temp.arbId = msg_can_temp.MCAN_ID;
|
msg_rx_temp.dlc = msg_can_temp.MCAN_DLC;
|
|
for (TP_uint8_t i = 0; i < msg_can_temp.MCAN_DLC; i++)
|
{
|
msg_rx_temp.frame[i] = msg_can_temp.MCAN_Data[i];
|
}
|
|
if (msg_rx_temp.arbId == UDS_PHY_REQ_RID)
|
{
|
UDS_RxMessage(&msg_rx_temp);
|
}
|
else
|
{
|
UDS_RxFunIdMessage(&msg_rx_temp);
|
}
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : extern void UDS_Task_1ms(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* Factory diagnosis task called in every 1ms */
|
/* INPUTS : */
|
/* None */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] Call routine function in FACT module */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/30/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
extern void UDS_Task_1ms(void *p)
|
{
|
/* Call tp task first to free up buffer */
|
CANTP_Task_1ms(&UDS_L_tp_stack);
|
UDS_RxTask_1ms();
|
|
/*
|
* This block of stuff controls whether the NVM is allowed to write data or
|
* not. This was added to allow the tester to shut off writes to dynamic
|
* NVM areas (in case during manufacturing there is a situation where
|
* DTCs are being constantly cleared / written for example). Stopping the
|
* writes will allow the current NVM writes to finish but further write
|
* attempts will be blocked. This has to happen from 1msec task for the
|
* following reasons:
|
* 1. If it is not in same timeslice as the request, there will be a window
|
* where the actual state does not match the data being returned to the
|
* tester. This could mean that the local RAM data indicates the NVM is
|
* not dirty, but if you're only updating the 'dirty' state every 20msec
|
* another app could have requested a write in previous 19 of the 20 msec,
|
* meaning we could return 'not busy' while a write was actually pending.
|
* 2. The factory DIDs don't wind up triggering callbacks, they are linked
|
* to data. It would be better if we worked like Vector and ran a callback
|
* instead of just returning data, so that we could (on receiving a particular
|
* DID) make the call into NVM directly and not through a timed task.
|
*/
|
}
|
|
/********************************************************* UDS_RxMessage() ************
|
* Each call is responsible for updating the rsp_data_size and rsp_data[] buffer if
|
* they do not want the standard ACK.
|
***************************************************************************************/
|
extern void UDS_RxMessage(TP_PDU_t *msg)
|
{
|
bool Msg_Recv_Comp_b;
|
uint8_t *Rcv_Buffer_Ptr = UDS_L_rx_msg_buffer;
|
|
/* Process the message with CANTP function */
|
CANTP_RxFrame(&UDS_L_tp_stack, msg);
|
|
/* Check if a message has been received completely */
|
Msg_Recv_Comp_b = CANTP_IsRxComplete(&UDS_L_tp_stack,
|
&Rcv_Buffer_Ptr, &UDS_L_rx_msg_size);
|
|
if (Msg_Recv_Comp_b != false)
|
{
|
/*cantp rx buff to UDS_L_rx_msg_buffer*/
|
memcpy(UDS_L_rx_msg_buffer, Rcv_Buffer_Ptr, UDS_L_rx_msg_size);
|
/* Call Message dispatcher */
|
/* UDS_MsgDispatch(); */
|
uds_data_indication(UDS_L_rx_msg_buffer, UDS_L_rx_msg_size, N_TATYPE_PHYSICAL);
|
}
|
}
|
extern void UDS_RxFunIdMessage(TP_PDU_t *msg)
|
{
|
uint8_t *Rcv_Buffer_Ptr = msg->frame;
|
/*as Single Frame*/
|
if ((msg->frame[1] == TESTER_PRESENT)) // only support 3E
|
{
|
UDS_L_rx_msg_size = (Rcv_Buffer_Ptr[0] & 0x0f);
|
/*cantp rx buff to UDS_L_rx_msg_buffer*/
|
memcpy(UDS_L_rx_msg_buffer, &Rcv_Buffer_Ptr[1], UDS_L_rx_msg_size);
|
/* Call Message dispatcher */
|
/* UDS_MsgDispatch(); */
|
uds_data_indication(UDS_L_rx_msg_buffer, UDS_L_rx_msg_size, N_TATYPE_FUNCTIONAL);
|
}
|
}
|
|
#if 1 /* ²ð·Ö */
|
/**
|
* @brief
|
*
|
* @param DIDitem
|
* @param nvBlockID
|
* @param address
|
* @param size
|
*/
|
extern void UDS_InitDIDMapRW(UDS_DIDList_e DIDitem, uint16_t nvBlockID, void *address, uint16_t size)
|
{
|
uint16_t i;
|
|
/* Make sure DID table still has space. If current DID table
|
* size is already larger than specified, do not update DID table */
|
if (DIDTable_Entry_Count_u16 >= UDS_DID_TABLE_SIZE)
|
{
|
return;
|
}
|
|
/* Look for existing table item with the same DID */
|
for (i = 0; i < DIDTable_Entry_Count_u16; i++)
|
{
|
if (DIDtable[i].DidEnum == DIDitem)
|
{
|
return;
|
}
|
}
|
|
/* If there is no such DID, add the new DID into the table */
|
if ((i == DIDTable_Entry_Count_u16) &&
|
(DIDTable_Entry_Count_u16 < UDS_DID_TABLE_SIZE))
|
{
|
|
/* Assign enumeration, address, size to the table */
|
DIDtable[DIDTable_Entry_Count_u16].DidEnum = DIDitem;
|
DIDtable[DIDTable_Entry_Count_u16].nvBlockID = nvBlockID;
|
DIDtable[DIDTable_Entry_Count_u16].address = address;
|
DIDtable[DIDTable_Entry_Count_u16].size = size;
|
DIDtable[DIDTable_Entry_Count_u16].access = READWRITE;
|
|
/* Calculate CRC */
|
/* DIDtable[DIDTable_Entry_Count_u16].crc = CRC16_Calc(&address, size); */
|
DIDTable_Entry_Count_u16++;
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : extern void UDS_InitDIDMap(UDS_DIDList_e DIDitem, */
|
/* const void *address, uint16_t size) */
|
/* */
|
/* DESCRIPTION : */
|
/* Function to be called by individual tasks to establish connection*/
|
/* between the variables to read and the enumeration */
|
/* INPUTS : */
|
/* enum DidEnum : enumeration value of DID items */
|
/* uint16_t address: DID item address */
|
/* uint16_t size : DID item size */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] Add DID table items */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 08/13/2014 Fogbugz: case#: 1791 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
extern void UDS_InitDIDMapRO(UDS_DIDList_e DIDitem, const void *address,
|
uint16_t size)
|
{
|
uint16_t i;
|
|
/* Make sure DID table still has space. If current DID table
|
* size is already larger than specified, do not update DID table */
|
if (DIDTable_Entry_Count_u16 >= UDS_DID_TABLE_SIZE)
|
{
|
return;
|
}
|
|
/* Look for existing table item with the same DID */
|
for (i = 0; i < DIDTable_Entry_Count_u16; i++)
|
{
|
if (DIDtable[i].DidEnum == DIDitem)
|
{
|
return;
|
}
|
}
|
|
/* If there is no such DID, add the new DID into the table */
|
if ((i == DIDTable_Entry_Count_u16) &&
|
(DIDTable_Entry_Count_u16 < UDS_DID_TABLE_SIZE))
|
{
|
|
/* Assign enumeration, address, size to the table */
|
DIDtable[DIDTable_Entry_Count_u16].DidEnum = DIDitem;
|
DIDtable[DIDTable_Entry_Count_u16].nvBlockID = 0xFF;
|
DIDtable[DIDTable_Entry_Count_u16].address = (void *)address;
|
DIDtable[DIDTable_Entry_Count_u16].size = size;
|
DIDtable[DIDTable_Entry_Count_u16].access = READONLY;
|
|
/* Calculate CRC */
|
/* DIDtable[DIDTable_Entry_Count_u16].crc = CRC16_Calc((void *)&address, size); */
|
DIDTable_Entry_Count_u16++;
|
}
|
}
|
#endif
|
|
extern void UDS_SwitchtoProgrammingSession(void)
|
{
|
UDS_L_Diag_session_e = PROGRAMMING;
|
CDT_RESET(TesterPresentTimer_u16,
|
UDS_NS_SessionTimeout_u16 / UDS_TASK_RATE);
|
}
|
|
extern void UDS_ResponseEntryProgrammingSession(void)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(SESSION_CONTROL);
|
UDS_L_tx_msg_buffer[1] = UDS_L_Diag_session_e;
|
UDS_L_tx_msg_buffer[2] = 0x00;
|
UDS_L_tx_msg_buffer[3] = 0x01;
|
UDS_L_tx_msg_buffer[4] = 0;
|
UDS_L_tx_msg_buffer[5] = 0;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x06;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
/*****************************************************************************/
|
/* Local Function definitions */
|
/*****************************************************************************/
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_SessionTiming(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* Decrease the session timer if it's not expired, if the timer */
|
/* expires, set the session back to default session */
|
/* INPUTS : */
|
/* None */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] Add DID table items */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/16/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SessionTiming(void)
|
{
|
/* Decrease tester present waiting timer, if timer expired, set Factory
|
* diag session to default session */
|
if (UDS_L_Diag_session_e != DEFAULT)
|
{
|
/* CDT_RESET(EntrySleepModeTimer_u16,ENTRY_SLEEP_MODE_TIMEOU); */
|
if (CDT_HASEXPIRED(TesterPresentTimer_u16) == false)
|
{
|
|
CDT_EXPIRED(TesterPresentTimer_u16);
|
|
if (CDT_HASEXPIRED(TesterPresentTimer_u16) != false)
|
{
|
UDS_SwitchtoDefaultSession(false);
|
}
|
}
|
else
|
{
|
UDS_SwitchtoDefaultSession(false);
|
}
|
}
|
else
|
{
|
CDT_RESET(TesterPresentTimer_u16, 0);
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_SecurityAccessTiming(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* Decrease the security Access timer if it's not expired, if the timer */
|
/* expires, set the UDS_SecurityFault_cnt-- */
|
/* INPUTS : */
|
/* None */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 08/10/2017 Fogbugz: case#: */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SecurityAccessTiming(void)
|
{
|
if ((UDS_L_SecurityFault_cnt != 0) || (UDS_L_SecurityStartDelay == 1))
|
{
|
if (CDT_EXPIRED(SecurityAcessTimer_u16) == true)
|
{
|
UDS_L_SecurityFault_cnt--;
|
UDS_L_SecurityStartDelay = 0;
|
}
|
else
|
{
|
}
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_ReadData(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function reads the data by enumeration value and place the */
|
/* result in the transmit buffer to send out response */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Read data by identifier */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/16/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_ReadData(uint8_t *payload)
|
{
|
bool DIDnotFound = false;
|
|
/* Build up the DID set while set the flag for DID found */
|
DIDnotFound = UDS_BuildDidSet(payload);
|
|
/* DIDnotFound == false means all requested DID have been found in */
|
/* DID table, thus their indexes have been stored in */
|
/* UDS_L_ReadDIDSet_t[x].DID_Table_Index */
|
if (DIDnotFound == false)
|
{
|
|
/* Compose a tx message to send out all requested DID data */
|
UDS_SendDidData();
|
}
|
else
|
{
|
/* A requested DID item cannot be found in the DID table. */
|
/* All current data should be abandoned */
|
memset(UDS_L_tx_msg_buffer, 0, CANTP_TX_BUFFER_SIZE);
|
/* Send a negative response */
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_WriteDataByIdentifier(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function writes the data passed by user to the data item */
|
/* specified by DID value */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Write data by identifier */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/16/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_WriteDataByIdentifier(uint8_t *payload)
|
{
|
uint16_t i;
|
uint16_t DID_u16;
|
uint16_t Index_to_be_written;
|
|
if ((UDS_L_Diag_session_e == DEFAULT) || ((UDS_O_SecurityAccessState_e != SECURITY_ACCESS_UNLOCK_LEVEL_1) && (UDS_O_SecurityAccessState_e != SECURITY_ACCESS_UNLOCK_LEVEL_2)))
|
{
|
/* Send a negative response.*/
|
UDS_SendNegResp(NRC_SECURITY_ACCESS_DENIED);
|
return;
|
}
|
/* 2nd and 3rd byte specifies the DID */
|
DID_u16 = payload[1] << 8 | payload[2];
|
|
for (i = 0; i < DIDTable_Entry_Count_u16; i++)
|
{
|
if (DIDtable[i].DidEnum == DID_u16)
|
{
|
/* Record index i */
|
Index_to_be_written = i;
|
break; /* DID data found, stop the search */
|
}
|
else
|
{
|
/* Otherwise, keep on looking */
|
}
|
}
|
|
/* i == DIDTable_Entry_Count_u16 means no data with the DID is found */
|
if (i == DIDTable_Entry_Count_u16)
|
{
|
/* Send out negative response */
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
}
|
else if (DIDtable[Index_to_be_written].access == READONLY)
|
{
|
|
/* Send out negative response */
|
UDS_SendNegResp(NRC_CONDITIONS_NOT_CORRECT);
|
}
|
else
|
{
|
|
/* Check the total received message size should be equal to */
|
/* SID+DID+DataSize */
|
if (UDS_L_rx_msg_size != (DIDtable[Index_to_be_written].size + SIZE_OF_SID_DID))
|
{
|
/* Send out negative response */
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
}
|
else
|
{
|
/* UDS_WriteF1DIDdata(&payload[3], Index_to_be_written); */
|
memcpy(DIDtable[Index_to_be_written].address, &payload[3],
|
DIDtable[Index_to_be_written].size);
|
|
/* Write the change to NVM */
|
if (DIDtable[Index_to_be_written].nvBlockID != 0xFF)
|
{
|
DID_SetWriteSaveFlag();
|
}
|
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(WRITE_DATA_BY_IDENTIFIER);
|
UDS_L_tx_msg_buffer[1] = payload[1];
|
UDS_L_tx_msg_buffer[2] = payload[2];
|
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 3;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
}
|
}
|
|
static uint8_t UDS_SendF1DIDdata(uint8_t *Copy_position, uint16_t DID_idx)
|
{
|
#if 1
|
uint8_t rtn_length = 0;
|
char *ptr_src = NULL;
|
uint16_t F1DID = 0;
|
uint8_t length = 0;
|
F1DID = (uint16_t)(DIDtable[DID_idx].DidEnum & 0x0000FFFFu);
|
ptr_src = DIDtable[DID_idx].address;
|
length = DIDtable[DID_idx].size;
|
|
UDS_FlipEndian(&(F1DID), sizeof(F1DID));
|
/* Copy requested DID into transmission buffer */
|
memcpy(Copy_position, &(F1DID), sizeof(F1DID));
|
Copy_position = Copy_position + sizeof(F1DID);
|
rtn_length += 2;
|
|
switch (((uint16_t)(DIDtable[DID_idx].DidEnum & 0x0000FFFFu)))
|
{
|
// case DID_UDS_NS_VINDataIdentifier: /*0xF190*/
|
// case DID_UDS_NS_DUNSIdentification:
|
// case DID_UDS_NS_MTC:
|
// case DID_UDS_NS_ManufacturersModeFlag:
|
// case DID_UDS_NS_ECUPartNumber:
|
// case DID_UDS_NS_SupplierECUSoftwareVersionNumber:
|
// UDS_StringCopy(ptr_src, (char *)Copy_position, length);
|
// break;
|
// case DID_UDS_NS_BaseModelPartNumber:
|
// case DID_UDS_NS_EndModelPartNumber:
|
// memcpy(Copy_position, ptr_src, 4);
|
// UDS_FlipEndian(Copy_position, 4);
|
// break;
|
// case DID_UDS_NS_BaseModelPartNumberVersionCode:
|
// case DID_UDS_NS_EndModelPartNumberVersionCode:
|
// memcpy(Copy_position, ptr_src, 2);
|
// UDS_FlipEndian(Copy_position, 2);
|
// break;
|
// case DID_UDS_NS_RepairShopCode:
|
// memcpy(Copy_position, ptr_src, 8);
|
// break;
|
// case DID_UDS_NS_ProgrammingDate:
|
// memcpy(Copy_position, ptr_src, 4);
|
break;
|
default:
|
break;
|
}
|
rtn_length += length;
|
#endif
|
return 0;
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_SendDidData(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function composes the payload of requested DID data and */
|
/* pass the payload for CANTP to send */
|
/* INPUTS : */
|
/* void */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Compose and send payload */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/18/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SendDidData(void)
|
{
|
uint16_t i = 0;
|
uint16_t SendDataSize = 1; /* Reserve for the Response ID */
|
uint8_t *Copy_position; /* Specifies the starting address of copying */
|
/* Use a word to store the least significant 2 bytes of enum value */
|
uint16_t TwoByteDID = 0;
|
|
/* Initialize the starting position of the copy, reserve the SID size */
|
Copy_position = UDS_L_tx_msg_buffer + SID_SIZE;
|
|
/* Have a simple variable to store the intended index */
|
i = UDS_L_ReadDIDSet_t.DID_Table_Index;
|
|
/* Parse out only the least significant 2 bytes */
|
TwoByteDID = (uint16_t)(DIDtable[i].DidEnum & 0x0000FFFFu);
|
if ((TwoByteDID & 0xff00u) == 0xf100u)
|
{
|
UDS_SendF1DIDdata(Copy_position, i);
|
SendDataSize = SendDataSize + sizeof(TwoByteDID);
|
}
|
else
|
{
|
/* Flip the two byte DID */
|
UDS_FlipEndian(&(TwoByteDID), sizeof(TwoByteDID));
|
|
/* Copy requested DID into transmission buffer */
|
memcpy(Copy_position, &(TwoByteDID), sizeof(TwoByteDID));
|
|
/* Update the copying position */
|
Copy_position = Copy_position + sizeof(TwoByteDID);
|
SendDataSize = SendDataSize + sizeof(TwoByteDID);
|
|
/* First copy the DID data into tx buffer */
|
memcpy(Copy_position, DIDtable[i].address, DIDtable[i].size);
|
|
/* Flip endianness of the data to be sent IN THE TX BUFFER */
|
/* NOTE that we should not flip at DIDtable[i].address because */
|
/* it will crash the original data stored there */
|
UDS_FlipEndian(Copy_position, DIDtable[i].size);
|
|
Copy_position = Copy_position + DIDtable[i].size;
|
}
|
|
SendDataSize = SendDataSize + DIDtable[i].size;
|
|
/* Specify read data by DID response ID */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(READ_DATA_BY_IDENTIFIER);
|
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = SendDataSize;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
|
static void UDS_RespTxMessage(void)
|
{
|
if (ssp_flg == true) /* ÒÖÖÆÕýÏìÓ¦, ²»·¢ËÍÕýÏìÓ¦ */
|
return;
|
|
if (!CANTP_TxMessage(&UDS_L_tp_stack, UDS_L_tx_msg_buffer,
|
UDS_L_tx_msg_size))
|
{
|
UDS_SendNegResp(NRC_BUSY_REPEAT_REQUEST);
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_TesterPresent(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function resets the tester present timer */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Read data stream by identifier */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/18/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_TesterPresent(uint8_t *payload)
|
{
|
|
/* Reset the tester present waiting timer. If current session is */
|
/* extended session */
|
CDT_RESET(TesterPresentTimer_u16,
|
UDS_NS_SessionTimeout_u16 / UDS_TASK_RATE);
|
|
uint8_t sub_func = UDS_GET_SUB_FUNCTION(payload[UDS_RQ_BYTE1]);
|
switch (sub_func)
|
{
|
case 0x00:
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(TESTER_PRESENT);
|
UDS_L_tx_msg_buffer[1] = 0x00;
|
UDS_L_tx_msg_size = 2;
|
UDS_RespTxMessage();
|
break;
|
default:
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED);
|
break;
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_SessionControl(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* Factory diagnosis session control */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Change session based on the third byte value of CAN msg */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 06/18/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SessionControl(uint8_t *payload)
|
{
|
uint16_t cnt = 5000u;
|
/* Change session based on CAN message request */
|
bool UDS_SessionSetOk_b = false;
|
uint8_t sub_func = UDS_GET_SUB_FUNCTION(payload[UDS_RQ_BYTE1]);
|
switch (sub_func)
|
{
|
case EXTENDED:
|
|
if ((UDS_L_Diag_session_e == DEFAULT) || (UDS_L_Diag_session_e == EXTENDED))
|
{
|
UDS_L_Diag_session_e = EXTENDED;
|
/* Reset the tester present waiting timer. */
|
CDT_RESET(TesterPresentTimer_u16,
|
UDS_NS_SessionTimeout_u16 / UDS_TASK_RATE);
|
UDS_SessionSetOk_b = true;
|
}
|
else
|
{
|
UDS_SendNegResp(NRC_CONDITIONS_NOT_CORRECT);
|
}
|
|
break;
|
case PROGRAMMING:
|
/* UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED); */
|
if (((UDS_L_Diag_session_e == EXTENDED) || (UDS_L_Diag_session_e == PROGRAMMING)) && (UDS_L_ProgrammingPreconditionCheckOK_b == true))
|
{
|
/**/
|
UDS_L_Diag_session_e = PROGRAMMING;
|
UDS_SessionSetOk_b = true;
|
FblSetFblProgramRequestFlag();
|
}
|
else if ((UDS_L_Diag_session_e == DEFAULT) || (UDS_L_ProgrammingPreconditionCheckOK_b == false)) /*DEFAULT session can not trans to PROGRAMMING*/
|
{
|
UDS_SendNegResp(NRC_CONDITIONS_NOT_CORRECT);
|
}
|
else
|
{
|
}
|
break;
|
case DEFAULT:
|
if (UDS_L_Diag_session_e == PROGRAMMING)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(SESSION_CONTROL);
|
UDS_L_tx_msg_buffer[1] = UDS_L_Diag_session_e;
|
UDS_L_tx_msg_buffer[2] = 0;
|
UDS_L_tx_msg_buffer[3] = 0;
|
UDS_L_tx_msg_buffer[4] = 0;
|
UDS_L_tx_msg_buffer[5] = 0;
|
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x06;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
while (cnt--)
|
{
|
; /// wait send command send out and then reset
|
}
|
|
UDS_SwitchtoDefaultSession(true);
|
while (1)
|
;
|
}
|
else
|
{
|
UDS_SwitchtoDefaultSession(false);
|
}
|
|
TesterPresentTimer_u16 = 0;
|
break;
|
default:
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED);
|
break;
|
}
|
if (UDS_SessionSetOk_b == true)
|
{
|
/* Compose the response payload */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(SESSION_CONTROL);
|
UDS_L_tx_msg_buffer[1] = UDS_L_Diag_session_e;
|
UDS_L_tx_msg_buffer[2] = 0;
|
UDS_L_tx_msg_buffer[3] = 0;
|
UDS_L_tx_msg_buffer[4] = 0;
|
UDS_L_tx_msg_buffer[5] = 0;
|
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x06;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : UDS_SecurityAccess(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* Security Access */
|
/* INPUTS : */
|
/* void */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 08/03/2017 Fogbugz: case#: */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SecurityAccess(uint8_t *payload)
|
{
|
if (UDS_L_Diag_session_e == DEFAULT)
|
{
|
/* Send a negative response.*/
|
UDS_SendNegResp(NRC_SECURITY_ACCESS_DENIED);
|
return;
|
}
|
if ((UDS_L_SecurityFault_cnt == 3) || (UDS_L_SecurityStartDelay == 1))
|
{
|
UDS_SendNegResp(NRC_REQUIRED_TIME_DELAY_NOT_EXPIRED);
|
return;
|
}
|
uint32_t ReceiveKey = 0;
|
uint8_t sub_func = UDS_GET_SUB_FUNCTION(payload[UDS_RQ_BYTE1]);
|
switch (sub_func)
|
{
|
case REQUEST_LEVEL_ONE_SEED:
|
case SEND_LEVEL_ONE_KEY:
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED); // only support LEVEL 2
|
return;
|
break;
|
case REQUEST_LEVEL_TWO_SEED:
|
UDS_L_SecurityAccessStep_e = REQUEST_LEVEL_TWO_SEED;
|
|
/* Compose the response payload */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(SECURITY_ACCESS);
|
UDS_L_tx_msg_buffer[1] = UDS_L_SecurityAccessStep_e;
|
#if 0
|
UDS_L_tx_msg_buffer[2] = (uint8_t)(LEVEL2_SEED >> 8);
|
UDS_L_tx_msg_buffer[3] = (uint8_t)(LEVEL2_SEED);
|
#endif
|
for (int i = 0; i < SEED_SIZE; i++)
|
{
|
UDS_L_tx_msg_buffer[2 + i] = (uint8_t)(LEVEL2_SEED >> ((SEED_SIZE - i - 1) * 8));
|
}
|
/* Specify the send payload size */
|
/* UDS_L_tx_msg_size = 0x04; */
|
UDS_L_tx_msg_size = 2 + SEED_SIZE;
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
break;
|
case SEND_LEVEL_TWO_KEY:
|
if (UDS_L_SecurityAccessStep_e != REQUEST_LEVEL_TWO_SEED)
|
{
|
UDS_SendNegResp(NRC_REQUEST_SEQUENCE_ERROR);
|
return;
|
}
|
/* ReceiveKey = payload[UDS_RQ_BYTE2]; */
|
/* ReceiveKey = (ReceiveKey << 8) | payload[UDS_RQ_BYTE3]; */
|
for (int i = 0; i < KEY_SIZE; i++)
|
{
|
ReceiveKey = ReceiveKey << 8 | payload[2 + i];
|
}
|
if (ReceiveKey == LEVEL2_KEY)
|
{
|
/*right key*/
|
UDS_L_SecurityFault_cnt = 0;
|
UDS_O_SecurityAccessState_e = SECURITY_ACCESS_UNLOCK_LEVEL_2;
|
UDS_L_SecurityAccessStep_e = SECURITY_ACCESS_STEP_MAX;
|
/* Compose the response payload */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(SECURITY_ACCESS);
|
UDS_L_tx_msg_buffer[1] = SEND_LEVEL_TWO_KEY;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
else
|
{
|
UDS_SendNegResp(NRC_INVALID_KEY);
|
if (++UDS_L_SecurityFault_cnt >= MAX_SECURITY_FAULT_CNT)
|
{
|
UDS_L_SecurityFault_cnt = MAX_SECURITY_FAULT_CNT;
|
CDT_RESET(SecurityAcessTimer_u16,
|
SECURITY_ACCESS_WAIT_TIME);
|
UDS_SendNegResp(NRC_EXCEEDED_NUMBER_OF_ATTEMPTS);
|
}
|
}
|
break;
|
default:
|
break;
|
}
|
}
|
|
static void UDS_Reset(uint8_t ResetType)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ECU_RESET);
|
UDS_L_tx_msg_buffer[1] = ResetType;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
// UDS_RespTxMessage();
|
|
if (ssp_flg == false) // ûÓÐÕýÏìÓ¦ÒÖÖÆ
|
{
|
TP_PDU_t msg;
|
msg.arbId = UDS_RESP_TID;
|
msg.extended = false;
|
msg.RTR = false;
|
msg.dlc = 8;
|
msg.frame[0] = 0x03;
|
msg.frame[1] = GET_RESPONSE_SERVICE_ID(ECU_RESET);
|
msg.frame[2] = ResetType;
|
|
for (int i = 0; i < 200; i++) // È·±£·¢³öÏìÓ¦
|
{
|
UDS_WriteData(&msg, 0);
|
}
|
}
|
|
CPU_HardReset();
|
}
|
|
static void UDS_HardwareReset(void)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ECU_RESET);
|
UDS_L_tx_msg_buffer[1] = 0x01;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
CPU_HardReset();
|
}
|
static void UDS_SoftwareReset(void)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ECU_RESET);
|
UDS_L_tx_msg_buffer[1] = 0x02;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
CPU_HardReset();
|
}
|
|
static void UDS_ECURest(uint8_t *payload)
|
{
|
uint8_t sub_func = UDS_GET_SUB_FUNCTION(payload[UDS_RQ_BYTE1]);
|
uint8_t reset_type = payload[UDS_RQ_BYTE1];
|
switch (sub_func)
|
{
|
case 0x01: // Hard Reset
|
UDS_Reset(reset_type);
|
break;
|
case 0x02: // Key On Off Reset
|
// UDS_Reset(reset_type);
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED);
|
break;
|
case 0x03: // Soft Reset
|
UDS_Reset(reset_type);
|
break;
|
case 0x04: // Enable Rapid Power Shutdown
|
UDS_Reset(reset_type);
|
break;
|
default:
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED);
|
break;
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_RoutineControl(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* Factory routine control */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 09/09/06 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_RoutineControl(uint8_t *payload)
|
{
|
uint16_t RoutineID = 0;
|
if ((UDS_L_Diag_session_e == DEFAULT) || ((UDS_O_SecurityAccessState_e != SECURITY_ACCESS_UNLOCK_LEVEL_1) && (UDS_O_SecurityAccessState_e != SECURITY_ACCESS_UNLOCK_LEVEL_2)))
|
{
|
/* Send a negative response.*/
|
UDS_SendNegResp(NRC_SECURITY_ACCESS_DENIED);
|
return;
|
}
|
RoutineID = (uint16_t)payload[UDS_RQ_BYTE2] << 8 | (uint16_t)payload[UDS_RQ_BYTE3];
|
|
switch (RoutineID)
|
{
|
case 0xf001:
|
UDS_CheckProgrammingIntergrity(payload);
|
|
break;
|
case 0xff02:
|
UDS_CheckProgrammingPrecondition();
|
break;
|
case 0xff00:
|
UDS_EraseMemory(payload);
|
break;
|
case 0xff01:
|
UDS_CheckProgrammingDependence(payload);
|
/* UDS_SendNegResp(NRC_REQUEST_SEQUENCE_ERROR); */
|
break;
|
default:
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
break;
|
}
|
}
|
|
static void UDS_ResponseTiming(void)
|
{
|
if (RESP_PENDING_MAX != UDS_L_ResponsePendingRequest_e)
|
{
|
if (CDT_EXPIRED(ResponsePendingTimer_u16) == true)
|
{
|
/**/
|
CDT_RESET(ResponsePendingTimer_u16, P2SERVER_PENDING_TIMEROUT);
|
UDS_SendNegResp(NRC_TRANSFER_DATA_SUSPENDED);
|
}
|
else
|
{
|
if ((UDS_L_ResponsePendingRequest_e & CHECK_PROGRAMMING_INTERGRITY_PENDING) != 0)
|
{
|
if (transferType == DOWNLOAD_FLASH)
|
{
|
UDS_L_CRCCheckFail_b = !MEM_PartitionCRCOK((uint8_t)MEM_PARTITION_CODEFLASH, UDS_L_CRCReceived);
|
if (UDS_L_CRCCheckFail_b == false)
|
{
|
NVM_ReInitFlashDriveRam(); // CLEAR FLASH DRIVE IN RAM
|
}
|
}
|
else
|
{
|
UDS_L_CRCCheckFail_b = !MEM_PartitionCRCOK((uint8_t)MEM_PARTITION_RAM, UDS_L_CRCReceived);
|
if (UDS_L_CRCCheckFail_b == true)
|
{
|
NVM_ReInitFlashDriveRam(); // CLEAR FLASH DRIVE IN RAM
|
}
|
}
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ROUTINE_CONTROL);
|
UDS_L_tx_msg_buffer[1] = 0x01;
|
UDS_L_tx_msg_buffer[2] = 0xf0;
|
UDS_L_tx_msg_buffer[3] = 0x01;
|
UDS_L_tx_msg_buffer[4] = (uint8_t)UDS_L_CRCCheckFail_b;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x05;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
|
UDS_L_ResponsePendingRequest_e &= (~CHECK_PROGRAMMING_INTERGRITY_PENDING);
|
UDS_L_ResponsePendingRelease_e &= (~CHECK_PROGRAMMING_INTERGRITY_PENDING);
|
}
|
}
|
}
|
else
|
{
|
CDT_RESET(ResponsePendingTimer_u16, P2SERVER_PENDING_TIMEROUT);
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_CommunicationControl(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* Factory communication control */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Change communication based on the third byte value of CAN msg */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 07/31/2017 Fogbugz: case#: */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_CommunicationControl(uint8_t *payload)
|
{
|
|
if (UDS_L_Diag_session_e != EXTENDED)
|
{
|
/* Send a negative response.*/
|
UDS_SendNegResp(NRC_SECURITY_ACCESS_DENIED);
|
return;
|
}
|
|
uint8_t ControlType = UDS_GET_SUB_FUNCTION(payload[UDS_RQ_BYTE1]);
|
uint8_t CommunicationType = payload[UDS_RQ_BYTE2];
|
if ((ControlType != (uint8_t)EnableRxAndTx) ||
|
(CommunicationType != NormalCommunicationMessage) && (CommunicationType != NetManageCommMessage) && (CommunicationType != BothCommunicationMessage))
|
{
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED);
|
return;
|
}
|
|
if (payload[UDS_RQ_BYTE2] == NetManageCommMessage)
|
{
|
UDS_SendNegResp(NRC_SUBFUNCTION_NOT_SUPPORTED);
|
return;
|
}
|
|
/* Change communnication type based on CAN message request */
|
UDS_L_CommunicationControlType_e = (UDS_CONTOL_TYPE_e)ControlType;
|
|
/* Compose the response payload */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(COMMUNICATION_CONTROL);
|
UDS_L_tx_msg_buffer[1] = UDS_L_CommunicationControlType_e;
|
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
extern void UDS_GetCommunicationControlType(unsigned char *type)
|
{
|
*type = (unsigned char)(UDS_L_CommunicationControlType_e & 0x3);
|
}
|
|
static void UDS_EraseMemory(uint8_t *payload)
|
{
|
uint8_t lengthFormat = 0;
|
uint8_t addrFormat = 0;
|
uint8_t i = 0;
|
int8_t erase_state = OP_STATUS_FAIL;
|
lengthFormat = (uint8_t)((payload[UDS_RQ_BYTE4] & 0xf0) >> 4);
|
addrFormat = (uint8_t)(payload[UDS_RQ_BYTE4] & 0x0f);
|
eraseAddress = 0;
|
eraseRemainder = 0;
|
if (Nvm_Flags.flash_driver_loaded == 0)
|
{
|
/*flash not load to ram*/
|
UDS_SendNegResp(NRC_CONDITIONS_NOT_CORRECT);
|
return;
|
}
|
for (i = 0; i < lengthFormat; i++)
|
{
|
eraseAddress <<= 8;
|
eraseAddress |= payload[i + UDS_RQ_BYTE5];
|
}
|
for (i = 0; i < addrFormat; i++)
|
{
|
eraseRemainder <<= 8;
|
eraseRemainder |= payload[i + UDS_RQ_BYTE5 + lengthFormat];
|
}
|
eraseRemainder += (64 - (eraseRemainder % 64));
|
|
if ((eraseAddress != APPCODE_START) || (eraseRemainder == 0))
|
{
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
return;
|
}
|
|
UDS_L_ResponsePendingRequest_e |= ERASE_RESP_PENDING;
|
UDS_SendNegResp(NRC_SERVICE_BUSY);
|
erase_state = NVM_EraseData(eraseAddress, eraseRemainder);
|
if (erase_state == OP_STATUS_OK)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ROUTINE_CONTROL);
|
UDS_L_tx_msg_buffer[1] = 0x01;
|
UDS_L_tx_msg_buffer[2] = 0xff;
|
UDS_L_tx_msg_buffer[3] = 0x00;
|
UDS_L_tx_msg_buffer[4] = 0; // 0:ok 1£ºerror
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 5;
|
UDS_RespTxMessage();
|
}
|
else
|
{
|
UDS_SendNegResp(NRC_GENERAL_PROGRAMMING_FAILURE);
|
}
|
}
|
|
static void UDS_CheckProgrammingIntergrity(uint8_t *payload)
|
{
|
#if 0
|
int8_t crc_state=OP_STATUS_FAIL;
|
bool crc_result=false;
|
FBL_UDS_O_transferCRC=(uint32_t)payload[4]<<24|(uint32_t)payload[5]<<16|(uint32_t)payload[6]<<8|(uint32_t)payload[7];
|
//crc_state=MEM_CodeCRCCheck(transferAddress+4,transferRemainder,FBL_UDS_SetCRCCheckResult);
|
#if 0
|
if(crc_state==OP_STATUS_OK)
|
{
|
FBL_UDS_L_ResponsePendingRequest_e|=CHECK_PROGRAMMING_INTERGRITY_PENDING;
|
UDS_SendNegResp(RESPONSEPENDING);
|
}
|
else
|
{
|
UDS_SendNegResp(GENERALPROGRAMMINGFAILURE);
|
}
|
#endif
|
UDS_L_tx_msg_buffer[0] = RESP_ID_ROUTINE_CONTROL;
|
UDS_L_tx_msg_buffer[1] = 0x01;
|
UDS_L_tx_msg_buffer[2] = 0xf0;
|
UDS_L_tx_msg_buffer[3] =0x01;
|
if(transferType==DOWNLOAD_FLASH)
|
{
|
crc_result=MEM_PartitionCRCOK((uint8_t)MEM_PARTITION_CODEFLASH);
|
}
|
else
|
{
|
crc_result=MEM_PartitionCRCOK((uint8_t)MEM_PARTITION_RAM);
|
}
|
//UDS_L_tx_msg_buffer[4] = (uint8_t)(!crc_result);
|
UDS_L_tx_msg_buffer[4] = 0;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x05;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
if(FBL_CANTP_TxMessage(&UDS_L_tp_stack, UDS_L_tx_msg_buffer,
|
UDS_L_tx_msg_size))
|
{
|
FBL_UDS_L_ResponsePendingRequest_e &=(~CHECK_PROGRAMMING_INTERGRITY_PENDING);
|
FBL_UDS_L_ResponsePendingRelease_e &=(~CHECK_PROGRAMMING_INTERGRITY_PENDING);
|
}
|
#endif
|
UDS_L_CRCReceived = (uint32_t)payload[4] << 24 | (uint32_t)payload[5] << 16 | (uint32_t)payload[6] << 8 | (uint32_t)payload[7];
|
UDS_L_ResponsePendingRequest_e |= CHECK_PROGRAMMING_INTERGRITY_PENDING;
|
CDT_RESET(ResponsePendingTimer_u16, P2SERVER_PENDING_TIMEROUT);
|
}
|
|
static void UDS_CheckProgrammingDependence(uint8_t *payload)
|
{
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ROUTINE_CONTROL);
|
UDS_L_tx_msg_buffer[1] = 0x01;
|
UDS_L_tx_msg_buffer[2] = 0xff;
|
UDS_L_tx_msg_buffer[3] = 0x01;
|
UDS_L_tx_msg_buffer[4] = 0;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x05;
|
|
/* Compose a response message and send a positive */
|
UDS_RespTxMessage();
|
}
|
|
static void UDS_CheckProgrammingPrecondition()
|
{
|
UDS_L_ProgrammingPreconditionCheckOK_b = true; /* always is true,maybe need check shiftpostion,speed and so on */
|
|
/* Compose the response payload */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(ROUTINE_CONTROL);
|
UDS_L_tx_msg_buffer[1] = 0x01;
|
UDS_L_tx_msg_buffer[2] = 0xff;
|
UDS_L_tx_msg_buffer[3] = 0x02;
|
UDS_L_tx_msg_buffer[4] = 0;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x05;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
|
static void UDS_RequestDownload(uint8_t *payload)
|
{
|
uint8_t lengthFormat;
|
uint16_t receive_size = 0;
|
lengthFormat = (uint8_t)((payload[UDS_RQ_BYTE2] & 0xf0) >> 4);
|
|
if (payload[UDS_RQ_BYTE2] != 0x44)
|
{
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
return;
|
}
|
if (UDS_L_rx_msg_size != REQUEST_DOWNLOAD_MSG_SIZE)
|
{
|
UDS_SendNegResp(NRC_INVALID_MESSAGE_LENGTH_OR_FORMAT);
|
return;
|
}
|
if (UDS_L_TransferDataInProgressing_b == true)
|
{
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
return;
|
}
|
expectedSequenceCnt = 0x01;
|
currentSequenceCnt = 0x01;
|
transferAddress = ((uint32_t)payload[UDS_RQ_BYTE3]) << 24 | ((uint32_t)payload[UDS_RQ_BYTE4]) << 16 | ((uint32_t)payload[UDS_RQ_BYTE5]) << 8 | ((uint32_t)payload[UDS_RQ_BYTE6]);
|
transferRemainder = ((uint32_t)payload[UDS_RQ_BYTE7]) << 24 | ((uint32_t)payload[UDS_RQ_BYTE8]) << 16 | ((uint32_t)payload[UDS_RQ_BYTE9]) << 8 | ((uint32_t)payload[UDS_RQ_BYTE10]);
|
|
if (transferRemainder == 0)
|
{
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
return;
|
}
|
DownloadAddress = transferAddress;
|
DownloadLength = transferRemainder;
|
if (transferAddress == FLASH_DRIVER_START_ADDR)
|
{
|
transferType = DOWNLOAD_RAM;
|
}
|
else if (transferAddress == APPCODE_START)
|
{
|
transferType = DOWNLOAD_FLASH;
|
}
|
else
|
{
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
return;
|
}
|
|
if (transferType == DOWNLOAD_FLASH)
|
{
|
/*flash driver is loaded?*/
|
if ((Nvm_Flags.flash_driver_loaded == 0))
|
{
|
UDS_SendNegResp(NRC_REQUEST_SEQUENCE_ERROR);
|
return;
|
}
|
|
if ((transferAddress != APPCODE_START) || (transferAddress + transferRemainder > APPLICATION_END_ADDR))
|
{
|
UDS_SendNegResp(NRC_REQUEST_OUT_OF_RANGE);
|
return;
|
}
|
}
|
else if ((transferType == DOWNLOAD_RAM))
|
{
|
if ((transferRemainder > (uint32_t)RAM_FALSH_DRIVE_LENGHT) || ((tFblAddress)flashCode != transferAddress))
|
{
|
// FblErrStatSetError(FBL_ERR_FLASHCODE_EXCEEDS_MEMORY);
|
UDS_SendNegResp(NRC_REQUEST_SEQUENCE_ERROR);
|
return;
|
}
|
else
|
{
|
}
|
}
|
DID_UpdateAtpProgramCnt();
|
/*always from buff 0*/
|
currentbuffId = 0;
|
UDS_L_TransferDataState_e = TRANFER_START;
|
receive_size = FBL_RX_BUFFER_SIZE + 2;
|
/*RESPONSE*/
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(REQUEST_DOWNLOAD);
|
// UDS_L_tx_msg_buffer[1] = lengthFormat<<4;
|
UDS_L_tx_msg_buffer[1] = 0x20;
|
UDS_L_tx_msg_buffer[2] = (uint8_t)(receive_size >> 8); /*max length of block size,256Byte*/
|
UDS_L_tx_msg_buffer[3] = ((uint8_t)receive_size);
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x04;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
static void UDS_TransferData(uint8_t *payload)
|
{
|
uint8_t partition_id;
|
uint32_t loadlength = 0;
|
uint8_t i = 0;
|
MEM_OPERATION_Ts operation_write;
|
int8_t write_result = OP_STATUS_FAIL;
|
/* Check if the requested sequence number is expected */
|
if (payload[UDS_RQ_BYTE1] != expectedSequenceCnt)
|
{
|
/* Check if sequence number corresponds to a retry */
|
if (payload[UDS_RQ_BYTE1] == currentSequenceCnt)
|
{
|
/* Handle the retries here */
|
|
/* Repetition of last transferData request */
|
/* Simply send a positive response without loading data to memory */
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(TRANSFER_DATA);
|
UDS_L_tx_msg_buffer[1] = currentSequenceCnt;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
else /* Sequence number is not for a retry */
|
{
|
/* Send a WrongSequenceError */
|
UDS_SendNegResp(NRC_WRONG_BLOCK_SEQUENCE_COUNTER);
|
return;
|
}
|
}
|
|
if (transferRemainder == 0) //||(transferAddress>=startaddr+length)
|
{
|
/*already receive all data*/
|
UDS_SendNegResp(NRC_REQUEST_SEQUENCE_ERROR);
|
return;
|
}
|
|
if (transferType == DOWNLOAD_FLASH)
|
{
|
if (transferAddress >= APPLICATION_END_ADDR)
|
{
|
/*already receive all data*/
|
UDS_SendNegResp(NRC_REQUEST_SEQUENCE_ERROR);
|
return;
|
}
|
partition_id = (uint8_t)MEM_PARTITION_CODEFLASH;
|
}
|
else
|
{
|
partition_id = (uint8_t)MEM_PARTITION_RAM;
|
}
|
/*COPY TP RX BUFF DATA TO MEM_TRMP BUFF*/
|
if (transferType == DOWNLOAD_FLASH)
|
{
|
if ((UDS_L_rx_msg_size - 2) < FBL_RX_BUFFER_SIZE)
|
{
|
for (i = 0; i < (FBL_RX_BUFFER_SIZE + 2 - UDS_L_rx_msg_size); i++)
|
{
|
payload[UDS_L_rx_msg_size + i] = 0xff;
|
}
|
}
|
else
|
{
|
}
|
loadlength = FBL_RX_BUFFER_SIZE;
|
}
|
else
|
{
|
// loadlength+=((uint32_t)(UDS_L_rx_msg_size-2));
|
loadlength = ((uint32_t)(UDS_L_rx_msg_size - 2));
|
}
|
memcpy((void *)&Mem_PartionTempBuff[currentbuffId][0], &payload[UDS_RQ_BYTE2], loadlength);
|
|
operation_write.p_buffer = &Mem_PartionTempBuff[currentbuffId][0];
|
operation_write.partition_id = partition_id;
|
operation_write.mem_operation_id = NVM_OP_TYPE_WRITE;
|
operation_write.start_addr = transferAddress;
|
operation_write.size_in_bytes = loadlength;
|
operation_write.pfn_complete_cbk = NULL;
|
operation_write.current_sequenc = expectedSequenceCnt;
|
operation_write.prev_seqence = currentSequenceCnt;
|
|
UDS_SendNegResp(NRC_SERVICE_BUSY); // first send busy
|
write_result = NEM_WriteData(&operation_write); // todo write all data at this function
|
if (write_result == OP_STATUS_OK)
|
{
|
transferAddress += loadlength;
|
transferRemainder -= (UDS_L_rx_msg_size - 2);
|
// transferRemainder-=loadlength;
|
if (transferRemainder == 0)
|
{
|
UDS_L_TransferDataState_e = TRANFER_END;
|
}
|
|
if (currentbuffId == 0)
|
{
|
currentbuffId = 1;
|
}
|
else
|
{
|
|
currentbuffId = 0;
|
}
|
/* Memorize current counter */
|
currentSequenceCnt = expectedSequenceCnt;
|
|
/* Sequence counter value of next transferData request */
|
expectedSequenceCnt++;
|
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(TRANSFER_DATA);
|
UDS_L_tx_msg_buffer[1] = currentSequenceCnt;
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x02;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
}
|
else
|
{
|
UDS_SendNegResp(NRC_GENERAL_PROGRAMMING_FAILURE);
|
}
|
}
|
static void UDS_RequestTransferExit(uint8_t *payload)
|
{
|
|
if (transferType == DOWNLOAD_FLASH)
|
{
|
transferAddress = APPCODE_START;
|
transferRemainder = 0;
|
}
|
else
|
{
|
transferAddress = FLASH_DRIVER_START_ADDR;
|
transferRemainder = 0;
|
}
|
UDS_L_TransferDataInProgressing_b = false;
|
UDS_L_TransferDataState_e = TRANFER_IDLE;
|
// transferType=0;
|
expectedSequenceCnt = 0x01;
|
currentSequenceCnt = 0x01;
|
|
UDS_L_tx_msg_buffer[0] = GET_RESPONSE_SERVICE_ID(REQUEST_TRANSFER_EXIT);
|
/* Specify the send payload size */
|
UDS_L_tx_msg_size = 0x01;
|
|
/* Compose a response message and send a positive */
|
/* response with the request data */
|
UDS_RespTxMessage();
|
DID_UpdateProgramCnt();
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_SendNegResp(NEGA_RESP_Code_e reason) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function composes and send a negative response */
|
/* INPUTS : */
|
/* NEGA_RESP_Code_e reason: Negative response reason */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Send negative response */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 07/29/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SendNegResp(NEGA_RESP_Code_e reason)
|
{
|
TP_PDU_t out = {0};
|
/* Pack and send CAN message */
|
out.arbId = UDS_RESP_TID;
|
out.extended = false;
|
out.RTR = false;
|
out.dlc = 8;
|
out.frame[0] = 3;
|
out.frame[1] = 0x7F;
|
out.frame[2] = UDS_L_rx_msg_buffer[0];
|
out.frame[3] = (uint8_t)reason;
|
#if 0
|
CANTP_zeroRestOfFrame(&out);
|
#endif
|
UDS_WriteData(&out, 0);
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_FlipEndian(void *address, uint16_t size) */
|
/* */
|
/* DESCRIPTION : */
|
/* Function to flip the endianness of a set of memory locations */
|
/* and put the flipped number back to *address location */
|
/* INPUTS : */
|
/* void* address : Start address of the memory location */
|
/* uint16_t size : Memory size */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* [1] Flip endianness */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 07/31/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_FlipEndian(void *address, uint16_t size)
|
{
|
|
uint8_t temp = 0;
|
uint8_t i = 0;
|
for (i = size; i > size / 2; i--)
|
{
|
temp = ((uint8_t *)address)[size - i];
|
((uint8_t *)address)[size - i] = ((uint8_t *)address)[i - 1];
|
((uint8_t *)address)[i - 1] = temp;
|
}
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_BuildDidSet(uint8_t * payload) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function builds up the set of requested DID */
|
/* INPUTS : */
|
/* uint8_t * payload: pointer to the payload starting address */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Build requested DID set */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 07/31/2014 Fogbugz: case#: 1575 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static bool UDS_BuildDidSet(uint8_t *payload)
|
{
|
#if 1
|
uint16_t i = 0;
|
bool DIDnotFoundflag = false;
|
|
/* Set the initial value of requested DID set size */
|
/* UDS_L_ReadDidSetSize_u16 = 0; */
|
|
UDS_L_ReadDIDSet_t.DID_Value = payload[1] << 8 | payload[2];
|
|
/* For each requested DID, verify it can be found in current DID table */
|
|
for (i = 0; (i < UDS_DID_TABLE_SIZE) && (DIDtable[i].DidEnum != UDS_L_ReadDIDSet_t.DID_Value); i++)
|
{
|
/* break; */
|
}
|
|
/* i == DIDTable_Entry_Count_u16 means no data with the DID is found */
|
if (i == UDS_DID_TABLE_SIZE)
|
{
|
/* Flag the fact that there is DID that cannot be found */
|
DIDnotFoundflag = true;
|
}
|
else
|
{
|
/* Continue with next requested DID */
|
UDS_L_ReadDIDSet_t.DID_Table_Index = i;
|
}
|
|
return (DIDnotFoundflag);
|
#else
|
bool not_found = true;
|
UDS_L_ReadDIDSet_t.DID_Value = payload[1] << 8 | payload[2];
|
uint16_t i;
|
for (i = 0; i < UDS_DID_TABLE_SIZE; i++)
|
{
|
if (UDS_L_ReadDIDSet_t.DID_Value == DIDtable[i].DidEnum)
|
{
|
UDS_L_ReadDIDSet_t.DID_Table_Index = i;
|
not_found = false;
|
break;
|
}
|
}
|
return not_found;
|
#endif
|
}
|
|
/*****************************************************************************/
|
/* NAME : static void UDS_SwitchtoDefaultSession(void) */
|
/* */
|
/* DESCRIPTION : */
|
/* This function handles the operations to switch to default session*/
|
/* INPUTS : */
|
/* None */
|
/* OUTPUTS : */
|
/* None */
|
/* RETURN : */
|
/* void */
|
/* PROCESS : */
|
/* Build requested DID set */
|
/* NOTES : */
|
/* None */
|
/* REVISION HISTORY : */
|
/* (1) Date: 10/30/2014 Fogbugz: case#: 2283 */
|
/* Initial release by Tom Tao */
|
/*****************************************************************************/
|
static void UDS_SwitchtoDefaultSession(uint8_t restcmd)
|
{
|
UDS_L_Diag_session_e = DEFAULT;
|
UDS_L_ProgrammingPreconditionCheckOK_b = false;
|
if (restcmd == true)
|
{
|
CPU_HardReset();
|
}
|
}
|
|
static void UDS_StringCopy(char *p_src, char *p_dest, uint8_t max_size)
|
{
|
uint8_t pn_len = 0u;
|
uint8_t i = 0u;
|
|
if ((p_src != NULL) && (p_dest != NULL) && (max_size > 0))
|
{
|
/* get the length of the string, limited to max_size */
|
pn_len = strnlen(p_src, max_size);
|
/* p_src=p_src+pn_len; */
|
/* copy source into dest */
|
for (i = 0u; i < pn_len; i++)
|
{
|
*p_dest++ = *p_src++;
|
}
|
for (i = pn_len; i < max_size; i++)
|
{
|
*p_dest++ = '\0';
|
}
|
}
|
}
|
|
/* end of _UDS_H */
|
