/* BEGIN_FILE_HDR ******************************************************************************* * NOTICE * This software is the property of HiRain Technologies. Any information * contained in this doc should not be reproduced, or used, or disclosed * without the written authorization from HiRain Technologies. ******************************************************************************* * File Name : E2E_P06.c ******************************************************************************* * Project/Product : AUTOSAR R21-11 * Title : End-to-End protect module * Author : Hirain ******************************************************************************* * Description : The source file of the End-to-End module. * ******************************************************************************* * Limitations : None * ******************************************************************************* * ******************************************************************************* * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- ------------ ---------- --------------- * 04.00.00 01/08/2022 wenbo.cui N/A Original ******************************************************************************* * END_FILE_HDR*/ /****************************************************************************** * Includes ******************************************************************************/ #include "E2E_P06.h" /******************************************************************************* * General QAC Suppression *******************************************************************************/ /*PRQA S 3214,0862,3614 EOF*/ /* According to the requirements of AUTOSAR Specification,when locating address segments in the files of each module,#include "E2E_MemMap.h" is required.Defined XXX_START_SEC_ will undefine in E2E_MemMap.h */ /*PRQA S 3432 EOF*/ /* P2VAR and other macros in the Compiler conforms to AUTOSAR standard.There's no need to revise. */ /***************************************************************************** * E2E QAC Suppression *****************************************************************************/ /*PRQA S 4640,4641 EOF*/ /* Function, macrodefinition is named with a fixed requirement and does not make changes */ /*PRQA S 3429,3453 EOF*/ /* Allow the use of macrofunction access definitions, and the department is verified and there is no problem. */ /*PRQA S 3435,3456 EOF*/ /* Allow multiple use parameters in macros */ /****************************************************************************** * Macro ******************************************************************************/ #define E2E_P06_BYTE_MASK ((uint8)0xFF) #define E2E_P06_CRC_INIT_VALUE ((uint16)0xFFFF) /*header length and offset defined in bytes*/ #define E2E_P06_HEADER_BYTE_LENGTH ((uint16)5) #define E2E_P06_CRC_OFFSET ((uint16)0) #define E2E_P06_LENGTH_OFFSET ((uint16)2) #define E2E_P06_COUNTER_OFFSET ((uint16)4) /*data length defined in bits*/ #define E2E_P06_MAX_DATA_LENGTH ((uint16)0x8000) #define E2E_P06_MIN_DATA_LENGTH ((uint16)(E2E_P06_HEADER_BYTE_LENGTH * (uint16)8)) #define E2E_P06_DATA_UINT_BIT ((uint16)8) /*SWS_E2E_00417*/ #define E2E_P06_MAX_COUNTER_VALUE ((uint8)0xFF) #define E2E_P06_GET_HEADEROFFSET(config) (((config)->Offset) >> (uint16)3) #define E2E_P06_BETOMCU16(data) (uint16)( (uint16)(((uint16)(data)[0] & (uint16)0x00FF) << (uint16)8)\ | (uint16)(((uint16)(data)[1] & (uint16)0x00FF) << (uint16)0)) #define E2E_P06_BYTE_ALIGNED_MASK ((uint16)0x0007) #define E2E_P06_IS_NOT_BYTE_ALIGNED(bit) ((uint16)((bit) & E2E_P06_BYTE_ALIGNED_MASK) != (uint16)0) #define E2E_START_SEC_CODE #include "E2E_MemMap.h" /****************************************************************************** * Private Functions Declare ******************************************************************************/ STATIC FUNC(void, E2E_CODE)E2E_P06CheckRecvCounter ( uint8 Counter, P2CONST(E2E_P06ConfigType, AUTOMATIC, E2E_APPL_CONST) Config, P2VAR(E2E_P06CheckStateType, AUTOMATIC, E2E_APPL_DATA) State ); STATIC FUNC(uint8, E2E_CODE) E2E_P06GetDeltaCounter ( uint8 Counter, uint8 LastValidCounter ); STATIC FUNC(uint16, E2E_CODE)E2E_P06GetCrc ( uint16 Length, P2CONST(E2E_P06ConfigType, AUTOMATIC, E2E_APPL_CONST) Config, P2CONST(uint8, AUTOMATIC, E2E_APPL_DATA) Data ); STATIC FUNC(void, E2E_CODE)E2E_P06Mcu16ToBeData ( P2VAR(uint8, AUTOMATIC, E2E_APPL_DATA) DataPtr, uint16 data ); /****************************************************************************** * Private Functions ******************************************************************************/ /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06CheckRecvCounter * * Description: Check the received counter. * * Inputs: Counter : Received counter. * Config : Pointer to static configuration. * State : Pointer to port/data communication state. * * Outputs: None. * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00436*/ STATIC FUNC(void, E2E_CODE)E2E_P06CheckRecvCounter ( uint8 Counter, P2CONST(E2E_P06ConfigType, AUTOMATIC, E2E_APPL_CONST) Config, P2VAR(E2E_P06CheckStateType, AUTOMATIC, E2E_APPL_DATA) State ) { uint8 DeltaCounter; /*compute delta counter*/ DeltaCounter = E2E_P06GetDeltaCounter(Counter, State->Counter); if((uint8)0 == DeltaCounter) { State->Status = E2E_P06STATUS_REPEATED; } else if((uint8)1 == DeltaCounter) { State->Status = E2E_P06STATUS_OK; } else if(DeltaCounter <= Config->MaxDeltaCounter) { State->Status = E2E_P06STATUS_OKSOMELOST; } else { State->Status = E2E_P06STATUS_WRONGSEQUENCE; } State->Counter = Counter; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06GetDeltaCounter * * Description: Calculate the delta counter. * * Inputs: Counter : Received counter. * LastValidCounter : The last valid counter value. * * Outputs: The delta counter value. * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ STATIC FUNC(uint8, E2E_CODE) E2E_P06GetDeltaCounter ( uint8 Counter, uint8 LastValidCounter ) { uint8 DeltaCounter; if(Counter >= LastValidCounter) { DeltaCounter = Counter - LastValidCounter; } else { DeltaCounter = ((uint8)(E2E_P06_MAX_COUNTER_VALUE - LastValidCounter) + (uint8)1) + Counter; } return DeltaCounter; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06GetCrc * * Description: Calculate the crc value. * * Inputs: Length : Data length in bytes. * Config : Pointer to static configuration. * Data : Pointer to the data to be protected. * * Outputs: The crc value. * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00427*/ STATIC FUNC(uint16, E2E_CODE)E2E_P06GetCrc ( uint16 Length, P2CONST(E2E_P06ConfigType, AUTOMATIC, E2E_APPL_CONST) Config, P2CONST(uint8, AUTOMATIC, E2E_APPL_DATA) Data ) { uint16 crc = E2E_P06_CRC_INIT_VALUE; uint16 headerOffset = E2E_P06_GET_HEADEROFFSET(Config); uint8 dataIdLow; uint8 dataIdHigh; uint16 CrcCopyLength; if(Config->Offset > (uint16)0) { /*SWS_E2E_00221*//*SWS_E2E_00420*//*SWS_E2E_00421*//*SWS_E2E_00110*/ crc = Crc_CalculateCRC16(&Data[0], (uint32)headerOffset, crc, TRUE); CrcCopyLength = (uint16)(Length - headerOffset) - E2E_P06_LENGTH_OFFSET; crc = Crc_CalculateCRC16(&Data[headerOffset + E2E_P06_LENGTH_OFFSET], (uint32)CrcCopyLength, crc, FALSE); } else { /*SWS_E2E_00221*//*SWS_E2E_00420*//*SWS_E2E_00421*//*SWS_E2E_00110*/ CrcCopyLength = (uint16)(Length - headerOffset) - E2E_P06_LENGTH_OFFSET; crc = Crc_CalculateCRC16(&Data[headerOffset + E2E_P06_LENGTH_OFFSET], (uint32)CrcCopyLength, crc, TRUE); } dataIdLow = (uint8)(Config->DataID) & E2E_P06_BYTE_MASK; dataIdHigh = (uint8)(Config->DataID >> E2E_P06_DATA_UINT_BIT) & E2E_P06_BYTE_MASK; /*SWS_E2E_00221*//*SWS_E2E_00419*//*SWS_E2E_00420*//*SWS_E2E_00421*//*SWS_E2E_00110*/ crc = Crc_CalculateCRC16(&dataIdHigh, (uint32)1, crc, FALSE); crc = Crc_CalculateCRC16(&dataIdLow, (uint32)1, crc, FALSE); return crc; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06Mcu16ToBeData * * Description: Converte the 16-bit data to big endian 8-bit data * * Inputs: DataPtr : Pointer to the data. * Data : Data to be converted. * * Outputs: None. * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ STATIC FUNC(void, E2E_CODE)E2E_P06Mcu16ToBeData ( P2VAR(uint8, AUTOMATIC, E2E_APPL_DATA) DataPtr, uint16 data ) { DataPtr[0] = (uint8)(data >> E2E_P06_DATA_UINT_BIT) & E2E_P06_BYTE_MASK; DataPtr[1] = (uint8)data & E2E_P06_BYTE_MASK; } /****************************************************************************** * Public Funtions ******************************************************************************/ /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06ProtectInit * * Description: Initializes the protection state. * * Inputs: StatePtr : Pointer to port/data communication state. * * Outputs: E2E_E_INPUTERR_NULL, * E2E_E_OK * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00455*/ FUNC(Std_ReturnType, E2E_CODE) E2E_P06ProtectInit ( P2VAR(E2E_P06ProtectStateType, AUTOMATIC, E2E_APPL_DATA) StatePtr ) { Std_ReturnType ret; /*SWS_E2E_00456*//*SWS_E2E_00011*/ if(NULL_PTR == StatePtr) { ret = E2E_E_INPUTERR_NULL; } else { ret = E2E_E_OK; /*SWS_E2E_00417*/ StatePtr->Counter = (uint8)0; } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06Protect * * Description: Protects the array/buffer to be transmitted using the E2E profile 6. * This includes checksum calculation, handling of counter. * * Inputs: ConfigPtr : Pointer to static configuration. * StatePtr : Pointer to port/data communication state. * DataPtr : Pointer to Data to be transmitted. * Length : Length of the data in bytes. * * Outputs: E2E_E_INPUTERR_NULL, * E2E_E_INPUTERR_WRONG, * E2E_E_INTERR, * E2E_E_OK * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00393*//*SWS_E2E_00423*/ FUNC(Std_ReturnType, E2E_CODE) E2E_P06Protect ( P2CONST(E2E_P06ConfigType, AUTOMATIC, E2E_APPL_CONST) ConfigPtr, P2VAR(E2E_P06ProtectStateType, AUTOMATIC, E2E_APPL_DATA) StatePtr, P2VAR(uint8, AUTOMATIC, E2E_APPL_DATA) DataPtr, uint16 Length ) { Std_ReturnType ret = E2E_E_OK; uint16 headerOffset; uint16 crc; /*verify input parameters*//*SWS_E2E_00011*//*SWS_E2E_00424*/ if((NULL_PTR == ConfigPtr) || (NULL_PTR == StatePtr) || (NULL_PTR == DataPtr)) { ret = E2E_E_INPUTERR_NULL; } else if (((ConfigPtr->MinDataLength) < E2E_P06_MIN_DATA_LENGTH) || (ConfigPtr->MinDataLength > ConfigPtr->MaxDataLength) || (ConfigPtr->MaxDataLength > E2E_P06_MAX_DATA_LENGTH) || (E2E_P06_IS_NOT_BYTE_ALIGNED(ConfigPtr->MinDataLength)) || (E2E_P06_IS_NOT_BYTE_ALIGNED(ConfigPtr->MaxDataLength))) { ret = E2E_E_INPUTERR_WRONG; } /*SWS_E2E_00424*/ else if (((Length * E2E_P06_DATA_UINT_BIT) < ConfigPtr->MinDataLength) || ((Length * E2E_P06_DATA_UINT_BIT) > ConfigPtr->MaxDataLength)) { ret = E2E_E_INPUTERR_WRONG; } else if ((ConfigPtr->Offset > ((uint16)(Length - E2E_P06_HEADER_BYTE_LENGTH) * E2E_P06_DATA_UINT_BIT)) || (E2E_P06_IS_NOT_BYTE_ALIGNED(ConfigPtr->Offset))) { ret = E2E_E_INPUTERR_WRONG; } else { /*Compute offset*//*SWS_E2E_00470*/ headerOffset = E2E_P06_GET_HEADEROFFSET(ConfigPtr); /*Write Length to data in big endian order*//*SWS_E2E_00479*//*SWS_E2E_00425*/ E2E_P06Mcu16ToBeData(&DataPtr[headerOffset + E2E_P06_LENGTH_OFFSET], Length); /*Write Counter to data in big endian order*//*SWS_E2E_00479*//*SWS_E2E_00426*/ DataPtr[headerOffset + E2E_P06_COUNTER_OFFSET] = StatePtr->Counter; /*calculate crc*/ crc = E2E_P06GetCrc(Length, ConfigPtr, DataPtr); /*Write crc to data in big endian order*//*SWS_E2E_00479*//*SWS_E2E_00428*/ E2E_P06Mcu16ToBeData(&DataPtr[headerOffset + E2E_P06_CRC_OFFSET], crc); /*PRQA S 3383 ++*/ /*The previously logical judgment of the data is guaranteed that the data value will not overflow.*/ /*Increment Counter*//*SWS_E2E_00221*//*SWS_E2E_00417*//*SWS_E2E_00429*/ StatePtr->Counter++; /*PRQA S 3383 --*/ } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06Check * * Description: Checks the Data received using the E2E profile 6. This includes * CRC calculation, handling of Counter. * * Inputs: ConfigPtr : Pointer to static configuration. * StatePtr : Pointer to port/data communication state. * DataPtr : Pointer to received data. * Length : Length of the data in bytes. * * Outputs: E2E_E_INPUTERR_NULL, * E2E_E_INPUTERR_WRONG, * E2E_E_INTERR, * E2E_E_OK * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00457*//*SWS_E2E_00430*/ FUNC(Std_ReturnType, E2E_CODE)E2E_P06Check ( P2CONST(E2E_P06ConfigType, AUTOMATIC, E2E_APPL_CONST) ConfigPtr, P2VAR(E2E_P06CheckStateType, AUTOMATIC, E2E_APPL_DATA) StatePtr, P2CONST(uint8, AUTOMATIC, E2E_APPL_DATA) DataPtr, uint16 Length ) { Std_ReturnType ret = E2E_E_OK; uint16 calCrc; uint16 recvCrc; uint16 headOffset; uint8 recvCounter; uint16 recvLength; /*SWS_E2E_00011*//*SWS_E2E_00431*/ if((NULL_PTR == ConfigPtr) || (NULL_PTR == StatePtr)) { ret = E2E_E_INPUTERR_NULL; } /*check config data length*/ else if (((ConfigPtr->MinDataLength) < E2E_P06_MIN_DATA_LENGTH) || (ConfigPtr->MinDataLength > ConfigPtr->MaxDataLength) || (ConfigPtr->MaxDataLength > E2E_P06_MAX_DATA_LENGTH) || (E2E_P06_IS_NOT_BYTE_ALIGNED(ConfigPtr->MinDataLength)) || (E2E_P06_IS_NOT_BYTE_ALIGNED(ConfigPtr->MaxDataLength))) { ret = E2E_E_INPUTERR_WRONG; } else if (DataPtr == NULL_PTR) { if(Length != (uint16)0) { ret = E2E_E_INPUTERR_WRONG; } else { /*No data has been received*//*SWS_E2E_00436*/ StatePtr->Status = E2E_P06STATUS_NONEWDATA; } } /*check the length of received data*//*SWS_E2E_00431*/ else if (((Length * E2E_P06_DATA_UINT_BIT) > ConfigPtr->MaxDataLength) || ((Length * E2E_P06_DATA_UINT_BIT) < ConfigPtr->MinDataLength)) { ret = E2E_E_INPUTERR_WRONG; } /*the length of the data received is correct*/ else { /*SWS_E2E_00431*/ if ((ConfigPtr->Offset > ((uint16)(Length - E2E_P06_HEADER_BYTE_LENGTH) * E2E_P06_DATA_UINT_BIT)) || (E2E_P06_IS_NOT_BYTE_ALIGNED(ConfigPtr->Offset))) { ret = E2E_E_INPUTERR_WRONG; } else { /*compute offset*/ headOffset = E2E_P06_GET_HEADEROFFSET(ConfigPtr); /*PRQA S 4571 ++*/ /*Allows less than int length data to shift and retrieve other operations, and the department is verified and there is no problem.*/ /*read received length from data*//*SWS_E2E_00432*/ recvLength = E2E_P06_BETOMCU16(&DataPtr[headOffset + E2E_P06_LENGTH_OFFSET]); /*read received counter from data*//*SWS_E2E_00433*/ recvCounter = DataPtr[headOffset + E2E_P06_COUNTER_OFFSET]; /*read received crc from data*//*SWS_E2E_00434*/ recvCrc = E2E_P06_BETOMCU16(&DataPtr[headOffset + E2E_P06_CRC_OFFSET]); /*PRQA S 4571 --*/ /*Compute CRC*/ calCrc = E2E_P06GetCrc(Length, ConfigPtr, DataPtr); /*Check if the received crc and data length is correct*//*SWS_E2E_00436*/ if((recvCrc == calCrc) && (recvLength == Length)) { /*check counter*//*SWS_E2E_00436*/ E2E_P06CheckRecvCounter(recvCounter, ConfigPtr, StatePtr); } else { /*SWS_E2E_00436*/ StatePtr->Status = E2E_P06STATUS_ERROR; } } } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06CheckInit * * Description: Initializes the check state. * * Inputs: StatePtr : Pointer to port/data communication state. * * Outputs: E2E_E_INPUTERR_NULL, * E2E_E_OK * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00458*/ FUNC(Std_ReturnType, E2E_CODE) E2E_P06CheckInit ( P2VAR(E2E_P06CheckStateType, AUTOMATIC, E2E_APPL_DATA) StatePtr ) { Std_ReturnType ret; /*SWS_E2E_00459*//*SWS_E2E_00011*/ if(NULL_PTR == StatePtr) { ret = E2E_E_INPUTERR_NULL; } else { StatePtr->Status = E2E_P06STATUS_ERROR; /*SWS_E2E_00473*/ StatePtr->Counter = E2E_P06_MAX_COUNTER_VALUE; ret = E2E_E_OK; } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************* * Function Name: E2E_P06MapStatusToSM * * Description: The function maps the check status of Profile 6 to a generic * check status, which can be used by E2E state machine check function. * The E2E Profile 6 delivers a more fine-granular status, but this * is not relevant for the E2E state machine. * * Inputs: CheckReturn : Return value of the E2E_P06Check function. * Status : Status determined by E2E_P06Check function. * * Outputs: Profile-independent status of the reception on one single Data in one cycle. * * Limitations: None ******************************************************************************* END_FUNCTION_HDR */ /*SWS_E2E_00460*/ FUNC(E2E_PCheckStatusType, E2E_CODE) E2E_P06MapStatusToSM ( Std_ReturnType CheckReturn, E2E_P06CheckStatusType Status ) { E2E_PCheckStatusType CheckStatus; /*SWS_E2E_00461*/ if(E2E_E_OK == CheckReturn) { if((E2E_P06STATUS_OK == Status) || (E2E_P06STATUS_OKSOMELOST == Status)) { CheckStatus = E2E_P_OK; } else if(E2E_P06STATUS_ERROR == Status) { CheckStatus = E2E_P_ERROR; } else if(E2E_P06STATUS_REPEATED == Status) { CheckStatus = E2E_P_REPEATED; } else if(E2E_P06STATUS_NONEWDATA == Status) { CheckStatus = E2E_P_NONEWDATA; } else { CheckStatus = E2E_P_WRONGSEQUENCE; } } /*SWS_E2E_00462*/ else { CheckStatus = E2E_P_ERROR; } return CheckStatus; } #define E2E_STOP_SEC_CODE #include "E2E_MemMap.h"