//***************************************************************************** // (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 CtrlLed.c /// /// \brief The software component CtrlLed can be initialized from the RTE. /// All monitor counters, values and timers will be initialized during /// initialization. /// The RTE call CtrlLed cyclicaly. In each cycle call CTrlLed performs /// ramping and applies /// gamma correction for each LED channel /// //----------------------------------------------------------------------------- #include #include #include #include #include #include #include #include #include #include #include #include #include "Bsw_Common.h" //PRQA S 5310, 5316, 5324, 5334, 5336, 5338 EOF //Program Architecture and CodeReadability //#include // for Simulink code that is generated with TargetLink //#define BUCK_ERROR_CHECK //#define LMM_ERROR_CHECK #define CONV_LSB_1_328_U16(var) (uint16)((uint16)(var) * 328u) #define CONV_LSB_1_328_U32(var) (uint32)((uint32)(var) * 328u) // base_pwm is [0.5%] #define CONV_TO_BASE_PWM(pwm, base_pwm) (uint16)((uint16)(pwm) * \ CONV_LSB_1_328_U16((unsigned)(base_pwm) >> 1u) / CONV_LSB_1_328_U16(100u)); #define CONV_LWR_RAW_2_ANGLE(var) (sint16)(100 * (((var) / 10u) - 10)) // start bit handling #define CHECK_BIT(var, bitPos) (((var) & ((unsigned)1u << (bitPos))) == ((unsigned)1u << (bitPos)) ? TRUE : FALSE) #define SET_BIT(var, bitPos) ((var) |= ((unsigned)1u << (bitPos))) #define CLEAR_BIT(var, bitPos) ((var) &= ~(1u << (bitPos))) #define ANY_OTHER_BIT(var, bitPos) (((var) | ~(1u << (bitPos))) != 0) // end bit handling #define DRV_ERR_STAT(var) ((((var).eErrOpenLoad == ERR_YES) || ((var).eErrShortToGnd == ERR_YES) || ((var).eErrShortToSupply == ERR_YES) || ((var).eErrVLedOutOfTolerance == ERR_YES) || ((var).eErrDrvThermalShutdown == ERR_YES)) ? TRUE : FALSE) #define BYPASS_ERR_STAT(var) ((var).eErrSwitchOpen == ERR_YES) typedef struct { tiu16Percent_1_328 unBrightness; tiu16TimeDiff_ms unRampTimeUp; tiu16TimeDiff_ms unRampTimeDown; tiu8Priority ucPriority; } tisAnimMaTarget; typedef tisAnimMaTarget tisAnimMaTargetArr[ANIMMA_NR_PIXELS]; //============================================================================= // inline functions //============================================================================= //----------------------------------------------------------------------------- // Start definitions of arrays and structures //----------------------------------------------------------------------------- #define ctasLedR_START_SEC_VAR_INIT_UNSPECIFIED #include "LedR_MemMap.h" //----------------------------------------------------------------------------- // Static variable declarations //----------------------------------------------------------------------------- #define ANIMATION_SEGMENT_NUM 81u uint8 CtrlLed_MountingSide = 0u; uint8 Segmentmapping[12] = { 0,1,2,3,4,5,6,7,8,9,10,11 }; uint8 CornerLightControlto2F = 0u; uint16 ADBMatrixContro2F = 0u; uint16 ucADBMatrixContro2F = 0u; uint16 utADBMatrixContro2F = 0u; uint16 ADB2FSegments = 0u; uint8 FlagtoControl2F = 0u; static uint8 AnimActiveSts = CTRLLED_ANIM_INACTIVE; uint8 AnimCompleteSts = CTRLLED_ANIM_STS_OFF; static tisBreatheReq CtrlLed_BreathSts; // ramping data for each channel -> illuminants + PXA part static ISV_STEST3_tp CtrlLed_Ramp[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS + LEDR_CFG_MATRIX_NO_OF_SEGMENTS] = { 0 }; // X axis points for each gamma curve - H_OPT // LSB: 0.5 STATIC_AL uint16 Gamma_X[LEDR_CFG_NO_OF_GAMMA_CURVES][LEDR_CFG_GAMMA_CURVE_POINTS_NO] = { // first (0%) and last point (100%) are not given by the coding { 0u, 0x800u, 0x1000u, 0x1800u, 0x2000u, 0x2800u, 0x3000u, 0x3800u, 0x4000u, 0x4800u, 0x5000u, 0x5800u, 0x6000u, 0x6800u, 0x7000u, 0x7800u, 0x8000u }, { 0u, 0x800u, 0x1000u, 0x1800u, 0x2000u, 0x2800u, 0x3000u, 0x3800u, 0x4000u, 0x4800u, 0x5000u, 0x5800u, 0x6000u, 0x6800u, 0x7000u, 0x7800u, 0x8000u }, }; // Y axis points for each gamma curve - PWM // LSB: 0.5 STATIC_AL uint16 Gamma_Y[LEDR_CFG_NO_OF_GAMMA_CURVES][LEDR_CFG_GAMMA_CURVE_POINTS_NO] = { // first (0%) and last point (100%) are not given by the coding #ifdef UNIT_TEST {33, 41, 97, 249, 545, 1032, 1759, 2774, 4125, 5859, 8025, 10670, 13843, 17591, 21963, 27006, 32768}, {33, 41, 97, 249, 545, 1032, 1759, 2774, 4125, 5859, 8025, 10670, 13843, 17591, 21963, 27006, 32768} #else {33, 41, 97, 249, 545, 1032, 1759, 2774, 4125, 5859, 8025, 10670, 13843, 17591, 21963, 27006, 32768}, {33, 41, 97, 249, 545, 1032, 1759, 2774, 4125, 5859, 8025, 10670, 13843, 17591, 21963, 27006, 32768} #endif }; static tCtrlLed_LogicalChannel LS_X[LEDR_CFG_NO_OF_SINGLE_UNITS] = { 0u }; static uint16 CtrlLed_TurnIndDebounce = 0; static bool AnimMaStartFlag = false; //CtrlLed_LMMRampGamma static uint8 CtrlLed_aucLMMPrio[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS] = LEDR_CFG_LSM_DEFAULT_PRIO; static uint8 CtrlLed_ucAnimation_prev[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS] = { 0u }; //CtrlLed_AnimaRamp STATIC_AL tiu16Percent_1_328 CtrlLed_aunAnimaRamp[ANIMMA_NR_PIXELS] = { 0u }; //CtrlLed_PxaRampGama static uint8 CtrlLed_aucPXAPrio[LEDR_CFG_MATRIX_NO_OF_SEGMENTS] = { 0u }; //CtrlLed_Cyclic10ms static tCtrlLed_PXAData CtrlLed_aunPXA_DutyCycle[LEDR_CFG_MATRIX_NO_OF_SEGMENTS] = { 0u }; static tCtrlLed_LMMData CtrlLed_aunLMM_DutyCycle[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS] = { 0u }; STATIC_AL tiu16Percent_1_328 CtrlLed_aunAnima_DutyCycle[ANIMMA_NR_PIXELS] = { 0u }; //----------------------------------------------------------------------------- // Stop definitions of arrays and structures //----------------------------------------------------------------------------- #define ctasLedR_STOP_SEC_VAR_INIT_UNSPECIFIED #include "LedR_MemMap.h" #define ctasLedR_START_SEC_VAR_INIT_8 #include "LedR_MemMap.h" static tieDataStatus codDataStat_prev = tieDataStatus_Invalid; #define ctasLedR_STOP_SEC_VAR_INIT_8 #include "LedR_MemMap.h" #define ctasLedR_START_SEC_VAR_INIT_32 #include "LedR_MemMap.h" static uint32 anima_counter = 0U; //-- counter scheduler, for the AnimMa50 #define ctasLedR_STOP_SEC_VAR_INIT_32 #include "LedR_MemMap.h" #define ctasLedR_START_SEC_VAR_NO_INIT_UNSPECIFIED #include "LedR_MemMap.h" #define ctasLedR_STOP_SEC_VAR_NO_INIT_UNSPECIFIED #include "LedR_MemMap.h" //----------------------------------------------------------------------------- // Start declaration or definitions of functions //----------------------------------------------------------------------------- #define ctasLedR_START_SEC_CODE #include "LedR_MemMap.h" //----------------------------------------------------------------------------- // Function prototypes //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_Init(void); STATIC_AL void CtrlLed_Cycle10ms(void); STATIC_AL void CtrlLed_CodingDataValidation(void); STATIC_AL uint16 CtrlLed_Ramping(uint16 unRequested_HOpt, uint16 unRequested_time, uint8 ucRampType, ISV_STEST3_tp* pISV); STATIC_AL void CtrlLed_LMMControlOverLS(tCtrlLed_LMMData aunLMM_DutyCycle[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS]); STATIC_AL void CtrlLed_PXARampGamma(tCtrlLed_PXAData(*aunPXA_DutyCycle)[LEDR_CFG_MATRIX_NO_OF_SEGMENTS]); STATIC_AL void CtrlLed_LMMRampGamma(tCtrlLed_LMMData(*aunLMM_DutyCycle)[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS], CtrlLed_tisLsTarget_perc(*ppCtrlLedLsTarget0_asSetting)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], uint8(*aunAnimationDetection)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]); STATIC_AL void CtrlLed_AnimMaRamp(tiu16Percent_1_328(*aunAnima_DutyCycle)[ANIMMA_NR_PIXELS]); STATIC_AL void CtrlLed_Update(CtrlLed_tisLsTarget_perc(*ppCtrlLedLsTarget0_asSetting)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], tiu16Percent_1_328(*ppCtrlLedExtSwitchTarget0_aunDutyCycle)[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC], uint8(*aunAnimationDetection)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], tiu32Thermozone(*ppCtrlLedLsTarget0_aulThermozone)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], tiu32Thermozone(*ppCtrlLedExtSwitchTarget0_aulThermozone)[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC]); STATIC_AL void CtrlLed_AnimaPXAControlOverLS(tCtrlLed_PXAData aunPXA_DutyCycle[LEDR_CFG_MATRIX_NO_OF_SEGMENTS], tiu16Percent_1_328(*aunAnima_DutyCycle)[ANIMMA_NR_PIXELS]); STATIC_AL tiu16Percent_1_328 CtrlLed_GammaCorrection(tiu16Percent_1_328 unH_Opt, uint8 ucGammaAllocation); STATIC_AL tiu16Percent_1_328 CtrlLed_GammaCorrection_Inv(tiu16Percent_1_328 unDutyCycle, uint8 ucGammaAllocation); STATIC_AL void CtrlLed_LSMaping(void); STATIC_AL void CtrlLed_LSPWM_Prio(void); STATIC_AL void CtrlLed_DrvErr_Handling(void); void ADBMatrixControChannelEnable(uint8 Num, tiu16Percent_1_328 *LedExtSwitchTargetDutyCycle, boolean Status); //----------------------------------------------------------------------------- /// \brief Gamm Correction /// /// \descr Calculate gamma correction /// /// /// \param unH_Opt - given H_OPT /// ucGammaAllocation - gamma allocation curve /// /// \return tiu16Percent_1_328 - PWM output //----------------------------------------------------------------------------- STATIC_AL tiu16Percent_1_328 CtrlLed_GammaCorrection(tiu16Percent_1_328 unH_Opt, uint8 ucGammaAllocation) { tiu16Percent_1_328 unGammaCorr = CTRLLED_DATA_INITIAL; if (unH_Opt != CTRLLED_DATA_INITIAL) { switch (ucGammaAllocation) { case LEDR_GAMMA_CURVE_IDX_1: // Apply gamma curve 1 unGammaCorr = UtilMath_FastInterpolateU16_N17(Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - CTRLLED_LOGIC_OFFSET], unH_Opt); break; case LEDR_GAMMA_CURVE_IDX_2: // Apply gamma curve 2 unGammaCorr = UtilMath_FastInterpolateU16_N17(Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - CTRLLED_LOGIC_OFFSET], unH_Opt); break; default: // no gamma allocation unGammaCorr = unH_Opt; break; } } return unGammaCorr; } //----------------------------------------------------------------------------- /// \brief Gamm Correction /// /// \descr Calculate gamma correction inversed /// /// /// \param unDutyCycle - PWM input /// ucGammaAllocation - gamma allocation curve /// /// \return tiu16Percent_1_328 - H_Opt output //----------------------------------------------------------------------------- STATIC_AL tiu16Percent_1_328 CtrlLed_GammaCorrection_Inv(tiu16Percent_1_328 unDutyCycle, uint8 ucGammaAllocation) { tiu16Percent_1_328 unGammaCorr = CTRLLED_DATA_INITIAL; if (unDutyCycle != CTRLLED_DATA_INITIAL) { switch (ucGammaAllocation) { case LEDR_GAMMA_CURVE_IDX_1: // Apply gamma curve 1 unGammaCorr = UtilMath_LinearInterpolateU16(Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - CTRLLED_LOGIC_OFFSET], Gamma_X[LEDR_GAMMA_CURVE_IDX_1 - CTRLLED_LOGIC_OFFSET], (sint32) LEDR_CFG_GAMMA_CURVE_POINTS_NO, unDutyCycle); break; case LEDR_GAMMA_CURVE_IDX_2: // Apply gamma curve 2 unGammaCorr = UtilMath_LinearInterpolateU16(Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - CTRLLED_LOGIC_OFFSET], Gamma_X[LEDR_GAMMA_CURVE_IDX_2 - CTRLLED_LOGIC_OFFSET], (sint32) LEDR_CFG_GAMMA_CURVE_POINTS_NO, unDutyCycle); break; default: // no gamma allocation unGammaCorr = unDutyCycle; break; } } return unGammaCorr; } //----------------------------------------------------------------------------- /// \brief LMM illumint control over light sources /// /// \descr Gives LMM illuminant control over light sources based on LMM illum prio /// /// /// \param aunLMM_DutyCycle - PWM of each LMM illuminant /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_LMMControlOverLS(tCtrlLed_LMMData aunLMM_DutyCycle[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS]) { uint8 ucChNo = CTRLLED_DATA_INITIAL; uint8 ucIdx = CTRLLED_DATA_INITIAL; uint8 ucLMMIllum_No = CTRLLED_DATA_INITIAL; // go thru all logical single units for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { // check if the unit is used if ((LS_X[ucIdx].ChConfig.Led_DriverID != 0u) && (LS_X[ucIdx].LMM_UsedIllum.unRaw != 0u)) { LS_X[ucIdx].LMM_IllumPrio = LEDR_PRIO_DEFAULT; // go thru all LMM Illuminants for (ucChNo = CTRLLED_DATA_INITIAL; ucChNo < LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS; ucChNo++) //12 { // search for the highest prio assigned illuminant if (CHECK_BIT(LS_X[ucIdx].LMM_UsedIllum.unRaw, ucChNo)) { if (aunLMM_DutyCycle[ucChNo].LMMPrio < LS_X[ucIdx].LMM_IllumPrio) { LS_X[ucIdx].LMM_IllumPrio = aunLMM_DutyCycle[ucChNo].LMMPrio; LS_X[ucIdx].LMM_IllumNo = (ucChNo + CTRLLED_LOGIC_OFFSET); // save the LMM illum with the highest prio ucLMMIllum_No = ucChNo; } } } if (LS_X[ucIdx].LMM_IllumPrio == LEDR_PRIO_DEFAULT) { LS_X[ucIdx].PWM_LMM = CTRLLED_PWM_0_328; } else { LS_X[ucIdx].PWM_LMM = aunLMM_DutyCycle[ucLMMIllum_No].unDutyCycle; } } } } //----------------------------------------------------------------------------- /// \brief Driver error handling /// /// \descr Monitor the driver errors /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_DrvErr_Handling(void) { uint8 ucIdx = CTRLLED_DATA_INITIAL; tisLsSafetyStatusErrorArr LsSafetyStatusErrorArr; tisVirtLsStatusFaultArr LsStatusFaultArr; tisVirtLsStatusFaultArr LsStatusFaultArr_prev; tisMxSegStatusErrorArr ppCtrlLedMxSwitchStatusError0; tisAllMlcSwitchStatus ppAllMlcSwitchStatus; // S Drv2 -> buck channels status (void)Rte_Read_LsStatusError0_asVal((tisLsSafetyStatusError *)LsSafetyStatusErrorArr); //Buck (void)Rte_Read_SwitchStatusError0_asVal(&ppAllMlcSwitchStatus); //Lmm //Read AniEnable Signal //Clear the faults for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS; ucIdx++) //12 { LsStatusFaultArr[ucIdx].eErr = ERR_SNA; //0 } for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) //103 { #ifdef BUCK_ERROR_CHECK //Turn off BUCK error detection // if the LS is used and is driven by Buck if ((LS_X[ucIdx].ChConfig.Led_DriverID != 0u) && (LS_X[ucIdx].LMM_IllumNo != 0u)) { if (LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr != ERR_YES) { if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrOpenLoad == ERR_YES) //OpenLoad { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_OPENLOAD; } else if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrShortToGnd == ERR_YES) //ShortToGnd { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_SHORTTOGND; } else if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrShortToSupply == ERR_YES) //ShortToSupply { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_SHORTTOBAT; } else if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrDrvInternal == ERR_YES) //LED driver error { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_LEDDRVERR; } else if ((LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrOvercurrent == ERR_YES)) //Overcurrent { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_OVERCURRENT; } else if ((LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrDrvThermalShutdown == ERR_YES)) //ThermalShutdown { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_THERMALSD; } else if ((LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrVLedOutOfTolerance == ERR_YES)) //Voltage out of tolerance { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_OVERVOLT; } else //Normal { // LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eErr = CTRLLED_ERR_LEDNORMAL; } } else { //LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 0U; } LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].eStatOn = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET].eStatOn; LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].unStatCurrent = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET].unStatCurrent; LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - CTRLLED_LOGIC_OFFSET].unStatDutyCycle = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET].unStatDutyCycle; } #endif #ifdef LMM_ERROR_CHECK // CddMlc -> MLC switches status /* MLC is detected */ if ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard >= CTRLLED_LMM_BOARD_MIN) && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard <= CTRLLED_LMM_BOARD_MAX)) //ucIdx > 11 { uint8 ucDevIdx = LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - CTRLLED_LOGIC_OFFSET; uint8 ucSegmentIdx = LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo; /* if having Open or short circuit or MLC fault or MLC bus fault, then will sent err for the LsStatusFaultArr */ if ((ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eFltLsOpen == ERR_YES) || (ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eFltLsShort == ERR_YES)) { /* MLC LED error */ if ((ucDevIdx == CTRLLED_CH_LMM_DRL1_1) && (ucSegmentIdx >= CTRLLED_LED_DRL_MIN) && (ucSegmentIdx <= CTRLLED_LED_DRL_MAX)) //HB Driver { LsStatusFaultArr[CTRLLED_CH_LMM_DRL1_1].eErr = CTRLLED_ERR_MLCLEDERR; } } else if ((ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].eFltCom == FLT_YES) || // MLC communication error (ppAllMlcSwitchStatus.eMlcComError == ERR_YES)) // Bus communication error { //LsStatusFaultArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErr = 11U; if ((ucDevIdx == CTRLLED_CH_LMM_DRL1_1) && (ucSegmentIdx >= CTRLLED_LED_DRL_MIN) && (ucSegmentIdx <= CTRLLED_LED_DRL_MAX)) //HB Driver { LsStatusFaultArr[CTRLLED_CH_LMM_DRL1_1].eErr = CTRLLED_ERR_MLCCOMERR; } } else { /* Do nothing */ } // MLC is detected and used by PXA //Rcode Fault Status if ((LS_X[ucIdx].MatrixIdx != 0u)) { if ((ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eFltLsOpen == ERR_YES) || (ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eFltLsShort == ERR_YES)) { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].eErr = ERR_YES; } else { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].eErr = ERR_NO; } // if the pixel is on, update the PWM value if (ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eStatSupported == SUPPORT_YES) { // return back the requested PXA PWM ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].unStatDutyCycle = LS_X[ucIdx].PWM_PXA; } else { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].unStatDutyCycle = 0u; } // Update the pixel status ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].eStatOn = ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eStatSupported; } } #endif } // store previous LsStatusFaultArr status (void)Bsw_MemCpy((uint8*)&LsStatusFaultArr_prev, (uint8*)&LsStatusFaultArr, sizeof(tisVirtLsStatusFaultArr)); // forward data to FctR SWC Rte_Write_LsStatusError0_asVal((const tisVirtLsStatusFault *)LsStatusFaultArr); //Write to FctR //From Buck Error // forward data to SigPrep Rte_Write_SwitchStatusError0_asVal((const tisMxSegStatusError *)ppCtrlLedMxSwitchStatusError0); //Write to SigPrep //From Lmm Error } //----------------------------------------------------------------------------- /// \brief LS PWM selection /// /// \descr LS PWM selection based on LMM - PXA Prio /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_LSPWM_Prio(void) { uint8 ucIdx = CTRLLED_DATA_INITIAL; // go thru all logical single units and copy the PWM data (LMM vs PXA) based on Prio for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { // check if the light source is used if (LS_X[ucIdx].ChConfig.Led_DriverID != 0u) //Buck { // for the moment in case crystal light is active -> use anima data with highest prio if (AnimActiveSts == CTRLLED_ANIM_INACTIVE) { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_LMM; #ifdef ADB_FUNCTION_USED { if (LS_X[ucIdx].LMM_IllumPrio != LEDR_PRIO_DEFAULT) { if (LS_X[ucIdx].MatrixPrio <= LS_X[ucIdx].LMM_IllumPrio) { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_PXA; } else { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_LMM; } } else { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_PXA; } } #endif } else { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_Anima; } } } LS_X[CTRLLED_CH_BUCK_LB].PWM = LS_X[CTRLLED_CH_BUCK_LB].PWM_LMM; LS_X[CTRLLED_CH_BUCK_HB].PWM = LS_X[CTRLLED_CH_BUCK_HB].PWM_LMM; LS_X[CTRLLED_CH_BUCK_TI].PWM = LS_X[CTRLLED_CH_BUCK_TI].PWM_LMM; } //----------------------------------------------------------------------------- /// \brief Map logical channels /// /// \descr Map single and group logical channels /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_LSMaping(void) { uint8 ucChNo = CTRLLED_DATA_INITIAL; uint8 ucIdx = CTRLLED_DATA_INITIAL; uint8 ucIdx_3 = CTRLLED_DATA_INITIAL; uint8 ucLocalAssignCh = CTRLLED_DATA_INITIAL; uint8 ucChannelGroup_Config[LEDR_CFG_COD_UNITxxx_CONFIG_NO_OF_BYTES] = { CTRLLED_DATA_INITIAL }; uint8 ppCtrlLedLsTarget0_aucEnable[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS] = { CTRLLED_DATA_INITIAL }; AnimMa_setCodingData(Cod_GetAnimMaBlock()); // start logical channel mapping - LMM based for (ucChNo = CTRLLED_DATA_INITIAL; ucChNo < LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS; ucChNo++) //12 { ucLocalAssignCh = Cod_GetLogicalUnitLsm(ucChNo); if (Cod_IsLogicalSingleUnit(ucLocalAssignCh) != FALSE) //Single { // set the LMM illuminant control over Logical single channel SET_BIT(LS_X[ucLocalAssignCh - 1u].LMM_UsedIllum.unRaw, ucChNo); } else if (Cod_IsLogicalGroupUnit(ucLocalAssignCh) != FALSE) //group { Cod_GetLogicalGroup(ucLocalAssignCh, &ucChannelGroup_Config[0]); for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_COD_UNITxxx_CONFIG_NO_OF_BYTES; ucIdx++) { // for each byte search for logical single channels for (ucIdx_3 = CTRLLED_DATA_INITIAL; ucIdx_3 < CTRLLED_CFG_BYTE_SIZE; ucIdx_3++) { if (CHECK_BIT(ucChannelGroup_Config[ucIdx], ucIdx_3) != FALSE) { // Light source no. assigned to LightSourceGroup LS_X[(ucIdx * CTRLLED_CFG_BYTE_SIZE) + ucIdx_3].LogicalChGroup[ucLocalAssignCh - CTRLLED_CFG_GROUP_UNIT_MIN_IDX] = ucLocalAssignCh; // Assign the LMM illuminant which is controling this logical channel group SET_BIT(LS_X[(ucIdx * CTRLLED_CFG_BYTE_SIZE) + ucIdx_3].LMM_UsedIllum.unRaw, ucChNo); } } } } else { // LOGICAL_CH_NOT_USED } } // end logical channel mapping // Channel config mapping for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { LS_X[ucIdx].ChConfig.Base_Pwm = Cod_GetLogicalUnitBasePWM(ucIdx); // coding data check if (Cod_GetLogicalUnitLedDrvId(ucIdx) <= (uint8)LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS) { LS_X[ucIdx].ChConfig.Led_DriverID = Cod_GetLogicalUnitLedDrvId(ucIdx); } LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard = Cod_GetLogicalUnitMlcDrvId(ucIdx); LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo = Cod_GetLogicalUnitMlcDrvSw(ucIdx); } // go through matrix assignments and animation assignments for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_MATRIX_NO_OF_SEGMENTS; ucIdx++) { if (Cod_GetLogicalUnitMtx(ucIdx) >(uint8) 0u) { LS_X[Cod_GetLogicalUnitMtx(ucIdx) - CTRLLED_LOGIC_OFFSET].MatrixIdx = (ucIdx + CTRLLED_LOGIC_OFFSET); } } for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < ANIMMA_NR_PIXELS; ucIdx++) { if (Cod_GetLogicalUnitAni(ucIdx) > (uint8)0u) { LS_X[Cod_GetLogicalUnitAni(ucIdx) - CTRLLED_LOGIC_OFFSET].AnimaIdx = (ucIdx + CTRLLED_LOGIC_OFFSET); } } for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS; ucIdx++) { ppCtrlLedLsTarget0_aucEnable[ucIdx] = 1u; } Rte_Write_LsTarget0_aucEnable((const uint8 *)ppCtrlLedLsTarget0_aucEnable); } //----------------------------------------------------------------------------- /// \brief LMM ramps and gamma correction /// /// \param aunLMM_DutyCycle : /// array of LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS duty /// cycles as requested by LSM (FctR) /// \param ppCtrlLedLsTarget0_asSetting: /// array of LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS duty cycles /// and current percentages that need to be written onto RTE /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_LMMRampGamma(tCtrlLed_LMMData(*aunLMM_DutyCycle)[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS], CtrlLed_tisLsTarget_perc(*ppCtrlLedLsTarget0_asSetting)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], uint8(*aunAnimationDetection)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]) { uint8 ucChNo = CTRLLED_DATA_INITIAL; uint8 ucGammaAllocation = CTRLLED_DATA_INITIAL; uint16 unPWM_Ramp[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS]; static CtrlLed_tisLsLmmTarget tmpFctRLsTarget0[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS]; uint8 ucAnimationMode; (void)Rte_Read_LsTarget0_asVal(tmpFctRLsTarget0); (void)Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ucAnimationMode); (void)Rte_Read_ppareSigPrepBreatheReq_sBreatheReq(&CtrlLed_BreathSts); if (GET_HEADLIGHT_VARIANT != CTRLLED_COD_VERSION_HIGH) { if (CtrlLed_BreathSts.ucPosBreatheReq == 1) { tmpFctRLsTarget0[CTRLLED_CH_BUCK_DRL].ucAnimation = 128; AnimCompleteSts = CTRLLED_ANIM_STS_PROGRESS; } else { AnimCompleteSts = CTRLLED_ANIM_STS_OFF; } } if ((GET_HEADLIGHT_VARIANT == CTRLLED_COD_VERSION_HIGH)) { if (ucAnimationMode != CTRLLED_ANIM_MODE_NONE) { if ((AnimCompleteSts == CTRLLED_ANIM_STS_PROGRESS) || (AnimMaStartFlag == false)) { tmpFctRLsTarget0[CTRLLED_CH_BUCK_DRL].ucAnimation = ucAnimationMode + CTRLLED_ANIM_SEQUENCE_OFSE; AnimMaStartFlag = true; } } else { AnimCompleteSts=CTRLLED_ANIM_STS_OFF; tmpFctRLsTarget0[CTRLLED_CH_BUCK_DRL].ucAnimation = CTRLLED_ANIM_MODE_NONE; AnimMaStartFlag = false; } } if (tmpFctRLsTarget0[CTRLLED_CH_BUCK_DRL].ucPriority == CTRLLED_PRIO_DRL) { AnimCompleteSts = CTRLLED_ANIM_STS_OFF; AnimActiveSts = CTRLLED_ANIM_INACTIVE; tmpFctRLsTarget0[CTRLLED_CH_BUCK_DRL].ucAnimation = CTRLLED_ANIM_SEQUENCE_NON; } else if ((tmpFctRLsTarget0[CTRLLED_CH_BUCK_DRL].ucPriority != CTRLLED_PRIO_DRL) && (AnimCompleteSts != CTRLLED_ANIM_STS_PROGRESS)) { AnimActiveSts = CTRLLED_ANIM_INACTIVE; } else { AnimActiveSts = CTRLLED_ANIM_ACTIVE; } for (ucChNo = 0u; ucChNo < LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS; ucChNo++) { // if the current LSM Illum prio is different then the default one -> store it if (tmpFctRLsTarget0[ucChNo].ucPriority != LEDR_PRIO_DEFAULT) { CtrlLed_aucLMMPrio[ucChNo] = tmpFctRLsTarget0[ucChNo].ucPriority; } // Set the current constant to 100% (*ppCtrlLedLsTarget0_asSetting)[ucChNo].unCurrent = CONV_LSB_1_328_U16(CTRLLED_PWM_100); //Detection logic for each light function, if animation is present then value will be != 0 //Add all the MLCs or single buck, for each light function (*aunAnimationDetection)[ucChNo] = tmpFctRLsTarget0[ucChNo].ucAnimation; // no animation is requested or the requested animation contains 0 Staging posts if (tmpFctRLsTarget0[ucChNo].ucAnimation == 0u) { // Stop crystal animation sequence in case it is active if ((AnimMa_isSequenceActive(CtrlLed_ucAnimation_prev[ucChNo] - CTRLLED_LMM_ANIMATION_OFFSET) == true) && // crystal animation sequence is still active (CtrlLed_ucAnimation_prev[ucChNo] >= CTRLLED_LMM_ANIMATION_OFFSET)) // crystal animation sequence was requested before { AnimMa_stopSequence(CtrlLed_ucAnimation_prev[ucChNo] - CTRLLED_LMM_ANIMATION_OFFSET); } // Get the allocated gamma for the current channel in HPWM ucGammaAllocation = Cod_GetGammaIndexLsm(ucChNo); //Convert HPWM to HOPT tmpFctRLsTarget0[ucChNo].unBrightness = CtrlLed_GammaCorrection_Inv(tmpFctRLsTarget0[ucChNo].unBrightness , ucGammaAllocation); // For each channel apply ramping on HOPT value (*aunLMM_DutyCycle)[ucChNo].unDutyCycle = CtrlLed_Ramping(tmpFctRLsTarget0[ucChNo].unBrightness, (uint16)(tmpFctRLsTarget0[ucChNo].unRampTime / 10u), (uint8)(tmpFctRLsTarget0[ucChNo].eRampType), &CtrlLed_Ramp[ucChNo]); // stored the PWM value after ramping unPWM_Ramp[ucChNo] = (*aunLMM_DutyCycle)[ucChNo].unDutyCycle; (*aunLMM_DutyCycle)[ucChNo].unDutyCycle = CtrlLed_GammaCorrection((*aunLMM_DutyCycle)[ucChNo].unDutyCycle , ucGammaAllocation); } else if (tmpFctRLsTarget0[ucChNo].ucAnimation >= CTRLLED_LMM_ANIMATION_OFFSET) { //if Animation is requested clear the value TODO (*aunLMM_DutyCycle)[ucChNo].unDutyCycle = 0u; // Crystal light animation path // Start crystal animation sequence if is not started aleady if (AnimMa_isSequenceActive(tmpFctRLsTarget0[ucChNo].ucAnimation - CTRLLED_LMM_ANIMATION_OFFSET) == false) { // Stop the previous running sequence on the same LMM if ((AnimMa_isSequenceActive(CtrlLed_ucAnimation_prev[ucChNo] - CTRLLED_LMM_ANIMATION_OFFSET) == true) && (CtrlLed_ucAnimation_prev[ucChNo] >= CTRLLED_LMM_ANIMATION_OFFSET) && (tmpFctRLsTarget0[ucChNo].ucAnimation != CtrlLed_ucAnimation_prev[ucChNo])) { AnimMa_stopSequence(CtrlLed_ucAnimation_prev[ucChNo] - CTRLLED_LMM_ANIMATION_OFFSET); } AnimMa_startSequence(tmpFctRLsTarget0[ucChNo].ucAnimation - CTRLLED_LMM_ANIMATION_OFFSET); } // light request is no longer active else if ((tmpFctRLsTarget0[ucChNo].ucPriority == LEDR_PRIO_DEFAULT) && (CtrlLed_ucAnimation_prev[ucChNo] >= CTRLLED_LMM_ANIMATION_OFFSET)) { // Trigger a soft stop AnimMa_softStopSequence(CtrlLed_ucAnimation_prev[ucChNo] - CTRLLED_LMM_ANIMATION_OFFSET); } else { /* Do nothing */ } } else { // TODO invalid animation sequence ID } // store the current animation ID CtrlLed_ucAnimation_prev[ucChNo] = tmpFctRLsTarget0[ucChNo].ucAnimation; // Hold the current LMM prio until ramp down to 0% is reached if (unPWM_Ramp[ucChNo] > 0u) { (*aunLMM_DutyCycle)[ucChNo].LMMPrio = CtrlLed_aucLMMPrio[ucChNo]; } else { (*aunLMM_DutyCycle)[ucChNo].LMMPrio = LEDR_PRIO_DEFAULT; } } } //----------------------------------------------------------------------------- /// \brief Crystal light animation - ramping /// /// \descr /// /// /// \param ucPxlNo /// /// /// \return boAnimaStat //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_AnimMaRamp(tiu16Percent_1_328(*aunAnima_DutyCycle)[ANIMMA_NR_PIXELS]) { uint8 ucIdx = CTRLLED_DATA_INITIAL; uint8 ucMatrixGammaAlloc = Cod_GetGammaIndexMtx(); // go thru all anima pixels and perform ramp up / ramp down for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < ANIMMA_NR_PIXELS; ucIdx++) { // Anima is active if ((AnimMaRamp_aucPxlIntTgt[ucIdx] * CTRLLED_CFG_PRR1_328) > CtrlLed_aunAnimaRamp[ucIdx]) { // Ramp Up CtrlLed_aunAnimaRamp[ucIdx] += (AnimMaRamp_aucPxlIntInc[ucIdx] * CTRLLED_CFG_PRR1_328); //If value exceeds over the target value, limit it to the target value if (CtrlLed_aunAnimaRamp[ucIdx] > (AnimMaRamp_aucPxlIntTgt[ucIdx] * CTRLLED_CFG_PRR1_328)) { CtrlLed_aunAnimaRamp[ucIdx] = AnimMaRamp_aucPxlIntTgt[ucIdx] * CTRLLED_CFG_PRR1_328; } else { //Do Nothing } } else if ((AnimMaRamp_aucPxlIntTgt[ucIdx] * CTRLLED_CFG_PRR1_328) < CtrlLed_aunAnimaRamp[ucIdx]) { // Ramp down if (CtrlLed_aunAnimaRamp[ucIdx] < (AnimMaRamp_aucPxlIntDec[ucIdx] * CTRLLED_CFG_PRR1_328)) { CtrlLed_aunAnimaRamp[ucIdx] = 0; } else { CtrlLed_aunAnimaRamp[ucIdx] -= (AnimMaRamp_aucPxlIntDec[ucIdx] * CTRLLED_CFG_PRR1_328); } } else { CtrlLed_aunAnimaRamp[ucIdx] = (AnimMaRamp_aucPxlIntTgt[ucIdx] * CTRLLED_CFG_PRR1_328); } (*aunAnima_DutyCycle)[ucIdx] = CtrlLed_GammaCorrection(CtrlLed_aunAnimaRamp[ucIdx] , ucMatrixGammaAlloc); } } //----------------------------------------------------------------------------- /// \brief PXA ramps and gamma correction /// /// \descr /// /// /// \param (*aunPXA_DutyCycle)[LEDR_CFG_MATRIX_NO_OF_SEGMENTS] /// - duty cycle requested by PXA SWC /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_PXARampGamma(tCtrlLed_PXAData(*aunPXA_DutyCycle)[LEDR_CFG_MATRIX_NO_OF_SEGMENTS]) { #ifdef ADB_FUNCTION_USED CtrlLed_tisMxSegTarget tmpMxSegTargetArr[LEDR_CFG_MATRIX_NO_OF_SEGMENTS]; uint8 ucMatrixGammaAlloc = Cod_GetGammaIndexMtx(); uint8 ucChNo = CTRLLED_DATA_INITIAL; // Read PXA data (void)Rte_Read_MxTarget0_asSetting(tmpMxSegTargetArr); for (ucChNo = 0u; ucChNo < LEDR_CFG_MATRIX_NO_OF_SEGMENTS; ucChNo++) { // if the current PXA prio is different then the default one -> store it if (tmpMxSegTargetArr[ucChNo].ucPriority != LEDR_PRIO_DEFAULT) { CtrlLed_aucPXAPrio[ucChNo] = tmpMxSegTargetArr[ucChNo].ucPriority; } // start PXA Ramping // If the requested target brightness is larger than the actual one -> use the RampUp time for ramping if (tmpMxSegTargetArr[ucChNo].unBrightness >= (*aunPXA_DutyCycle)[ucChNo].unDutyCycle) { (*aunPXA_DutyCycle)[ucChNo].unDutyCycle = CtrlLed_Ramping(tmpMxSegTargetArr[ucChNo].unBrightness, (tmpMxSegTargetArr[ucChNo].unRampTimeUp / 10u), CTRLLED_RAMP_ZK, &CtrlLed_Ramp[ucChNo + LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]); } // If the requested target brigtness is lower than the actual one -> use the RampDown time for ramping else { (*aunPXA_DutyCycle)[ucChNo].unDutyCycle = CtrlLed_Ramping(tmpMxSegTargetArr[ucChNo].unBrightness, (tmpMxSegTargetArr[ucChNo].unRampTimeDown / 10u), CTRLLED_RAMP_ZK, &CtrlLed_Ramp[ucChNo + LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]); } // end PXA Ramping // Hold the current PXA prio until ramp down to 0% is reached if ((*aunPXA_DutyCycle)[ucChNo].unDutyCycle > CTRLLED_PWM_ZERO) { (*aunPXA_DutyCycle)[ucChNo].PXAPrio = CtrlLed_aucPXAPrio[ucChNo]; } else if (tmpMxSegTargetArr[ucChNo].ucPriority == LEDR_PRIO_DEFAULT) { (*aunPXA_DutyCycle)[ucChNo].PXAPrio = LEDR_PRIO_DEFAULT; } else { /* Do nothing */ } // start PXA Gamma HOPT TO HPWM (*aunPXA_DutyCycle)[ucChNo].unDutyCycle = CtrlLed_GammaCorrection((*aunPXA_DutyCycle)[ucChNo].unDutyCycle , ucMatrixGammaAlloc); } // end PXA Gamma #endif //ADB_FUNCTION_USED } //----------------------------------------------------------------------------- /// \brief PXA and AnimaMa control over light sources /// /// \descr Gives PXA and AnimaMa control over light sources /// /// /// \param aunPXA_DutyCycle - PXA PWM of each pixel /// aunAnima_DutyCycle - AnimaMa PWM of each pixel /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_AnimaPXAControlOverLS(tCtrlLed_PXAData aunPXA_DutyCycle[LEDR_CFG_MATRIX_NO_OF_SEGMENTS], tiu16Percent_1_328(*aunAnima_DutyCycle)[ANIMMA_NR_PIXELS]) { uint8 ucIdx = CTRLLED_DATA_INITIAL; uint8 ucAnimationMode; tisAnimationStatus ucAnimSts; (void)Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ucAnimationMode); // assign the pixel X PWM to the related Light source for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { #ifdef ADB_FUNCTION_USED // LS_X points to pixel ucIdx if (LS_X[ucIdx].MatrixIdx > 0u) { // store PXA PWM LS_X[ucIdx].PWM_PXA = aunPXA_DutyCycle[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].unDutyCycle; // include matrix prio LS_X[ucIdx].MatrixPrio = aunPXA_DutyCycle[LS_X[ucIdx].MatrixIdx - CTRLLED_LOGIC_OFFSET].PXAPrio; } #endif if (LS_X[ucIdx].AnimaIdx > 0u) { // store the AnimMa PWM LS_X[ucIdx].PWM_Anima = (*aunAnima_DutyCycle)[LS_X[ucIdx].AnimaIdx - CTRLLED_LOGIC_OFFSET]; } } //High animation feedback logic //Base no animation feedback if (GET_HEADLIGHT_VARIANT == CTRLLED_COD_VERSION_HIGH) { if (CtrlLed_aunLMM_DutyCycle[CTRLLED_CH_BUCK_DRL].LMMPrio == CTRLLED_PRIO_DRL) { AnimCompleteSts = CTRLLED_ANIM_STS_OFF; } else if (AnimMa_GetAnimSts()) { for (ucIdx = 0; ucIdx < ANIMMA_NR_PIXELS; ucIdx++) { if ((*aunAnima_DutyCycle)[ucIdx] != CTRLLED_PWM_ZERO) { AnimCompleteSts = CTRLLED_ANIM_STS_PROGRESS; break; } else { AnimCompleteSts = CTRLLED_ANIM_STS_COMPLETE; } } } else { AnimCompleteSts = CTRLLED_ANIM_STS_PROGRESS; } } if (Cod_GetAnimMaBlock() == NULL_PTR) { ucAnimSts.ucHLM_LockLightStatusfeedback = CTRLLED_ANIMSTS_INACTIVE; ucAnimSts.ucHLM_UnLockLightStatusfeedback = CTRLLED_ANIMSTS_INACTIVE; } else if ((ucAnimationMode >= CTRLLED_ANIM_MODE1_UNLOCK) && (ucAnimationMode <= CTRLLED_ANIM_MODE3_UNLOCK) && (AnimCompleteSts == CTRLLED_ANIM_STS_PROGRESS)) { ucAnimSts.ucHLM_LockLightStatusfeedback = CTRLLED_ANIMSTS_OFF; ucAnimSts.ucHLM_UnLockLightStatusfeedback = CTRLLED_ANIMSTS_ON; } else if ((ucAnimationMode >= CTRLLED_ANIM_MODE1_LOCK) && (ucAnimationMode <= CTRLLED_ANIM_MODE3_LOCK) && (AnimCompleteSts == CTRLLED_ANIM_STS_PROGRESS)) { ucAnimSts.ucHLM_LockLightStatusfeedback = CTRLLED_ANIMSTS_ON; ucAnimSts.ucHLM_UnLockLightStatusfeedback = CTRLLED_ANIMSTS_OFF; } //POS breath else if ((CtrlLed_BreathSts.ucPosBreatheReq == true) && (GET_HEADLIGHT_VARIANT != CTRLLED_COD_VERSION_HIGH)) { ucAnimSts.ucHLM_LockLightStatusfeedback = CTRLLED_ANIMSTS_ON; ucAnimSts.ucHLM_UnLockLightStatusfeedback = CTRLLED_ANIMSTS_ON; } else { ucAnimSts.ucHLM_LockLightStatusfeedback = CTRLLED_ANIMSTS_OFF; ucAnimSts.ucHLM_UnLockLightStatusfeedback = CTRLLED_ANIMSTS_OFF; } //R2 adds RTE interface and passes it to SysMon Rte_Write_ppaseCtrlLedAnimationStatus_sAnimationStatus(&ucAnimSts); } //----------------------------------------------------------------------------- /// \brief go thru all LS and update ppCtrlLedLsTarget0_asSetting and ppCtrlLedExtSwitchTarget0_aunDutyCycle ports /// /// \descr /// /// /// \param //Par1 Buck /// \param //Par2 Lmm /// /// \return //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_Update(CtrlLed_tisLsTarget_perc(*ppCtrlLedLsTarget0_asSetting)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], tiu16Percent_1_328(*ppCtrlLedExtSwitchTarget0_aunDutyCycle)[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC], uint8(*aunAnimationDetection)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], tiu32Thermozone(*ppCtrlLedLsTarget0_aulThermozone)[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS], tiu32Thermozone(*ppCtrlLedExtSwitchTarget0_aulThermozone)[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC]) { // go thru all LS and update ppCtrlLedLsTarget0_asSetting and ppCtrlLedExtSwitchTarget0_aunDutyCycle ports for (uint8 ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { // LED driver found // a LED driver is assigned to this LS if (LS_X[ucIdx].ChConfig.Led_DriverID != CTRLLED_DATA_INITIAL) // && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard == 0x09)) { if (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard == CTRLLED_LMM_BOARD_NON) //Lmm not used { // copy PWM data assigned to LED channel X w/o Bypass w/o MLC (*ppCtrlLedLsTarget0_asSetting)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unDutyCycle = CONV_TO_BASE_PWM(LS_X[ucIdx].PWM, LS_X[ucIdx].ChConfig.Base_Pwm); //ECU8.SWAD.9783 if (CodPrj_GetLogicalUnitThermozoneIdx(ucIdx) != CTRLLED_DATA_INITIAL && (LS_X[ucIdx].LMM_IllumNo != CTRLLED_DATA_INITIAL)) { (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET] = CodPrj_GetLogicalUnitThermozoneIdx(ucIdx); } else { (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET] = LEDR_NO_CHANNEL; } } // update ppCtrlLedExtSwitchTarget0_aunDutyCycle with MLC data (MLC_NO and MLC_Switch_NO) if ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard >= 0x01u) && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard <= 0x08u)) { //buck pwm not used if (GET_HEADLIGHT_VARIANT == CTRLLED_COD_VERSION_HIGH) { // set PWM intensity to MLC (*ppCtrlLedExtSwitchTarget0_aunDutyCycle)[LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u][LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = CONV_TO_BASE_PWM(LS_X[ucIdx].PWM, LS_X[ucIdx].ChConfig.Base_Pwm); // set intensity to 100% for BUCK if (LS_X[ucIdx].PWM != CTRLLED_PWM_ZERO) { (*ppCtrlLedLsTarget0_asSetting)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unDutyCycle = CONV_TO_BASE_PWM(CONV_LSB_1_328_U16(CTRLLED_PWM_100), LS_X[ucIdx].ChConfig.Base_Pwm); } //add thermozone data (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = LEDR_NO_CHANNEL; (*ppCtrlLedExtSwitchTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u][LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = LEDR_NO_CHANNEL; if (CodPrj_GetLogicalUnitThermozoneIdx(ucIdx) != CTRLLED_DATA_INITIAL) { (*ppCtrlLedExtSwitchTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u][LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = CodPrj_GetLogicalUnitThermozoneIdx(ucIdx); } } else { // set PWM intensity to BUCK (*ppCtrlLedLsTarget0_asSetting)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unDutyCycle = CONV_TO_BASE_PWM(LS_X[ucIdx].PWM, LS_X[ucIdx].ChConfig.Base_Pwm); //add thermozone data (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET] = LEDR_NO_CHANNEL; (*ppCtrlLedExtSwitchTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u][LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = LEDR_NO_CHANNEL; if (CodPrj_GetLogicalUnitThermozoneIdx(ucIdx) != CTRLLED_DATA_INITIAL) { (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - CTRLLED_LOGIC_OFFSET] = CodPrj_GetLogicalUnitThermozoneIdx(ucIdx); } } } } } if (GET_HEADLIGHT_VARIANT == CTRLLED_COD_VERSION_HIGH) if ((*ppCtrlLedLsTarget0_asSetting)[CTRLLED_CH_BUCK_TI].unDutyCycle != CTRLLED_PWM_0_328) { CtrlLed_TurnIndDebounce = 54; } // else if(((*aunAnimationDetection)[CTRLLED_CH_BUCK_DRL] != CTRLLED_ANIM_SEQUENCE_NON)) // { // CtrlLed_TurnIndDebounce = 0; // } if(CtrlLed_TurnIndDebounce > 0) { CtrlLed_TurnIndDebounce--; for (uint8 Idx = 0u; Idx <= CTRLLED_LMM_PCBA_MAX; Idx++) { (*ppCtrlLedExtSwitchTarget0_aunDutyCycle)[CTRLLED_CH_LMM_DRL1_1][Idx] = CTRLLED_PWM_0_328; } } } //----------------------------------------------------------------------------- /// \brief initialisation function for CtrlLed /// /// \descr /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_Init(void) { uint8 ucIdx = CTRLLED_DATA_INITIAL; CtrlLed_tieMountingSide ucSide = 0xFFU; for (ucIdx = CTRLLED_DATA_INITIAL; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { // include matrix prio LS_X[ucIdx].MatrixPrio = LEDR_PRIO_DEFAULT; LS_X[ucIdx].LMM_IllumPrio = LEDR_PRIO_DEFAULT; } CtrlLed_BreathSts.ucGrilleBreatheReq = 0u; CtrlLed_BreathSts.ucPosBreatheReq = 0u; (void)rcAnimMaInit(); // set the mounting side of the Animation Rte_Call_GetMountingSide(&ucSide); // Set the mounting side of the animation block if (ucSide == eIoHwAbUser_MountingSide_Left) { (void)AnimMa_setMountingSide(ANIMMA_MOUNTINGSIDE_LEFT); CtrlLed_MountingSide = CTRLLED_MOUNTINSIDE_LEFT; } else if (ucSide == eIoHwAbUser_MountingSide_Right) { (void)AnimMa_setMountingSide(ANIMMA_MOUNTINGSIDE_RIGHT); CtrlLed_MountingSide = CTRLLED_MOUNTINSIDE_RIGHT; } else { (void)AnimMa_setMountingSide(ANIMMA_MOUNTINGSIDE_UNKNOWN); CtrlLed_MountingSide = ANIMMA_MOUNTINGSIDE_UNKNOWN; } CtrlLed_CodingDataValidation(); } //----------------------------------------------------------------------------- /// \brief cyclic function for CtrlLed /// /// \descr CtrlLed_Cycle10ms() applies ramps and gamma correction for each /// LED channel /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_Cycle10ms(void) { uint8 ucIdx = CTRLLED_DATA_INITIAL; uint8 ucIdx_1 = CTRLLED_DATA_INITIAL; //CtrlLed_tieMountingSide ucSide = 0xFFU; uint16 CeremonyLeftOutPut[ANIMATION_SEGMENT_NUM]; uint16 CeremonyRightOutPut[ANIMATION_SEGMENT_NUM]; tiu32Thermozone ppCtrlLedLsTarget0_aulThermozone[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]; tiu32Thermozone ppCtrlLedExtSwitchTarget0_aulThermozone[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC]; uint8 aunAnimationDetection[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]; CtrlLed_tisLsTarget_perc ppCtrlLedLsTarget0_asSetting[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS]; tiu16Percent_1_328 ppCtrlLedExtSwitchTarget0_aunDutyCycle[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC]; (void)Bsw_MemSet((uint8*)ppCtrlLedLsTarget0_aulThermozone, 0xFF, sizeof(tiu32Thermozone)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); (void)Bsw_MemSet((uint8*)ppCtrlLedExtSwitchTarget0_aulThermozone, 0xFF, sizeof(tiu32Thermozone)*CTRLLED_CFG_MAX_NO_OF_MLC*CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC); (void)Bsw_MemSet(aunAnimationDetection, CTRLLED_DATA_INITIAL, sizeof(uint8)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); (void)Bsw_MemSet((uint8*)ppCtrlLedLsTarget0_asSetting, CTRLLED_DATA_INITIAL, sizeof(CtrlLed_tisLsTarget_perc)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); (void)Bsw_MemSet((uint8*)ppCtrlLedExtSwitchTarget0_aunDutyCycle, CTRLLED_DATA_INITIAL, sizeof(tiu16Percent_1_328)*CTRLLED_CFG_MAX_NO_OF_MLC*CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC); (void)Bsw_MemSet((uint8*)CeremonyLeftOutPut, CTRLLED_DATA_INITIAL, sizeof(CeremonyLeftOutPut)); (void)Bsw_MemSet((uint8*)CeremonyRightOutPut, CTRLLED_DATA_INITIAL, sizeof(CeremonyRightOutPut)); // Validate the coding data // LMM Ramping and gamma correction CtrlLed_LMMRampGamma(&CtrlLed_aunLMM_DutyCycle, &ppCtrlLedLsTarget0_asSetting, &aunAnimationDetection); // PXA Ramping and gamma correction /* CtrlLed_PXARampGamma(&CtrlLed_aunPXA_DutyCycle); */ // Control logical single channels based on the LMM illuminants request CtrlLed_LMMControlOverLS(CtrlLed_aunLMM_DutyCycle); // Calculate the animation Intensity if (anima_counter % (ANIMMA_CYCLE) == 0u) { // Activate Status needs to be added!!! // When the corresponding Light Functions are activated, LMM aunLMM_DutyCycle? (void)rcAnimMa50(); } else { // do nothing } anima_counter += 1U; // Crystal light Ramping and gamma correction CtrlLed_AnimMaRamp(&CtrlLed_aunAnima_DutyCycle); // Assign PXA and AnimaMa PWM to logical channels CtrlLed_AnimaPXAControlOverLS(CtrlLed_aunPXA_DutyCycle, &CtrlLed_aunAnima_DutyCycle); // Decide for each light source if it shall be driven by LMM or PXA CtrlLed_LSPWM_Prio(); // go thru all LS and update ppCtrlLedLsTarget0_asSetting and ppCtrlLedExtSwitchTarget0_aunDutyCycle ports CtrlLed_Update(&ppCtrlLedLsTarget0_asSetting, &ppCtrlLedExtSwitchTarget0_aunDutyCycle, &aunAnimationDetection, &ppCtrlLedLsTarget0_aulThermozone, &ppCtrlLedExtSwitchTarget0_aulThermozone); Rte_Write_ExtSwitchTarget0_aunDutyCycle((const tiu16Percent_1_328Arr16*)ppCtrlLedExtSwitchTarget0_aunDutyCycle); Rte_Write_LsTarget0_asSetting((const CtrlLed_tisLsTarget_perc*)ppCtrlLedLsTarget0_asSetting); Rte_Write_LsTarget0_aulThermozone((const tiu32Thermozone*)ppCtrlLedLsTarget0_aulThermozone); Rte_Write_ExtSwitchTarget0_aulThermozone((const tiu32ThermozoneArr16*)ppCtrlLedExtSwitchTarget0_aulThermozone); CtrlLed_DrvErr_Handling(); } //----------------------------------------------------------------------------- /// \brief Validate coding data /// /// \descr Validate the coding data and extract the relevant coding parameters /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_CodingDataValidation(void) { uint8 ucGammaCurveNo = CTRLLED_DATA_INITIAL; uint8 ucGammaCurvePointNo = CTRLLED_DATA_INITIAL; tieDataStatus codDataStat; Rte_Read_CodingDataStatus(&codDataStat); // get the relevant coding data once coding status is valid if (codDataStat == tieDataStatus_Valid) { #ifndef UNIT_TEST CtrlLed_CodPrj_Init(); // For each gamma curve, update the X and Y points with the coding data. // Note: X and Y first and last points are not given by the coding data. //for (ucGammaCurveNo = CTRLLED_DATA_INITIAL; ucGammaCurveNo < LEDR_CFG_NO_OF_GAMMA_CURVES; ucGammaCurveNo++) //{ // for (ucGammaCurvePointNo = CTRLLED_DATA_INITIAL; ucGammaCurvePointNo < LEDR_CFG_GAMMA_CURVE_COD_POINTS_NO; ucGammaCurvePointNo++) // { // Gamma_Y[ucGammaCurveNo][ucGammaCurvePointNo] = CodPrj_GetGammaY(ucGammaCurveNo, ucGammaCurvePointNo); // } //} #endif // Perform Logical channel mapping CtrlLed_LSMaping(); } // keep the current status of coding data codDataStat_prev = codDataStat; } //----------------------------------------------------------------------------- /// \brief Ramping function /// /// \descr CtrlLed_Ramping() is ramping up/down the given requested H_Opt /// This function has been generated/tested with Simulink /// /// \param uint16 unRequested_HOpt - requested H_Opt LSB: 1_328 [0...100]% /// uint16 unRequested_time - requested time LSB: 0.01 [0...12,5]seconds /// uint8 ucRampType - ramp type ZK = 0; SK = 1; Hard = 2 /// ISV_STEST3_tp * pISV - structure which contains the current data /// ramping for all 14 channels /// /// \return uint16 LSB: 1_328 //----------------------------------------------------------------------------- STATIC_AL uint16 CtrlLed_Ramping(uint16 unRequested_HOpt, uint16 unRequested_time, uint8 ucRampType, ISV_STEST3_tp* pISV) { uint16 Aux_U16 = 0; uint8 ucRem = 0u; /* TEST/Ramp/RampFactorsCalculation/TimeReferencing/Enable: Enable condition TEST/Ramp/RampFactorsCalculation/TimeReferencing/Enable: Omitted comparison with constant. # combined # Logical: TEST/Ramp/RampFactorsCalculation/UpdateDetection/TimeOrPwmChanged # combined # Relational: TEST/Ramp/RampFactorsCalculation/UpdateDetection/ReqPwmChanged # combined # Relational: TEST/Ramp/RampFactorsCalculation/UpdateDetection/RampTimeChanged */ if ((unRequested_time != pISV->X_STEST10_T_Ramp_prev) || (unRequested_HOpt != pISV->X_STEST10_PWM_rq_prev)) { /* SLLocal: Default storage class for local variables | Width: 32 */ Int32 S32_Single_Ramp_Diff; /* LSB: 0.00304878 OFF: 0 MIN/MAX: -100 .. 100 */ pISV->X_CurrentTime = unRequested_time; /* Sum: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Single_Ramp_Diff */ S32_Single_Ramp_Diff = ((Int32)unRequested_HOpt) - ((Int32) pISV->X_STEST3_PWM_current_out_prev); /* Abs: TEST/Ramp/RampFactorsCalculation/TimeReferencing/RampDiffAbs */ if (S32_Single_Ramp_Diff >= 0) { /* # combined # Product: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Calculated_Step */ pISV->STEST9_Calculated_Step = (UInt32)S32_Single_Ramp_Diff; } else { /* # combined # Product: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Calculated_Step */ pISV->STEST9_Calculated_Step = (UInt32)(-S32_Single_Ramp_Diff); } /* Switch: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Switch TEST/Ramp/RampFactorsCalculation/TimeReferencing/Switch: Omitted comparison with constant. # combined # Relational: TEST/Ramp/HardSwitch/Relational Operator2 */ if (CTRLLED_RAMP_SK == ucRampType) { /* Switch: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Switch # combined # Product: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Divide2 # combined # Product: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Divide3 # combined # Product: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Calculated_Step */ pISV->STEST9_Switch = (UInt16)(((UInt32)((pISV->STEST9_Calculated_Step * ((UInt32) unRequested_time) * 41u) >> 12u)) / 328u); } else { /* Switch: TEST/Ramp/RampFactorsCalculation/TimeReferencing/Switch */ pISV->STEST9_Switch = unRequested_time; } } /* Unit delay: TEST/Ramp/RampFactorsCalculation/UpdateDetection/PWM_rq_prev */ pISV->X_STEST10_PWM_rq_prev = unRequested_HOpt; /* Unit delay: TEST/Ramp/RampFactorsCalculation/UpdateDetection/T_Ramp_prev */ pISV->X_STEST10_T_Ramp_prev = unRequested_time; /* Switch: TEST/Ramp/Switch2 TEST/Ramp/Switch2: Omitted comparison with constant. # combined # Relational: TEST/Ramp/HardSwitch/Relational Operator */ if (ucRampType == CTRLLED_RAMP_HART) { if (pISV->X_CurrentTime == 0u) { pISV->X_STEST3_PWM_current_out_prev = unRequested_HOpt; } else { pISV->X_CurrentTime--; } return pISV->X_STEST3_PWM_current_out_prev; } else { /* Switch: TEST/Ramp/Switch1 TEST/Ramp/Switch1: Omitted comparison with constant. # combined # Relational: TEST/Ramp/HardSwitch/Relational Operator1 */ if (0u == unRequested_time) { /* Switch: TEST/Ramp/Switch1 # combined # Switch: TEST/Ramp/Switch2 # combined # Unit delay: TEST/Ramp/PWM_HighRes_out_prev */ pISV->X_STEST3_PWM_HighRes_out_prev = ((((Int32)unRequested_HOpt) * 1250) / 41); ucRem = (uint8)((((UInt32)unRequested_HOpt) * 1250u) % 41u); } else { /* SLLocal: Default storage class for local variables | Width: 32 */ Int32 STEST3_StepDivTime; /* LSB: 0.0001 OFF: 0 MIN/MAX: -214748.3648 .. 214748.3647 */ Int32 STEST4_ReqPwm_Min_OutPut_prev; /* LSB: 0.0001 OFF: 0 MIN/MAX: -100 .. 100 */ Int32 STEST8_Switch_MX; /* LSB: 0.0001 OFF: 0 MIN/MAX: -100 .. 100 */ UInt32 Aux_U32; /* Sum: TEST/Ramp/DifferenceLimiterAdj/ReqPwm_Min_OutPut_prev */ STEST4_ReqPwm_Min_OutPut_prev = (((((Int32)unRequested_HOpt) * 1250) / 41) - (pISV->X_STEST3_PWM_HighRes_out_prev)); /* Product: TEST/Ramp/StepDivTime */ Aux_U32 = ((UInt32)pISV->STEST9_Switch) * 5000u; if (Aux_U32 != 0u) { /* SLLocal: Default storage class for local variables | Width: 32 */ //UInt32 Aux_U32_a; //UInt32 Aux_U32_b; // TODO C__U64MULU32I32(pISV->STEST9_Calculated_Step, (Int32)152439, Aux_U32_a, Aux_U32_b); // TODO C__I32DIVU64U32(Aux_U32_a, Aux_U32_b, Aux_U32, STEST3_StepDivTime); } else { /* TEST/Ramp/StepDivTime: Numerator always greater than or equal to zero. */ STEST3_StepDivTime = 2147483647; } if (STEST4_ReqPwm_Min_OutPut_prev >= STEST3_StepDivTime) { /* Switch: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MX */ STEST8_Switch_MX = STEST3_StepDivTime; } else { /* Switch: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MN TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MN: Omitted comparison with constant. # combined # Relational: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/RelOp_MN # combined # Gain: TEST/Ramp/Gain2 */ if (STEST4_ReqPwm_Min_OutPut_prev <= ((Int32)(-STEST3_StepDivTime))) { /* Switch: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MN # combined # Switch: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MX # combined # Gain: TEST/Ramp/Gain2 */ STEST8_Switch_MX = (Int32)(-STEST3_StepDivTime); } else { /* Switch: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MN # combined # Switch: TEST/Ramp/DifferenceLimiterAdj/LimitAdj/Switch_MX */ STEST8_Switch_MX = STEST4_ReqPwm_Min_OutPut_prev; } } /* Switch: TEST/Ramp/Switch1 # combined # Switch: TEST/Ramp/Switch2 # combined # Sum: TEST/Ramp/DifferenceLimiterAdj/PWM_Out # combined # Unit delay: TEST/Ramp/PWM_HighRes_out_prev */ pISV->X_STEST3_PWM_HighRes_out_prev = STEST8_Switch_MX + pISV->X_STEST3_PWM_HighRes_out_prev; } } /* TEST/Ramp/Rescaler # combined # Unit delay: TEST/Ramp/PWM_current_out_prev # combined # Unit delay: TEST/Ramp/PWM_HighRes_out_prev */ Aux_U16 = (UInt16)((((UInt32)pISV->X_STEST3_PWM_HighRes_out_prev) * 41u + ucRem) / 1250u) ; if (Aux_U16 <= 3280u /* 10. */) { /* Reference of merge block: Merge TEST/Ramp/Subsystem/Merge update of variable(s) associated with TEST/Ramp/Subsystem/If Action Subsystem/Out1 # combined # TEST/Ramp/Subsystem/If Action Subsystem/Rescaler1 # combined # Unit delay: TEST/Ramp/PWM_current_out_prev # combined # TEST/Ramp/Subsystem/If Action Subsystem/Rescaler */ pISV->X_STEST3_PWM_current_out_prev = (UInt16)((((UInt32)(UInt16)((((UInt32)Aux_U16) * 76217u) / 1249959u)) * 1249959u) / 76217u); } else { /* Reference of merge block: Merge TEST/Ramp/Subsystem/Merge update of variable(s) associated with TEST/Ramp/Subsystem/If Action Subsystem1/Out1 # combined # TEST/Ramp/Subsystem/If Action Subsystem1/Rescaler1 # combined # Unit delay: TEST/Ramp/PWM_current_out_prev # combined # TEST/Ramp/Subsystem/If Action Subsystem1/Rescaler */ //pISV->X_STEST3_PWM_current_out_prev = (UInt16)(((UInt16)(Aux_U16 / 328u)) * 328u); pISV->X_STEST3_PWM_current_out_prev = (UInt16) Aux_U16; } /* # combined # TargetLink outport: TEST/Ramp/RampOut # combined # Unit delay: TEST/Ramp/PWM_current_out_prev */ return pISV->X_STEST3_PWM_current_out_prev; } //----------------------------------------------------------------------------- /// \brief initialisation runnable /// /// \descr initialisation runnable for CtrlLed /// Called once at start up. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void ctasCtrlLed_riLedRInit(void) { //ENTER_INIT_RUNNABLE(RICTRLLEDINIT); CtrlLed_Init(); //EXIT_INIT_RUNNABLE(RICTRLLEDINIT); } //----------------------------------------------------------------------------- /// \brief de initialisation runnable /// /// \descr de initialisation runnable for CtrlLed /// Called once at shutdown /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void ctasCtrlLed_rdLedRDeInit(void) { //ENTER_DE_INIT_RUNNABLE(RICTRLLEDDEINIT); //CtrlLed_DeInit(); //EXIT_DE_INIT_RUNNABLE(RICTRLLEDDEINIT); } //----------------------------------------------------------------------------- /// \brief cyclic runnable /// /// \descr cyclic runnable for CtrlLed /// Calling cyclicaly every 10 ms. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void ctasCtrlLed_rpLedR10ms(void) { //ENTER_CYCLIC_RUNNABLE(RPCTRLLED10MS); CtrlLed_Cycle10ms(); //EXIT_CYCLIC_RUNNABLE(RPCTRLLED10MS); } //----------------------------------------------------------------------------- /// \brief cyclic runnable /// /// \descr cyclic runnable for CtrlLed /// Calling cyclicaly every 50 ms. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void ctasCtrlLed_rpLedR50ms(void) { //ENTER_CYCLIC_RUNNABLE(RPCTRLLED10MS); //CtrlLed_Cycle50ms(); //EXIT_CYCLIC_RUNNABLE(RPCTRLLED10MS); } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverCornerLightControlStart /// /// \descr Corner light control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverCornerLightControlStart(uint8 CornerLightControl) { CornerLightControlto2F = CornerLightControl; FlagtoControl2F = CTRLLED_MODE_2F_ON; return E_OK; } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverCornerLightControlStop /// /// \descr Corner light control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverCornerLightControlStop(uint8 CornerLightControl) { CornerLightControlto2F = CornerLightControl; FlagtoControl2F = CTRLLED_MODE_2F_OFF; return E_OK; } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverADBMatrixControlStart /// /// \descr High beam control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverADBMatrixControlStart(uint16 Ctrl2FHBSegment) { ADBMatrixContro2F = Ctrl2FHBSegment; FlagtoControl2F = CTRLLED_MODE_2F_ON; return E_OK; } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverADBMatrixControlStop /// /// \descr High beam control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverADBMatrixControlStop(uint16 Ctrl2FHBSegment) { ADBMatrixContro2F = Ctrl2FHBSegment; FlagtoControl2F = CTRLLED_MODE_2F_OFF; return E_OK; } //----------------------------------------------------------------------------- /// \brief ADBMatrixControChannelEnable /// /// \descr /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void ADBMatrixControChannelEnable(uint8 Num, tiu16Percent_1_328 *LedExtSwitchTargetDutyCycle, boolean Status) { #ifdef ADB_FUNCTION_USED uint16 ChannelMapping[12] = { 26398,32765,32765,7158,32765,15640,15040,32765,9927,7158,11810,7158 }; if (Status == true) { LedExtSwitchTargetDutyCycle[Segmentmapping[Num]] = ChannelMapping[Segmentmapping[Num]]; } else { LedExtSwitchTargetDutyCycle[Segmentmapping[Num]] = false; } #endif //ADB_FUNCTION_USED } //----------------------------------------------------------------------------- // Stop declaration or definitions of functions //----------------------------------------------------------------------------- //#define ctasLedR_STOP_SEC_CODE //#include "LedR_MemMap.h" /************************************************************ * RUNNABLE: roExtTakeoverAnimationControlStart * SYMBOL: roExtTakeoverAnimationControlStart ************************************************************ * RTE Events * OIT_ppasvExtTakeoverAnimationControl_Start_ppasvExtTakeoverAnimationControl_Start ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverAnimationControlStart ( CONST(uint8, AUTOMATIC) AnimationControl ) { /* roExtTakeoverAnimationControlStart_Start User Code start*/ /* roExtTakeoverAnimationControlStart_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverAnimationControlStop * SYMBOL: roExtTakeoverAnimationControlStop ************************************************************ * RTE Events * OIT_ppasvExtTakeoverAnimationControl_Stop_ppasvExtTakeoverAnimationControl_Stop ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverAnimationControlStop ( CONST(uint8, AUTOMATIC) AnimationControl ) { /* roExtTakeoverAnimationControlStop_Start User Code start*/ /* roExtTakeoverAnimationControlStop_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverDRLOnOffControlStart * SYMBOL: roExtTakeoverDRLOnOffControlStart ************************************************************ * RTE Events * OIT_ppasvExtTakeoverDRLOnOffControl_Start_ppasvExtTakeoverDRLOnOffControl_Start ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverDRLOnOffControlStart ( CONST(uint8, AUTOMATIC) DRLOnOffControl ) { /* roExtTakeoverDRLOnOffControlStart_Start User Code start*/ /* roExtTakeoverDRLOnOffControlStart_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverDRLOnOffControlStop * SYMBOL: roExtTakeoverDRLOnOffControlStop ************************************************************ * RTE Events * OIT_ppasvExtTakeoverDRLOnOffControl_Stop_ppasvExtTakeoverDRLOnOffControl_Stop ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverDRLOnOffControlStop ( CONST(uint8, AUTOMATIC) DRLOnOffControl ) { /* roExtTakeoverDRLOnOffControlStop_Start User Code start*/ /* roExtTakeoverDRLOnOffControlStop_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverHBOnOffControlStart * SYMBOL: roExtTakeoverHBOnOffControlStart ************************************************************ * RTE Events * OIT_ppasvExtTakeoverHBOnOffControl_Start_ppasvExtTakeoverHBOnOffControl_Start ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverHBOnOffControlStart ( CONST(uint8, AUTOMATIC) HBOnOffControl ) { /* roExtTakeoverHBOnOffControlStart_Start User Code start*/ /* roExtTakeoverHBOnOffControlStart_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverHBOnOffControlStop * SYMBOL: roExtTakeoverHBOnOffControlStop ************************************************************ * RTE Events * OIT_ppasvExtTakeoverHBOnOffControl_Stop_ppasvExtTakeoverHBOnOffControl_Stop ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverHBOnOffControlStop ( CONST(uint8, AUTOMATIC) HBOnOffControl ) { /* roExtTakeoverHBOnOffControlStop_Start User Code start*/ /* roExtTakeoverHBOnOffControlStop_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverLBOnOffControlStart * SYMBOL: roExtTakeoverLBOnOffControlStart ************************************************************ * RTE Events * OIT_ppasvExtTakeoverLBOnOffControl_Start_ppasvExtTakeoverLBOnOffControl_Start ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverLBOnOffControlStart ( CONST(uint8, AUTOMATIC) LBOnOffControl ) { /* roExtTakeoverLBOnOffControlStart_Start User Code start*/ /* roExtTakeoverLBOnOffControlStart_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverLBOnOffControlStop * SYMBOL: roExtTakeoverLBOnOffControlStop ************************************************************ * RTE Events * OIT_ppasvExtTakeoverLBOnOffControl_Stop_ppasvExtTakeoverLBOnOffControl_Stop ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverLBOnOffControlStop ( CONST(uint8, AUTOMATIC) LBOnOffControl ) { /* roExtTakeoverLBOnOffControlStop_Start User Code start*/ /* roExtTakeoverLBOnOffControlStop_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverPOSOnOffControlStart * SYMBOL: roExtTakeoverPOSOnOffControlStart ************************************************************ * RTE Events * OIT_ppasvExtTakeoverPOSOnOffControl_Start_ppasvExtTakeoverPOSOnOffControl_Start ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverPOSOnOffControlStart ( CONST(uint8, AUTOMATIC) POSOnOffControl ) { /* roExtTakeoverPOSOnOffControlStart_Start User Code start*/ /* roExtTakeoverPOSOnOffControlStart_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverPOSOnOffControlStop * SYMBOL: roExtTakeoverPOSOnOffControlStop ************************************************************ * RTE Events * OIT_ppasvExtTakeoverPOSOnOffControl_Stop_ppasvExtTakeoverPOSOnOffControl_Stop ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverPOSOnOffControlStop ( CONST(uint8, AUTOMATIC) POSOnOffControl ) { /* roExtTakeoverPOSOnOffControlStop_Start User Code start*/ /* roExtTakeoverPOSOnOffControlStop_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverTIOnOffControlStart * SYMBOL: roExtTakeoverTIOnOffControlStart ************************************************************ * RTE Events * OIT_ppasvExtTakeoverTIOnOffControl_Start_ppasvExtTakeoverTIOnOffControl_Start ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverTIOnOffControlStart ( CONST(uint8, AUTOMATIC) TIOnOffControl ) { /* roExtTakeoverTIOnOffControlStart_Start User Code start*/ /* roExtTakeoverTIOnOffControlStart_Start User Code end*/ } //#define ctasLedR_STOP_SEC_CODE //#include "ctasLedR_MemMap.h" /************************************************************ * Start User Prototypes - Do not remove this comment */ /* Add your prototypes here */ /* End User Prototypes - Do not remove this comment ************************************************************/ /************************************************************ * RUNNABLE: roExtTakeoverTIOnOffControlStop * SYMBOL: roExtTakeoverTIOnOffControlStop ************************************************************ * RTE Events * OIT_ppasvExtTakeoverTIOnOffControl_Stop_ppasvExtTakeoverTIOnOffControl_Stop ************************************************************ * Read API *********************************************** * Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&ptasrDataStatus_eCompleteCodingDataStatus); * Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&ptasrDataStatus_eFUSACodingDataStatus); * Rte_Read_ppareFctRLsTarget0_asVal(ptasrLsLmmTarget_asVal); * Rte_Read_pparePxAMxTarget0_asSetting(ptasrMxSegTarget_asSetting); * Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&ptasrAnimationEnable_sAnimationEnable); * Rte_Read_ppareSigPrepAnimationMode_AnimationMode(&ptasrSigPrepAnimationMode_AnimationMode); * Rte_Read_ppareSigPrepCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt(&ptasrCeremonyCmdSeqnCnt_sCeremonyCmdSeqnCnt); * Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&ptasrMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt); * Rte_Read_ppareSysMonIntSwitchStatusError0_asVal(ptasrIntSwitchStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_asVal(ptasrLsSafetyStatusError_asVal); * Rte_Read_ppareSysMonLsStatusError0_ucErrInternalCom(&ptasrLsSafetyStatusError_ucErrInternalCom); * Rte_Read_ppareSysMonMlcSwitchStatus0_sAllMlcSwitchStatusRecord(&ptasrMlcSwitchStatus_sAllMlcSwitchStatusRecord); * Rte_Read_ppareSysMonWelcomeLampFctReq_sWelcomeLampFct(&ptasrSysMonWelcomeLampFctReq_sWelcomeLampFct); * * CS API *********************************************** * Rte_Call_ppaclCddBoostSetPara_CddBoost_SetPara(Call_ptacsCddBoostSetPara_CddBoost_SetPara_pPara); * Rte_Call_ppaclCddLedSetPara_CddLed_SetPara(Call_ptacsCddLedSetPara_CddLed_SetPara_pPara); * Rte_Call_ppaclCPMLsLink0_SetLsLink(Call_ptacsAppMLsLink_SetLsLink_aulDrvChannelSwitch); * Rte_Call_ppaclIoHwAbUserMountingSide1_IoHwAbUser_GetMountingSide(Call_ptacsGetMountingSide_IoHwAbUser_GetMountingSide_peVal); * ************************************************************/ //#define ctasLedR_START_SEC_CODE //#include "ctasLedR_MemMap.h" FUNC(Std_ReturnType, ctasLedR_CODE) ctasCtrlLed_roExtTakeoverTIOnOffControlStop ( CONST(uint8, AUTOMATIC) TIOnOffControl ) { /* roExtTakeoverTIOnOffControlStop_Start User Code start*/ /* roExtTakeoverTIOnOffControlStop_Start User Code end*/ } #define ctasLedR_STOP_SEC_CODE #include "ctasLedR_MemMap.h"