//***************************************************************************** // (C) Automotive Lighting Reutlingen GmbH // Tuebinger Strasse 123, 72762 Reutlingen, Germany // // Automotive Lighting Reutlingen GmbH owns all the rights to this work. // This work shall not be copied, reproduced, used, modified, transferred // or its information shall not be disclosed without the prior written // authorization of Automotive Lighting Reutlingen GmbH. //***************************************************************************** ///----------------------------------------------------------------------------- /// \file CodM.c /// /// \brief Coding Manager module for Hongqi H5 /// /// \descr Source: ECU8.x_CodingTool.xlsm. /// Version TBD /// For further details see coding parameter /// /// \author Kakade, Amol ALDE-RT/EES3 (Initial POC version) /// /// \date 21.06.2021, 10:51:08 ///----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Standard / system header file includes //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Project-specific header file includes //----------------------------------------------------------------------------- #include #include #include #include #include //----------------------------------------------------------------------------- // "define" and "typedef" statements at the module level //----------------------------------------------------------------------------- /** Swap the byte ordering of a 32-bit value */ #define CY_SWAP_ENDIAN32(x) ((uint32)((((x) >> 24u) & 0x000000FFu) | (((x) & 0x00FF0000u) >> 8u) | \ (((x) & 0x0000FF00u) << 8u) | ((x) << 24u))) #define VALIDATION_CYCLE_COUNTER_MAX 5u //----------------------------------------------------------------------------- // Global variable declarations //----------------------------------------------------------------------------- //============================================================================= // Start definitions of static or initialized variables of type of type structures, unions, or arrays //============================================================================= #define ctasCtrlStp_START_SEC_VAR_INIT_UNSPECIFIED #include "ctasCtrlStp_MemMap.h" // -------------- Start variable definitions. /* Actual coding Data*/ //tRomPara_CodingArea applicationCodingData __attribute__((section(".APPL_CODING_DATA"))) = ROMPARA_SYSTEMBLOCK_INIT; const tRomPara_CodingArea applicationCodingData __attribute__((section(".APPL_CODING_DATA"))); /* Actual coding Data End*/ // -------------- Stop variable definitions. #define ctasCtrlStp_STOP_SEC_VAR_INIT_UNSPECIFIED #include "ctasCtrlStp_MemMap.h" //============================================================================= // End definitions of static or initialized variables of type of type structures, unions, or arrays //============================================================================= #if 0 //============================================================================= // Start definitions of Initialized 32 bit variables //============================================================================= #define ctaaCodM_START_SEC_CONST_ROM_32BIT #include "ctaaCodM_MemMap.h" // -------------- Start variable definitions. const tRomPara_CodingArea* applicationCodingDataptr = (tRomPara_CodingArea*)&_start_of_coding_data; // PRQA S 310 1 // program architecture and code readability // -------------- Stop variable definitions. #define ctaaCodM_STOP_SEC_CONST_ROM_32BIT #include "ctaaCodM_MemMap.h" //============================================================================= // Stop definitions of Initialized 32 bit variables //============================================================================= #endif //============================================================================= // Start definitions of static or initialized variables of type of type structures, unions, or arrays //============================================================================= #define ctaaCodM_START_SEC_VAR_INIT_UNSPECIFIED #include "ctaaCodM_MemMap.h" // -------------- Start variable definitions. STATIC_AL uint8 CodM_pucCodingLabels[] = "F02_HH001_CODD_0003.0004"; //added by Amie uint8 NVM_MOUNTING_SIDE = 0xFF; // -------------- Stop variable definitions. #define ctaaCodM_STOP_SEC_VAR_INIT_UNSPECIFIED #include "ctaaCodM_MemMap.h" //============================================================================= // End definitions of static or initialized variables of type of type structures, unions, or arrays //============================================================================= //============================================================================= // Start definitions of uninitialized 8 bit variables //============================================================================= #define ctaaCodM_START_SEC_VAR_NO_INIT_8 #include "ctaaCodM_MemMap.h" // -------------- Start variable definitions. STATIC_AL tieSafetyCodingErrorReason CodM_SafetyCodingErrorReason; // -------------- Stop variable definitions. #define ctaaCodM_STOP_SEC_VAR_NO_INIT_8 #include "ctaaCodM_MemMap.h" //============================================================================= // End definitions of uninitialized 8 bit variables //============================================================================= //============================================================================= // Start definitions of static or initialized 8 bit variables //============================================================================= #define ctaaCodM_START_SEC_VAR_INIT_8 #include "ctaaCodM_MemMap.h" // -------------- Start variable definitions. STATIC_AL boolean CodM_bIsCodingLabelsCompatible = FALSE; STATIC_AL boolean CodM_bIsCodingDataValidated = FALSE; STATIC_AL uint8 CodM_CodingValidationCntr = 0u; STATIC_AL boolean CodM_boCrcCodingTestResultIsOk = FALSE; // -------------- Stop variable definitions. #define ctaaCodM_STOP_SEC_VAR_INIT_8 #include "ctaaCodM_MemMap.h" //============================================================================= // End definitions of static or initialized 8 bit variables //============================================================================= /* // test-code: Checking block size (see lst-file) #ifdef CHECKSIZE #pragma ghs ZO // turn off optimization volatile int SystemBlock = sizeof(tRomPara_SystemBlock); // 48 bytes expected volatile int CodingArea = sizeof(tRomPara_CodingArea); // 62+48 = 110 bytes expected (packed) volatile uint32 CodingAreaSize = &_start_of_coding_data - &_start_of_coding_data; // 62+48 = 110 bytes expected (packed) volatile int SystemBlock = sizeof(tRomPara_SystemBlock); // 48 bytes expected volatile int CodingArea = sizeof(tRomPara_CodingArea); // 62+48 = 110 bytes expected (packed) #endif #undef CHECKSIZE */ //============================================================================= // Start declaration or definitions of functions //============================================================================= #define ctaaCodM_START_SEC_CODE #include "ctaaCodM_MemMap.h" // -------------- Start function declarations or definitions. STATIC_AL void CodM_ValidateCodingData(void); //----------------------------------------------------------------------------- // Static variable declarations //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Function prototypes //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Function definitions //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- /// \brief initialisation function for CodM /// /// \descr CodM_Init() is initializing the RTE outputs, privat variables and /// coding data. /// Calling once at start up. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CodM_Init(void) { if(CodM_bIsCodingDataValidated == FALSE) { CodM_bIsCodingDataValidated = TRUE; CodM_ValidateCodingData(); CodM_Rte_Call_SysMonGetSafetyCodingErrorReason(&CodM_SafetyCodingErrorReason); if(( CodM_boCrcCodingTestResultIsOk == TRUE) && (CodM_SafetyCodingErrorReason == 0xFEu)) { CodM_Rte_Write_CodMFuSaCodingDataStatus(TRUE); } else { CodM_Rte_Write_CodMFuSaCodingDataStatus(FALSE); } } } //----------------------------------------------------------------------------- /// \brief deinitialisation function for CodM /// /// \descr CodM_DeInit() is doing nothing /// Calling once before go to sleep. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CodM_DeInit(void) { // do absolute nothing } // PRQA S 5334 1 // program architecture and code readability //----------------------------------------------------------------------------- /// \brief cyclic function for CodM /// /// \descr CodM_Cycle20ms() is to be updated further. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CodM_Cycle20ms(void) { //Read Coding Error for Fusa Coding Error CodM_Rte_Call_SysMonGetSafetyCodingErrorReason(&CodM_SafetyCodingErrorReason); // PRQA S 3200// program architecture and readability if(( CodM_boCrcCodingTestResultIsOk == TRUE) && (CodM_SafetyCodingErrorReason == 0xFEu)) { CodM_Rte_Write_CodMFuSaCodingDataStatus(TRUE); //TODO --Shall be changed once DTC is finalize //Rte_Call_ppaclSetDtcStatusE00100_SetEventStatus(DEM_EVENT_STATUS_PASSED); } else { CodM_Rte_Write_CodMFuSaCodingDataStatus(FALSE); //TODO --Shall be changed once DTC is finalize //Rte_Call_ppaclSetDtcStatusE00100_SetEventStatus(DEM_EVENT_STATUS_FAILED); } } //----------------------------------------------------------------------------- /// \brief Temporaru function to be used for avoiding code optimization /// /// \descr DoNotOptimize() is used temporarily for avoiding code optimization. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void DoNotOptimize(void) { (void)applicationCodingData; } //----------------------------------------------------------------------------- // Runnable Definitions //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- /// \brief initialisation runnable /// /// \descr initialisation runnable for CodM /// Calling once at start up. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(void, ctaaCodM_CODE) riCodMInit(void) { CodM_Init(); } //----------------------------------------------------------------------------- /// \brief deinitialisation runnable /// /// \descr deinitialisation runnable for CodM /// Calling once before go to sleep. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(void, ctaaCodM_CODE) rdCodMDeInit(void) { CodM_DeInit(); } //----------------------------------------------------------------------------- /// \brief cyclic runnable /// /// \descr cyclic runnable for CodM /// Calling cyclicaly every 20 ms. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(void, ctaaCodM_CODE) rpCodM20ms(void) { if(CodM_bIsCodingDataValidated == FALSE) { CodM_bIsCodingDataValidated = TRUE; CodM_Cycle20ms(); if(CodM_CodingValidationCntr == 0u) { CodM_ValidateCodingData(); CodM_CodingValidationCntr = VALIDATION_CYCLE_COUNTER_MAX; } else { CodM_CodingValidationCntr = CodM_CodingValidationCntr - 1u; } } } //----------------------------------------------------------------------------- /// \brief Init Runnables /// /// \descr CodM_IsCodingLabelsCompatible /// Calling at init. /// /// \param void /// /// \return boolean //----------------------------------------------------------------------------- boolean CodM_IsCodingLabelsCompatible(unsigned char* szSrc, unsigned char* szDest) { while (((unsigned char)'\0' != *szSrc) && ((unsigned char)'\0' != *szDest) && (*szSrc == *szDest)) { // PRQA S 1881// program architecture and readability szSrc++; szDest++; } return ((*szSrc - *szDest) == 0u ? TRUE : FALSE); // PRQA S 1863// program architecture and readability } FUNC(Std_ReturnType, ctaaCodM_CODE) roCodMStartCodingDataVerification(void) { if(CodM_bIsCodingDataValidated == FALSE) { CodM_ValidateCodingData(); CodM_Rte_Call_SysMonGetSafetyCodingErrorReason(&CodM_SafetyCodingErrorReason); if ((CodM_boCrcCodingTestResultIsOk == TRUE) && (CodM_SafetyCodingErrorReason == 0xFEu)) { CodM_Rte_Write_CodMFuSaCodingDataStatus(TRUE); } else { CodM_Rte_Write_CodMFuSaCodingDataStatus(FALSE); } CodM_bIsCodingDataValidated = TRUE; } return RTE_E_OK; } STATIC_AL void CodM_ValidateCodingData(void) { /* Deviation fromMISRA-C:2012 rule 11.4, 11.6. Justification: This cast is needed for handling integral values as addresses for device access. */ /* PRQA S 306 2 */ uint32 ulCrcCodingData; unsigned char ucCodingLabels[25] = {(unsigned char)'\0',(unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',(unsigned char)'\0', (unsigned char)'\0',(unsigned char)'\0', (unsigned char)'\0',(unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',(unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0',(unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0', (unsigned char)'\0'};// PRQA S 4414// program architecture and readability uint32* pulCrcCodingExpected = (uint32*)CODING_CRC_ADDRESS; // PRQA S 306// program architecture and readability uint8* pucCrcCodingData = (uint8*)CODING_START_ADDRESS; // PRQA S 306// program architecture and readability uint32 ulExpectedCRC; tieMountingSideRaw pMountingSide = eIoHwAbUser_MountingSideRaw_Unknown; tieResetReason peResetReason = RESET_SNA; tisCddSbcStatus sCddSbcStatus = { 0 }; (void)CodM_Rte_Read_CddSbcStatus(&sCddSbcStatus); //For UT peResetReason = sCddSbcStatus.eResetReason; //(void)Rte_Call_ppaclCddSbcGetResetReason_GetResetReason(&peResetReason); #ifndef UNIT_TEST // Crc_CalculateCRC32: unit test crashes at this point if ((pulCrcCodingExpected != NULL) && (pucCrcCodingData != NULL)) { ulCrcCodingData = Crc_CalculateCRC32P4(pucCrcCodingData, (uint32) (CODING_END_ADDRESS - CODING_START_ADDRESS + 1u), (uint32) 0xFFFFFFFFUL, (boolean) TRUE); ulExpectedCRC = *pulCrcCodingExpected; //Swap Byte order ulExpectedCRC = CY_SWAP_ENDIAN32(ulExpectedCRC); CodM_boCrcCodingTestResultIsOk = (ulCrcCodingData == ulExpectedCRC) ? TRUE : FALSE; //Read Coding Labels (void)Rte_Memcpy(&ucCodingLabels, &(applicationCodingData.CodingLabels[0]), sizeof(ucCodingLabels) - 1u); // PRQA S 1840// program architecture and readability //Compare Coding Labels CodM_bIsCodingLabelsCompatible = CodM_IsCodingLabelsCompatible(ucCodingLabels, CodM_pucCodingLabels); //Check Combined coding validity CodM_boCrcCodingTestResultIsOk &= CodM_bIsCodingLabelsCompatible; //CodM_Rte_Call_SysMonGetSafetyCodingErrorReason(&CodM_SafetyCodingErrorReason); //CodM_boCrcCodingTestResultIsOk &= (( CodM_SafetyCodingErrorReason == 0xFEu) ? TRUE : FALSE); } #else extern uint8 setValue; CodM_boCrcCodingTestResultIsOk = Crc_CalculateCRCTest(setValue); #endif if (CodM_boCrcCodingTestResultIsOk == TRUE) { CodM_Rte_Write_CodMCodingDataStatus(TRUE); //For UT } else { CodM_Rte_Write_CodMCodingDataStatus(FALSE); //For UT } if (CodM_boCrcCodingTestResultIsOk == FALSE || peResetReason == RESET_WATCHDOG) { //(void)Rte_Call_Dtc805a09_SetEventStatus(DEM_EVENT_STATUS_FAILED); } else { //(void)Rte_Call_Dtc805a09_SetEventStatus(DEM_EVENT_STATUS_PASSED); } (void)CodM_Rte_Call_IoHwAbUserGetMountingSideRaw(&pMountingSide); //For UT if(pMountingSide == eIoHwAbUser_MountingSideRaw_Unknown) { //(void)Rte_Call_Dtc805a10_SetEventStatus(DEM_EVENT_STATUS_FAILED); //(void)Rte_Switch_ppCodingConditionMode0_currentConditionMode(RTE_MODE_Coding_ConditionMode_CODING_NOT_ALLOWED); } else { //(void)Rte_Call_Dtc805a10_SetEventStatus(DEM_EVENT_STATUS_PASSED); //(void)Rte_Switch_ppCodingConditionMode0_currentConditionMode(RTE_MODE_Coding_ConditionMode_CODING_ALLOWED); } /* FLM3.MDRS.CodM.252 */ if ((pMountingSide == eIoHwAbUser_MountingSideRaw_Left) && (NVM_MOUNTING_SIDE == NVM_RIGHT) || (pMountingSide == eIoHwAbUser_MountingSideRaw_Right) && (NVM_MOUNTING_SIDE == NVM_LEFT)) { //(void)Rte_Call_Dtc805a17_SetEventStatus(DEM_EVENT_STATUS_FAILED); } else { //(void)Rte_Call_Dtc805a17_SetEventStatus(DEM_EVENT_STATUS_PASSED); } //PRQA S 5324 1 // number of RTE Calls } // -------------- Stop function declarations or definitions. #define ctaaCodM_STOP_SEC_CODE #include "ctaaCodM_MemMap.h" //============================================================================= // End declaration or definitions of functions //=============================================================================