//***************************************************************************** // (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 SysVolt.c /// /// \brief Submodule SysVolt: system operating voltage monitoring /// //------------------------------ile includes //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Project-specific header file includes //----------------------------------------------------------------------------- #include //----------------------------------------------------------------------------- // Standard / system header f #include #include //#include #include //HONGQI_Comment-- #include //HONGQI_Comment-- #include //HONGQI_Comment-- #include #include "Rte_ctasSysVolt.h" /* PRQA S 0857 */ /* MD_MSR_1.1_857 */ //HONGQI_Comment-- #include #include //----------------------------------------------------------------------------- // "define" and "typedef" statements at the module level //----------------------------------------------------------------------------- #define NumOfFanCodingData 4U #define TempDelaytimer 5U #define SYSVOLT_CYCLE_TIME_MS (sint16)20 #define SYSVOLT_LOW_TO_NORMAL_OFFSET 1000U //low voltage to normal voltage offset :normal voltage>9V #define SYSVOLT_HIGH_TO_NORMAL_OFFSET 2000U //high voltage to normal voltage offset:normal voltage<18V #define SYSVOLT_FAILSAFE_DeMature_Time 10U //failsfe de-mature time //----------------------------------------------------------------------------- // Global variable declaration //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- // Types declaration //----------------------------------------------------------------------------- typedef enum teSysVolt_StateMachine_VBat_DTC { SysVolt_StateMachine_VBat_DTC_eLow = 1, SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal = 2, SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow = 3, SysVolt_StateMachine_VBat_DTC_eNormal = 4, SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh = 5, SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal = 6, SysVolt_StateMachine_VBat_DTC_eHigh = 7, SysVolt_StateMachine_VBat_DTC_eUnknown = 0xFFFF } teSysVolt_StateMachine_VBat_DTC; typedef enum teSysVolt_StateMachine_VBat_LedMain { SysVolt_StateMachine_VBat_LedMain_OFF = 1, SysVolt_StateMachine_VBat_LedMain_To_OFF = 2, SysVolt_StateMachine_VBat_LedMain_Remain_ON = 3, SysVolt_StateMachine_VBat_LedMain_To_Switch_ON = 4, SysVolt_StateMachine_VBat_LedMain_Switch_ON = 5, SysVolt_StateMachine_VBat_LedMain_eUnknown = 0xFFFF } teSysVolt_StateMachine_VBat_LedMain; //============================================================================= // Start definitions of uninitialized 8 bit variables //============================================================================= #define ctasSysVolt_START_SEC_VAR_NO_INIT_8 #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. //STATIC_AL uint8 COD_SYS_HighSupply_V; //STATIC_AL uint8 COD_SYS_HighSupply_T; //STATIC_AL uint8 COD_SYS_LowSupply_V; //STATIC_AL uint8 COD_SYS_LowSupply_T; //STATIC_AL uint8 COD_LED_HAUPT_UBAT_MIN_OFF_V; //STATIC_AL uint8 COD_LED_HAUPT_UBAT_MIN_OFF_T; //STATIC_AL uint8 COD_LED_HAUPT_UBAT_MIN_ON_V; //STATIC_AL uint8 COD_LED_HAUPT_UBAT_MIN_ON_T; #ifdef UNIT_TEST STATIC_AL uint8 COD_Fan_Turn_Off_Undervoltage_Level; STATIC_AL uint8 COD_Fan_Turn_On_Off_Delay; STATIC_AL uint8 COD_Fan_Turn_Off_Overvoltage_Level; STATIC_AL uint8 COD_Fan_Turn_On_Undervoltage_Level ; STATIC_AL uint8 COD_Fan_Turn_On_Overvoltage_Level; #endif //STATIC_AL uint8 COD_Fan_Turn_On_Hyst; STATIC_UT_NOINIT(tieDataStatus, ucCodingDataStatus); // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_NO_INIT_8 #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of uninitialized 8 bit variables //============================================================================= //============================================================================= // Start definitions of uninitialized 16 bit variables //============================================================================= #define ctasSysVolt_START_SEC_VAR_NO_INIT_16 #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. //STATIC_AL uint16 SysVolt_SYS_HighSupply_mV; //STATIC_AL sint16 SysVolt_SYS_HighSupply_ms; //STATIC_AL uint16 SysVolt_SYS_LowSupply_mV; //STATIC_AL sint16 SysVolt_SYS_LowSupply_ms; STATIC_AL uint16 SysVolt_SYS_HighSupply_to_Norm_mV; //STATIC_AL sint16 SysVolt_SYS_HighSupply_to_Norm_ms; STATIC_AL uint16 SysVolt_SYS_LowSupply_to_Norm_mV; //STATIC_AL sint16 SysVolt_SYS_LowSupply_to_Norm_ms; //STATIC_AL uint16 SysVolt_LED_HAUPT_UBAT_MIN_OFF_mV; //STATIC_AL sint16 SysVolt_LED_HAUPT_UBAT_MIN_OFF_ms; //STATIC_AL uint16 SysVolt_LED_HAUPT_UBAT_MIN_ON_mV; //STATIC_AL sint16 SysVolt_LED_HAUPT_UBAT_MIN_ON_ms; STATIC_AL sint16 SysVolt_swStatemachine_VBat_DTC_Timeout_ms; STATIC_AL sint16 SysVolt_swStatemachine_VBat_LedMain_Timeout_ms; // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_NO_INIT_16 #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of uninitialized 16 bit variables //============================================================================= //============================================================================= // Start definitions of uninitialized 32 bit variables //============================================================================= #define ctasSysVolt_START_SEC_VAR_NO_INIT_32 #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. STATIC_AL tiu32Voltage_mV SysVolt_VBat; //static uint32 debug_counter; // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_NO_INIT_32 #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of uninitialized 32 bit variables //============================================================================= //============================================================================= // Start definitions of uninitialized boolean variables //============================================================================= #define ctasSysVolt_START_SEC_VAR_NO_INIT_BOOLEAN #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. STATIC_AL boolean FanRemainOn; STATIC_AL boolean FanSwitchOn; STATIC_AL boolean VBatDiagEnable; // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_NO_INIT_BOOLEAN #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of uninitialized boolean variables //============================================================================= //============================================================================= // Start definitions of initialized boolean variables //============================================================================= #define ctasSysVolt_START_SEC_VAR_INIT_BOOLEAN #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. #if (SysVoltReadCodingDataOn == 1) STATIC_UT(boolean, SysVolt_IsCodingDataLoaded, FALSE); #endif // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_INIT_BOOLEAN #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of initialized boolean variables //============================================================================= //============================================================================= // Start definitions of static or uninitialized variables of type of type structures, unions, or arrays //============================================================================= #define ctasSysVolt_START_SEC_VAR_NO_INIT_UNSPECIFIED #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. STATIC_AL tisSysVoltStatus SysVolt_VoltStatus; STATIC_AL tSysVolt_ResultSet SysVolt_Results; // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_NO_INIT_UNSPECIFIED #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of static or uninitialized variables of type of type structures, unions, or arrays //============================================================================= //============================================================================= // Start definitions of static or initialized variables of type of type structures, unions, or arrays //============================================================================= #define ctasSysVolt_START_SEC_VAR_INIT_UNSPECIFIED #include "ctasSysVolt_MemMap.h" // -------------- Start variable definitions. STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_StateMachine_VBat_DTC_CurrentState = SysVolt_StateMachine_VBat_DTC_eUnknown; STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_StateMachine_VBat_LedMain_CurrentState = SysVolt_StateMachine_VBat_LedMain_eUnknown; STATIC_AL tSysVolt_VoltageRangeSet SysVoltLevelFan[] = { // VoltRangeName, unVoltRangeUpperLimit_mV { SysVolt_eLow2, 0 /*[mV]*/ }, { SysVolt_eLow1, 0 /*[mV]*/ }, { SysVolt_eNormal, 0 /*[mV]*/ }, { SysVolt_eHigh1, 0 /*[mV]*/ }, { SysVolt_eHigh2, 0xFFFF /*[mV]*/ } }; STATIC_AL tSysVolt_ConfigsSet SysVolt_Configs[] = { { SysVoltLevelFan, // true values loaded from coding parameters UTIL_COUNTOF(SysVoltLevelFan), // const value set in configuration 0 // &Rte_Call_ctacIoHwAbUser_ppCodingData0_GetFan_Turn_On_Off_Delay } }; // -------------- Stop variable definitions. #define ctasSysVolt_STOP_SEC_VAR_INIT_UNSPECIFIED #include "ctasSysVolt_MemMap.h" //============================================================================= // End definitions of static or initialized variables of type of type structures, unions, or arrays //============================================================================= //STATIC_UT_NOINIT(uint8 , COD_SYS_HighSupply_V ); //STATIC_UT_NOINIT(uint8 , COD_SYS_HighSupply_T ); //STATIC_UT_NOINIT(uint8 , COD_SYS_LowSupply_V ); //STATIC_UT_NOINIT(uint8 , COD_SYS_LowSupply_T ); /* STATIC_UT_NOINIT(uint8 , COD_LED_HAUPT_UBAT_MIN_OFF_V ); STATIC_UT_NOINIT(uint8 , COD_LED_HAUPT_UBAT_MIN_OFF_T ); STATIC_UT_NOINIT(uint8 , COD_LED_HAUPT_UBAT_MIN_ON_V ); STATIC_UT_NOINIT(uint8 , COD_LED_HAUPT_UBAT_MIN_ON_T ); STATIC_UT_NOINIT(uint8 , COD_Fan_Turn_Off_Undervoltage_Level ); STATIC_UT_NOINIT(uint8 , COD_Fan_Turn_Off_Overvoltage_Level ); STATIC_UT_NOINIT(uint8 , COD_Fan_Turn_On_Off_Delay ); STATIC_UT_NOINIT(uint8 , COD_Fan_Turn_On_Hyst ); STATIC_UT_NOINIT(uint16, SysVolt_SYS_HighSupply_mV ); STATIC_UT_NOINIT(sint16, SysVolt_SYS_HighSupply_ms ); STATIC_UT_NOINIT(uint16, SysVolt_SYS_LowSupply_mV ); STATIC_UT_NOINIT(sint16, SysVolt_SYS_LowSupply_ms ); STATIC_UT_NOINIT(uint16, SysVolt_SYS_HighSupply_to_Norm_mV ); //own variable STATIC_UT_NOINIT(sint16, SysVolt_SYS_HighSupply_to_Norm_ms ); //own variable STATIC_UT_NOINIT(uint16, SysVolt_SYS_LowSupply_to_Norm_mV ); //own variable STATIC_UT_NOINIT(sint16, SysVolt_SYS_LowSupply_to_Norm_ms ); //own variable STATIC_UT_NOINIT(uint16, SysVolt_LED_HAUPT_UBAT_MIN_OFF_mV ); STATIC_UT_NOINIT(sint16, SysVolt_LED_HAUPT_UBAT_MIN_OFF_ms ); STATIC_UT_NOINIT(uint16, SysVolt_LED_HAUPT_UBAT_MIN_ON_mV ); STATIC_UT_NOINIT(sint16, SysVolt_LED_HAUPT_UBAT_MIN_ON_ms ); //STATIC_UT_NOINIT(uint16, SysVolt_Fan_Turn_Off_Undervoltage_Level); //STATIC_UT_NOINIT(uint16, SysVolt_Fan_Turn_Off_Overvoltage_Level ); //STATIC_UT_NOINIT(uint16, SysVolt_Fan_Turn_On_Off_Delay ); //STATIC_UT_NOINIT(uint16, SysVolt_Fan_Turn_On_Hyst );*/ //============================================================================= // Start declaration or definitions of functions //============================================================================= #define ctasSysVolt_START_SEC_CODE #include "ctasSysVolt_MemMap.h" // -------------- Start function declarations or definitions. //----------------------------------------------------------------------------- // Function prototypes //----------------------------------------------------------------------------- STATIC_AL void SysVolt_Init(void); //STATIC_AL void SysVolt_DeInit(void); STATIC_AL void SysVolt_Cycle10ms(void); STATIC_AL void SysVolt_CodingValidCycle(void); STATIC_AL void SysVolt_UpdateCoding(void); STATIC_AL void SysVolt_StateMachine_VBat_FAN(void); STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eLow2(void); STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eLow1(void); STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eNormal(void); STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eHigh1(void); STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eHigh2(void); STATIC_AL void SysVolt_StateMachine_VBat_DTC(void); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eHigh(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eLow(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL void SysVolt_StateMachine_VBat_LedMain(void); STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_Switch_ON(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_To_Switch_ON(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_Remain_ON(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_To_OFF(tiu32Voltage_mV ulVBatvoltage_mV); STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_OFF(tiu32Voltage_mV ulVBatvoltage_mV); //----------------------------------------------------------------------------- // Macros //----------------------------------------------------------------------------- FUNC(void, ctasSysVolt_CODE) rdSysVoltDeInit(void) { SysVolt_Results.ePreviousVoltageRange = SysVolt_eUnknown; SysVolt_Results.eVoltageRangeResult = SysVolt_eUnknown; SysVolt_Results.ucDebounceCnt = ZERO; } //----------------------------------------------------------------------------- /// \brief API initialization runnable /// /// \descr Initialization runnable for SysVolt /// Calling once at start up. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(void, ctaaSysVolt_CODE) riSysVoltInit(void) { SysVolt_Init(); } //----------------------------------------------------------------------------- /// \brief API cyclic runnable /// /// \descr cyclic runnable for SysVolt /// Calling cyclically every 10 ms. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(void, ctaaSysVolt_CODE) rpSysVolt10ms(void) { SysVolt_Cycle10ms(); } //----------------------------------------------------------------------------- /// \brief Initialization function for SysVolt /// /// \descr This function is called to determine the voltage range. /// Calling once at start up. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_Init(void) { #if (SysVoltReadCodingDataOn == 1) SysVolt_IsCodingDataLoaded = FALSE; #else SysVolt_UpdateCoding(); // this updates the hard coded coding values #endif SysVolt_Results.ePreviousVoltageRange = SysVolt_eUnknown; SysVolt_Results.eVoltageRangeResult = SysVolt_eUnknown; SysVolt_Results.ucDebounceCnt = ZERO; } //----------------------------------------------------------------------------- /// \brief De-initialization function for SysVolt /// /// \descr SysVolt_DeInit() /// /// \param void /// /// \return void //----------------------------------------------------------------------------- //STATIC_AL void SysVolt_DeInit(void) //{ //} //----------------------------------------------------------------------------- /// \brief Cyclic function for SysVolt /// /// \descr This function is the main function of SysVolt, which receives the /// Vbat value every 10 mseconds and sets flags for each state of the /// voltage value and sends them to the RTE. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_Cycle10ms(void) { #if (SysVoltReadCodingDataOn == 1) // Check coding status SysVolt_Rte_Read_CodingDataStatus_sVal(&ucCodingDataStatus); if(ucCodingDataStatus == FALSE) { //debug_counter++; SysVolt_IsCodingDataLoaded = FALSE; } else { if(SysVolt_IsCodingDataLoaded == FALSE) { SysVolt_UpdateCoding(); SysVolt_IsCodingDataLoaded = TRUE; } else { // essential cyclic function of SysVolt SysVolt_CodingValidCycle(); SysVolt_StateMachine_VBat_FAN(); SysVolt_StateMachine_VBat_DTC(); SysVolt_StateMachine_VBat_LedMain(); } } #else SysVolt_CodingValidCycle(); #endif } //----------------------------------------------------------------------------- /// \brief update coding parameter for SysVolt /// /// \descr copy and convert the coding parameters to SysVolt variables /// /// SYS_HighSupply_V Unit: 0,1 V Values: 0.. 255 (0.. 22,5V) Ueberspannungsfehler: Spannungswert Origin: SG Hersteller /// SYS_HighSupply_T Unit: 0,01 s Values: 0.. 255 (0.. 2,5s) Ueberspannungsfehler: Entprellung Origin: SG Hersteller /// SYS_LowSupply_V Unit: 0,1 V Values: 0.. 255 (0.. 22,5V) Unterspannungsfehler: Spannungswert Origin: SG Hersteller /// SYS_LowSupply_T Unit: 0,01 s Values: 0.. 255 (0.. 2,5s) Unterspannungsfehler: Entprellung Origin: SG Hersteller /// /// LED_HAUPT_UBAT_MIN_OFF_V Unit: 0,1 V Values: 0.. 255 (0.. 25,5 V) Untere Ausschaltschwelle fuer Hauptlichtfunktionen Origin: SG Hersteller /// LED_HAUPT_UBAT_MIN_OFF_T Unit: 1 ms Values: 0.. 255 (0.. 0,25 s) Verzoegerung fuer die untere Ausschaltschwelle (Hauptlichtfunktionen) Origin: SG Hersteller /// LED_HAUPT_UBAT_MIN_ON_V Unit: 0,1 V Values: 0.. 255 (0.. 25,5 V) Untere Einschaltschwelle fuer Hauptlichtfunktionen Origin: SG Hersteller /// LED_HAUPT_UBAT_MIN_ON_T Unit: 1 ms Values: 0.. 255 (0.. 0,25 s) Verzoegerung fuer die untere Einschaltschwelle (Hauptlichtfunktionen) Origin: SG Hersteller /// /// Fan_Turn_Off_Undervoltage_Level Unit: 0,1V Values: 0..255 (0.. 25,5 V) Luefter schaltet ab, wenn Klemme 30 unterhalb dieses Schwellwertes liegt, fuer die Entprellzeit: Fan_Turn_On_Off_Delay. Origin: BMW /// Fan_Turn_Off_Overvoltage_Level Unit: 0,1V Values: 0..255 (0.. 25,5 V) Origin: BMW /// Fan_Turn_On_Off_Delay Unit: 20ms Values: 0..15 (0.. 300 ms) Origin: BMW /// Fan_Turn_On_Hyst Unit: 200mV Values: 0..15 (0.. 3 V) Origin: BMW /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_UpdateCoding(void) { #if (SysVoltReadCodingDataOn == 1) //COD_SYS_HighSupply_V = applicationCodingData.System.SystemData.SYS_HighSupply_V; //COD_SYS_HighSupply_T = applicationCodingData.System.SystemData.SYS_HighSupply_T; //COD_SYS_LowSupply_V = applicationCodingData.System.SystemData.SYS_LowSupply_V; //COD_SYS_LowSupply_T = applicationCodingData.System.SystemData.SYS_LowSupply_T; #ifdef UNIT_TEST COD_Fan_Turn_Off_Undervoltage_Level = applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_OFF_V_MIN; COD_Fan_Turn_Off_Overvoltage_Level = applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_OFF_V_MAX; COD_Fan_Turn_On_Undervoltage_Level = applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_ON_V_MIN; COD_Fan_Turn_On_Overvoltage_Level = applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_ON_V_MAX; COD_Fan_Turn_On_Off_Delay = applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_OFF_T_MAX; #endif //calculate and set values for the statemachines //SysVolt_SYS_HighSupply_mV = (uint16) COD_SYS_HighSupply_V * 100U ; //SysVolt_SYS_HighSupply_ms = (sint16)((sint16)COD_SYS_HighSupply_T * (sint16)10U); //SysVolt_SYS_LowSupply_mV = (uint16) COD_SYS_LowSupply_V * 100U ; //SysVolt_SYS_LowSupply_ms = (sint16)((sint16)COD_SYS_LowSupply_T * (sint16)10U); //TODO: calculate the values based on the coded values to guarantee hysteresis, and avoid problems based on faulty coding SysVolt_SYS_HighSupply_to_Norm_mV = (uint16)(((uint32)applicationCodingData.System.SystemData.SYS_HighSupply_V * 100U) - SYSVOLT_HIGH_TO_NORMAL_OFFSET);//(uint16)17500U; //SysVolt_SYS_HighSupply_to_Norm_ms = (sint16)300U; SysVolt_SYS_LowSupply_to_Norm_mV = (uint16)(((uint32)applicationCodingData.System.SystemData.SYS_LowSupply_V * 100U) + SYSVOLT_LOW_TO_NORMAL_OFFSET);// (uint16)9000U; //SysVolt_SYS_LowSupply_to_Norm_ms = (sint16)300U; //COD_LED_HAUPT_UBAT_MIN_ON_V = applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_V; //COD_LED_HAUPT_UBAT_MIN_ON_T = applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_T; //COD_LED_HAUPT_UBAT_MIN_OFF_V = applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_OFF_V; //COD_LED_HAUPT_UBAT_MIN_OFF_T = applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_OFF_T; //SysVolt_LED_HAUPT_UBAT_MIN_ON_mV = (uint16) COD_LED_HAUPT_UBAT_MIN_ON_V * 100U ; //SysVolt_LED_HAUPT_UBAT_MIN_ON_ms = (sint16)((sint16)COD_LED_HAUPT_UBAT_MIN_ON_T); //SysVolt_LED_HAUPT_UBAT_MIN_OFF_mV = (uint16) COD_LED_HAUPT_UBAT_MIN_OFF_V * 100U ; //SysVolt_LED_HAUPT_UBAT_MIN_OFF_ms = (sint16)((sint16)COD_LED_HAUPT_UBAT_MIN_OFF_T); #ifdef UNIT_TEST // correct the implausible values read from coding if(COD_Fan_Turn_Off_Undervoltage_Level == 0U) { COD_Fan_Turn_Off_Undervoltage_Level = 70U; } if(COD_Fan_Turn_Off_Overvoltage_Level == 0U) { COD_Fan_Turn_Off_Overvoltage_Level = 180U; } if(COD_Fan_Turn_On_Off_Delay == 0U) { COD_Fan_Turn_On_Off_Delay = TempDelaytimer; // = 5 * 10ms } #endif #ifndef UNIT_TEST SysVolt_Configs[0].pRangeCfg[0].ucVoltRangeUpperLimit_mV = (uint16)( (uint16)(applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_OFF_V_MIN)/*COD_Fan_Turn_Off_Undervoltage_Level */* (uint16)100U); SysVolt_Configs[0].pRangeCfg[1].ucVoltRangeUpperLimit_mV = (uint16)( ( applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_ON_V_MIN)/*COD_Fan_Turn_On_Undervoltage_Level*/ * (uint16)100U); SysVolt_Configs[0].pRangeCfg[2].ucVoltRangeUpperLimit_mV = (uint16)((applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_ON_V_MAX)/*COD_Fan_Turn_On_Overvoltage_Level*/* (uint16)100U); SysVolt_Configs[0].pRangeCfg[3].ucVoltRangeUpperLimit_mV = (uint16)( (uint16)(applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_OFF_V_MAX)/*COD_Fan_Turn_Off_Overvoltage_Level */ * (uint16)100U); SysVolt_Configs[0].ucDebounceCnt = ( uint8)((applicationCodingData.Fan1.FAN_SUPPLY[0].ucFAN_SUPPLY_OFF_T_MAX)/*(COD_Fan_Turn_On_Off_Delay)*//10u); #else SysVolt_Configs[0].pRangeCfg[0].ucVoltRangeUpperLimit_mV = (uint16)( (uint16)COD_Fan_Turn_Off_Undervoltage_Level * (uint16)100U); SysVolt_Configs[0].pRangeCfg[1].ucVoltRangeUpperLimit_mV = (uint16)( COD_Fan_Turn_On_Undervoltage_Level * (uint16)100U); SysVolt_Configs[0].pRangeCfg[2].ucVoltRangeUpperLimit_mV = (uint16)(COD_Fan_Turn_On_Overvoltage_Level* (uint16)100U); SysVolt_Configs[0].pRangeCfg[3].ucVoltRangeUpperLimit_mV = (uint16)( (uint16)COD_Fan_Turn_Off_Overvoltage_Level * (uint16)100U); SysVolt_Configs[0].ucDebounceCnt = ( uint8)((COD_Fan_Turn_On_Off_Delay)/10u); #endif #else //without the final implementation of coding, we use hard-coded values SysVolt_Configs[0].pRangeCfg[0].ucVoltRangeUpperLimit_mV = 6000U; SysVolt_Configs[0].pRangeCfg[1].ucVoltRangeUpperLimit_mV = 7000U; SysVolt_Configs[0].pRangeCfg[2].ucVoltRangeUpperLimit_mV = 19000U; SysVolt_Configs[0].pRangeCfg[3].ucVoltRangeUpperLimit_mV = 19500U; SysVolt_Configs[0].ucDebounceCnt = TempDelaytimer; #endif // PRQA S 5324 1 // STCAL suppression: This function cannot be feasibly simplified } //----------------------------------------------------------------------------- /// \brief main functionality for SysVolt only called when coding ok /// /// \descr cyclic function of SysVolt which is only called when the coding is /// valid. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_CodingValidCycle(void) { uint8 ucIdx; tiu32Voltage_mV ulVBatvoltage; teSysVolt_Results eNewVoltageRange; SysVolt_Rte_Read_IoHwAbUserEcuSupply0_ulActualMin(&SysVolt_VBat); ulVBatvoltage = SysVolt_VBat; if (ulVBatvoltage < VBAT_DIAG_VOLTAGE) { VBatDiagEnable = FALSE; } else { VBatDiagEnable = TRUE; } SysVolt_VoltStatus.boErrorDiagEnabled = VBatDiagEnable; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } //----------------------------------------------------------------------------- /// \brief Statemachine for FAN /// /// \descr This cyclic function is called to determine the FAN: /// overvoltage and undervoltage /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_StateMachine_VBat_FAN(void) { uint8 ucIdx; tiu32Voltage_mV ulVBatvoltage; teSysVolt_Results eNewVoltageRange; SysVolt_Rte_Read_IoHwAbUserEcuSupply0_ulActualMin(&SysVolt_VBat); ulVBatvoltage = SysVolt_VBat; for (ucIdx = 0; ucIdx < SysVolt_Configs[0].ucNumOfRanges; ucIdx++) { if (ulVBatvoltage < SysVolt_Configs[0].pRangeCfg[ucIdx].ucVoltRangeUpperLimit_mV) { eNewVoltageRange = SysVolt_Configs[0].pRangeCfg[ucIdx].VoltRangeName; SysVolt_Results.eVoltageRangeResult = SysVolt_Configs[0].pRangeCfg[ucIdx].VoltRangeName; break; } } switch (eNewVoltageRange) { case SysVolt_eLow2: SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eLow2(); break; case SysVolt_eLow1: SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eLow1(); break; case SysVolt_eNormal: SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eNormal(); break; case SysVolt_eHigh1: SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eHigh1(); break; case SysVolt_eHigh2: SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eHigh2(); break; default: break; } } //----------------------------------------------------------------------------- /// \brief Statemachine worker function /// /// \descr SysVolt LOW2 state /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eLow2(void) { if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eLow1) { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_Results.eVoltageRangeResult) { if (SysVolt_Results.ucDebounceCnt != ZERO && FanRemainOn != FALSE) { SysVolt_Results.ucDebounceCnt--; if (SysVolt_Results.ucDebounceCnt == ZERO) { FanRemainOn = FALSE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } } } else { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; if (FanSwitchOn == TRUE) { FanSwitchOn = FALSE; SysVolt_VoltStatus.boFanSwitchOn = FanSwitchOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } } SysVolt_Results.ePreviousVoltageRange = SysVolt_Results.eVoltageRangeResult; } //----------------------------------------------------------------------------- /// \brief Statemachine worker function /// /// \descr SysVolt LOW1 state /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eLow1(void) { if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eLow2) { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eNormal) { FanSwitchOn = FALSE; SysVolt_VoltStatus.boFanSwitchOn = FanSwitchOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_Results.eVoltageRangeResult) { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } else { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } SysVolt_Results.ePreviousVoltageRange = SysVolt_Results.eVoltageRangeResult; } //----------------------------------------------------------------------------- /// \brief Statemachine worker function /// /// \descr SysVolt NORMAL state /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eNormal(void) { if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eLow1) { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eHigh1) { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_Results.eVoltageRangeResult) { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); if (SysVolt_Results.ucDebounceCnt != ZERO && FanSwitchOn != TRUE) { SysVolt_Results.ucDebounceCnt--; if (SysVolt_Results.ucDebounceCnt == ZERO) { FanSwitchOn = TRUE; SysVolt_VoltStatus.boFanSwitchOn = FanSwitchOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } } } else { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; if (FanRemainOn == FALSE) { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } } SysVolt_Results.ePreviousVoltageRange = SysVolt_Results.eVoltageRangeResult; // PRQA S 5336 1 // STMIF suppression: intentionally not modified, reuse of existing code } //----------------------------------------------------------------------------- /// \brief Statemachine worker function /// /// \descr SysVolt HIGH1 state /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eHigh1(void) { if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eNormal) { FanSwitchOn = FALSE; SysVolt_VoltStatus.boFanSwitchOn = FanSwitchOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eHigh2) { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_Results.eVoltageRangeResult) { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } else { FanRemainOn = TRUE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } SysVolt_Results.ePreviousVoltageRange = SysVolt_Results.eVoltageRangeResult; } //----------------------------------------------------------------------------- /// \brief Statemachine worker function /// /// \descr SysVolt HIGH2 state /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_ProcessState_SysVolt_StateMachine_VoltageRanges_SysVolt_eHigh2(void) { if (SysVolt_Results.ePreviousVoltageRange == SysVolt_eHigh1) { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; } else if (SysVolt_Results.ePreviousVoltageRange == SysVolt_Results.eVoltageRangeResult) { if (SysVolt_Results.ucDebounceCnt != ZERO && FanRemainOn != FALSE) { SysVolt_Results.ucDebounceCnt--; if (SysVolt_Results.ucDebounceCnt == ZERO) { FanRemainOn = FALSE; SysVolt_VoltStatus.boFanRemainOn = FanRemainOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } } } else { SysVolt_Results.ucDebounceCnt = SysVolt_Configs[0].ucDebounceCnt; if (FanSwitchOn == TRUE) { FanSwitchOn = FALSE; SysVolt_VoltStatus.boFanSwitchOn = FanSwitchOn; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); } } SysVolt_Results.ePreviousVoltageRange = SysVolt_Results.eVoltageRangeResult; } //----------------------------------------------------------------------------- /// \brief Statemachine for DTC /// /// \descr This cyclic function is called to determine the DTCs: /// overvoltage and undervoltage /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_StateMachine_VBat_DTC(void) { tiu32Voltage_mV ulVBatvoltage_mV; teSysVolt_StateMachine_VBat_DTC newState = SysVolt_StateMachine_VBat_DTC_CurrentState; SysVolt_Rte_Read_IoHwAbUserEcuSupply0_ulActualMean(&SysVolt_VBat); ulVBatvoltage_mV = SysVolt_VBat; switch (SysVolt_StateMachine_VBat_DTC_CurrentState) { case SysVolt_StateMachine_VBat_DTC_eHigh: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eHigh(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eNormal: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eLow: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eLow(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_DTC_eUnknown: //fallthru default: newState = SysVolt_StateMachine_VBat_DTC_eNormal; break; } SysVolt_StateMachine_VBat_DTC_CurrentState = newState; // PRQA S 5324 1 // STCAL suppression: This function cannot be feasibly simplified } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC HIGH state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eHigh(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eHigh; if(ulVBatvoltage_mV < SysVolt_SYS_HighSupply_to_Norm_mV) { SysVolt_swStatemachine_VBat_DTC_Timeout_ms = SYSVOLT_FAILSAFE_DeMature_Time; retVal = SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal; } else { retVal = SysVolt_StateMachine_VBat_DTC_eHigh; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC NORMAL to HIGH transition state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh; if(ulVBatvoltage_mV <(((uint32) applicationCodingData.System.SystemData.SYS_HighSupply_V * 100U)) /*SysVolt_SYS_HighSupply_mV*/) { retVal = SysVolt_StateMachine_VBat_DTC_eNormal; } else if (SysVolt_swStatemachine_VBat_DTC_Timeout_ms == 0) { //DTC_HIGH_VOLTAGE_FAIL; SysVolt_VoltStatus.sSupplyVoltStatus.eVoltSts = 5U; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_DTC_eHigh; } else { SysVolt_swStatemachine_VBat_DTC_Timeout_ms -= 1; retVal = SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC HIGH to NORMAL transition state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal; if(SysVolt_SYS_HighSupply_to_Norm_mV < ulVBatvoltage_mV) { retVal = SysVolt_StateMachine_VBat_DTC_eHigh; } else if(SysVolt_swStatemachine_VBat_DTC_Timeout_ms == 0)//<= (sint16)((sint16)applicationCodingData.System.SystemData.SYS_HighSupply_T * (sint16)10U)/*SysVolt_SYS_HighSupply_ms*/) { //DTC_HIGH_VOLTAGE_PASS; SysVolt_VoltStatus.sSupplyVoltStatus.eVoltSts= 1U; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus*)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_DTC_eNormal; } else { SysVolt_swStatemachine_VBat_DTC_Timeout_ms -= 1;// (sint16)((sint16)applicationCodingData.System.SystemData.SYS_HighSupply_T * (sint16)10U)/*SysVolt_SYS_HighSupply_ms*/; retVal = SysVolt_StateMachine_VBat_DTC_eHigh_to_eNormal; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC NORMAL state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eNormal; if(ulVBatvoltage_mV < ((uint32)applicationCodingData.System.SystemData.SYS_LowSupply_V * 100U )/*SysVolt_SYS_LowSupply_mV*/) { SysVolt_swStatemachine_VBat_DTC_Timeout_ms = ((sint16)((sint16)applicationCodingData.System.SystemData.SYS_LowSupply_T * (sint16)10U))/*SysVolt_SYS_LowSupply_ms*/; retVal = SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow; } else if(/*SysVolt_SYS_HighSupply_mV*/( (uint32)applicationCodingData.System.SystemData.SYS_HighSupply_V *100u) < ulVBatvoltage_mV) { SysVolt_swStatemachine_VBat_DTC_Timeout_ms = (sint16)((sint16)applicationCodingData.System.SystemData.SYS_HighSupply_T * (sint16)10U)/*SysVolt_SYS_HighSupply_ms*/; retVal = SysVolt_StateMachine_VBat_DTC_eNormal_to_eHigh; } else { retVal = SysVolt_StateMachine_VBat_DTC_eNormal; SysVolt_VoltStatus.sSupplyVoltStatus.eVoltSts = NORMAL_VOLTAGE; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC NORMAL to LOW transition state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow; if(/*SysVolt_SYS_LowSupply_mV*/((uint32) applicationCodingData.System.SystemData.SYS_LowSupply_V * 100U ) < ulVBatvoltage_mV) { retVal = SysVolt_StateMachine_VBat_DTC_eNormal; } else if(SysVolt_swStatemachine_VBat_DTC_Timeout_ms == 0)//<= ((sint16)((sint16)applicationCodingData.System.SystemData.SYS_LowSupply_T * (sint16)10U))/*SysVolt_SYS_LowSupply_ms*/) { //DTC_LOW_VOLTAGE_FAIL; SysVolt_VoltStatus.sSupplyVoltStatus.eVoltSts = UNDER_VOLTAGE_L1; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus*)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_DTC_eLow; } else { SysVolt_swStatemachine_VBat_DTC_Timeout_ms -= 1;// ((sint16)((sint16)applicationCodingData.System.SystemData.SYS_LowSupply_T * (sint16)10U))/*SysVolt_SYS_LowSupply_ms*/; retVal = SysVolt_StateMachine_VBat_DTC_eNormal_to_eLow; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC LOW to NORMAL transition state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal; if(ulVBatvoltage_mV < SysVolt_SYS_LowSupply_to_Norm_mV) { retVal = SysVolt_StateMachine_VBat_DTC_eLow; } else if(SysVolt_swStatemachine_VBat_DTC_Timeout_ms == 0)//<= ((sint16)((sint16)applicationCodingData.System.SystemData.SYS_LowSupply_T * (sint16)10U))/*SysVolt_SYS_LowSupply_ms*/) { //DTC_LOW_VOLTAGE_PASS; SysVolt_VoltStatus.sSupplyVoltStatus.eVoltSts = NORMAL_VOLTAGE; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus*)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_DTC_eNormal; } else { SysVolt_swStatemachine_VBat_DTC_Timeout_ms -= 1;// ((sint16)((sint16)applicationCodingData.System.SystemData.SYS_LowSupply_T * (sint16)10U))/*SysVolt_SYS_LowSupply_ms*/; retVal = SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine DTC worker function /// /// \descr SysVolt DTC LOW state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_DTC SysVolt_ProcessState_SysVolt_StateMachine_VBat_DTC_eLow(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_DTC retVal = SysVolt_StateMachine_VBat_DTC_eLow; if(SysVolt_SYS_LowSupply_to_Norm_mV < ulVBatvoltage_mV) { SysVolt_swStatemachine_VBat_DTC_Timeout_ms = SYSVOLT_FAILSAFE_DeMature_Time; retVal = SysVolt_StateMachine_VBat_DTC_eLow_to_eNormal; } else { retVal = SysVolt_StateMachine_VBat_DTC_eLow; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine for Led main function /// /// \descr This cyclic function is called to determine the Led main function: /// Switch on (enable / disable) /// Remain on (enable / disable) /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void SysVolt_StateMachine_VBat_LedMain(void) { tiu32Voltage_mV ulVBatvoltage_mV; teSysVolt_StateMachine_VBat_LedMain newState = SysVolt_StateMachine_VBat_LedMain_CurrentState; //HONGQI_Comment-- (void)Rte_Read_ppIoHwAbUserEcuSupply0_ulActualMean(&SysVolt_VBat); ulVBatvoltage_mV = SysVolt_VBat; switch (SysVolt_StateMachine_VBat_LedMain_CurrentState) { case SysVolt_StateMachine_VBat_LedMain_Switch_ON: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_Switch_ON(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_LedMain_To_Switch_ON: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_To_Switch_ON(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_LedMain_Remain_ON: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_Remain_ON(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_LedMain_To_OFF: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_To_OFF(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_LedMain_OFF: newState = SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_OFF(ulVBatvoltage_mV); break; case SysVolt_StateMachine_VBat_LedMain_eUnknown: //fallthru default: newState = SysVolt_StateMachine_VBat_LedMain_OFF; break; } SysVolt_StateMachine_VBat_LedMain_CurrentState = newState; } //----------------------------------------------------------------------------- /// \brief Statemachine Led main worker function /// /// \descr SysVolt Led main SWITCH_ON state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_Switch_ON(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_LedMain retVal = SysVolt_StateMachine_VBat_LedMain_Switch_ON; if(ulVBatvoltage_mV <((uint32)(applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_V) * 100U)/* SysVolt_LED_HAUPT_UBAT_MIN_ON_mV*/) { retVal = SysVolt_StateMachine_VBat_LedMain_Remain_ON; } else { SysVolt_VoltStatus.sLedVoltStatus.eVoltSts = NORMAL_VOLTAGE; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_LedMain_Switch_ON; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine Led main worker function /// /// \descr SysVolt Led main transition to SWITCH_ON state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_To_Switch_ON(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_LedMain retVal = SysVolt_StateMachine_VBat_LedMain_To_Switch_ON; if(ulVBatvoltage_mV < ((uint32)(applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_V) * 100U)/*SysVolt_LED_HAUPT_UBAT_MIN_ON_mV*/) { retVal = SysVolt_StateMachine_VBat_LedMain_Remain_ON; } else if(SysVolt_swStatemachine_VBat_LedMain_Timeout_ms == 0)// <= SysVolt_LED_HAUPT_UBAT_MIN_ON_ms) { //SYSVOLT_LED_MAINFUNCTION_SW_ON; SysVolt_VoltStatus.sLedVoltStatus.eVoltSts = NORMAL_VOLTAGE; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_LedMain_Switch_ON; } else { SysVolt_swStatemachine_VBat_LedMain_Timeout_ms --;//= SysVolt_LED_HAUPT_UBAT_MIN_ON_ms; retVal = SysVolt_StateMachine_VBat_LedMain_To_Switch_ON; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine Led main worker function /// /// \descr SysVolt Led main REMAIN_ON state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_Remain_ON(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_LedMain retVal = SysVolt_StateMachine_VBat_LedMain_Remain_ON; if (/*SysVolt_LED_HAUPT_UBAT_MIN_ON_mV */((uint32)(applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_V) * 100U)< ulVBatvoltage_mV) { SysVolt_swStatemachine_VBat_LedMain_Timeout_ms = ((sint16)((sint16)applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_T))/*SysVolt_LED_HAUPT_UBAT_MIN_ON_ms*/; retVal = SysVolt_StateMachine_VBat_LedMain_To_Switch_ON; } else if(ulVBatvoltage_mV < /*SysVolt_LED_HAUPT_UBAT_MIN_OFF_mV*/((uint32) (applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_OFF_V) * 100U)) { SysVolt_swStatemachine_VBat_LedMain_Timeout_ms = ((sint16)((sint16)applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_OFF_T))/*SysVolt_LED_HAUPT_UBAT_MIN_OFF_ms*/; retVal = SysVolt_StateMachine_VBat_LedMain_To_OFF; } else { //retVal = SysVolt_StateMachine_VBat_LedMain_Remain_ON; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine Led main worker function /// /// \descr SysVolt Led main transition to OFF state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_To_OFF(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_LedMain retVal = SysVolt_StateMachine_VBat_LedMain_To_OFF; if (/*SysVolt_LED_HAUPT_UBAT_MIN_OFF_mV*/((uint32)(applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_OFF_V) * 100U) < ulVBatvoltage_mV) { retVal = SysVolt_StateMachine_VBat_LedMain_Remain_ON; } else if (SysVolt_swStatemachine_VBat_LedMain_Timeout_ms == 0)// ((sint16)((sint16)applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_T))/*SysVolt_LED_HAUPT_UBAT_MIN_ON_ms*/) { retVal = SysVolt_StateMachine_VBat_LedMain_OFF; } else { SysVolt_swStatemachine_VBat_LedMain_Timeout_ms --; // = ((sint16)((sint16)applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_OFF_T))/*SysVolt_LED_HAUPT_UBAT_MIN_OFF_ms*/; retVal = SysVolt_StateMachine_VBat_LedMain_To_OFF; } return retVal; } //----------------------------------------------------------------------------- /// \brief Statemachine Led main worker function /// /// \descr SysVolt Led main OFF state /// /// \param Voltage mV /// /// \return void //----------------------------------------------------------------------------- STATIC_AL teSysVolt_StateMachine_VBat_LedMain SysVolt_ProcessState_SysVolt_StateMachine_VBat_LedMain_OFF(tiu32Voltage_mV ulVBatvoltage_mV) { teSysVolt_StateMachine_VBat_LedMain retVal = SysVolt_StateMachine_VBat_LedMain_OFF; if(/*SysVolt_LED_HAUPT_UBAT_MIN_OFF_mV*/((uint32) (applicationCodingData.Led1.LedSupplyVoltage.LED_VBAT_MIN_ON_V) * 100U) < ulVBatvoltage_mV) { retVal = SysVolt_StateMachine_VBat_LedMain_Remain_ON; } else { SysVolt_VoltStatus.sLedVoltStatus.eVoltSts = UNDER_VOLTAGE_L3; SysVolt_Rte_Write_SysVoltStatus((const tisSysVoltStatus *)&SysVolt_VoltStatus); retVal = SysVolt_StateMachine_VBat_LedMain_OFF; } return retVal; } // -------------- Stop function declarations or definitions. #define ctasSysVolt_STOP_SEC_CODE #include "ctasSysVolt_MemMap.h" //============================================================================= // End declaration or definitions of functions //=============================================================================