//***************************************************************************** // (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 //PRQA S 5310, 5316, 5324, 5334, 5336, 5338 EOF //Program Architecture and Code Readability //#include // for Simulink code that is generated with TargetLink //used for VC1 #define REVISE_VERSION_VC1 #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_TO_BASE_PWM(pwm, base_pwm) (uint16)((uint32)(pwm) * CONV_LSB_1_328_U32((base_pwm) >> 1u) / CONV_LSB_1_328_U32(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) /// Coding data set 1 //STATIC_AL uint8 aucCodingData2[2000] = { 0u }; //typedef uint16 tiu16TimeDiff_ms; 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 //----------------------------------------------------------------------------- #ifdef REVISE_VERSION_VC1 #define ANIMATION_SEGMENT_NUM 81u #define MatrixMaskSegment1 0x0001 #define MatrixMaskSegment2 0x0002 #define MatrixMaskSegment3 0x0004 #define MatrixMaskSegment4 0x0008 #define MatrixMaskSegment5 0x0010 #define MatrixMaskSegment6 0x0020 #define MatrixMaskSegment7 0x0040 #define MatrixMaskSegment8 0x0080 #define MatrixMaskSegment9 0x0100 #define MatrixMaskSegment10 0x0200 #define MatrixMaskSegment11 0x0400 #define MatrixMaskSegment12 0x0800 STATIC_AL tesCeremonyCmdLeft1 Read_tesCeremonyCmdLeft_Test; //Left Segment STATIC_AL tesCeremonyCmdRight1 Read_tesCeremonyCmdRight_Test; //Right Segment uint8 AnimationMountingSide = 0u; uint8 CtrlLed_MountingSide = 0u; bool Flag_AnimationEnable = false; bool ADB2FOutStatus = false; uint16 CeremonyDataLeft1[ANIMATION_SEGMENT_NUM] = { 0 }; uint16 CeremonyDataRight1[ANIMATION_SEGMENT_NUM] = { 0 }; /* //VC1 HL Animation LED Segment mapping_v1.6 uint8 AniMappingLeft[60] = { 15,16,17,18,19,20,21,22,23,24,25,26, 27,28,29,30,31,32,33,34,35,36,37,38, 40,41,42,43,44,45,46,47,48,49,50,51, 52,53,54,55,56,57,58,59,60,61,62,63, 13,12,10,9,5,4,11,8,7,6,3,2, }; uint8 AniMappingRight[60] = { 15,16,17,18,19,20,21,22,23,24,25,26, 27,28,29,30,31,32,33,34,35,36,37,38, 40,41,42,43,44,45,46,47,48,49,50,51, 52,53,54,55,56,57,58,59,60,61,62,63, 4,5,9,10,12,13,11,8,7,6,3,2, }; //VC1 HL Animation LED Segment mapping_v1.7 uint8 AniMappingLeft[60] = { 38,37,36,35,34,33,32,31,30,29,28,27, 26,25,24,23,22,21,20,19,18,17,16,15, 63,62,61,60,59,58,57,56,55,54,53,52, 51,50,49,48,47,46,45,44,43,42,40,41, 13,12,10,9,5,4,11,8,7,6,3,2, }; uint8 AniMappingRight[60] = { 38,37,36,35,34,33,32,31,30,29,28,27, 26,25,24,23,22,21,20,19,18,17,16,15, 63,62,61,60,59,58,57,56,55,54,53,52, 51,50,49,48,47,46,45,44,43,42,40,41, 4,5,9,10,12,13,11,8,7,6,3,2, }; */ //VC1 HL Animation LED Segment mapping_v1.8 uint8 AniMappingLeft[60] = { 38,37,36,35,34,33,32,31,30,29,28,27, 26,25,24,23,22,21,20,19,18,17,15,16, 63,62,61,60,59,58,57,56,55,54,53,52, 51,50,49,48,47,46,45,44,43,42,40,41, 13,12,10,9,5,4,11,8,7,6,3,2, }; uint8 AniMappingRight[60] = { 38,37,36,35,34,33,32,31,30,29,28,27, 26,25,24,23,22,21,20,19,18,17,15,16, 63,62,61,60,59,58,57,56,55,54,53,52, 51,50,49,48,47,46,45,44,43,42,40,41, 4,5,9,10,12,13,11,8,7,6,3,2, }; /*uint16 SegmentMask[12] = { MatrixMaskSegment1,MatrixMaskSegment2,MatrixMaskSegment3,MatrixMaskSegment4, MatrixMaskSegment5, MatrixMaskSegment6, MatrixMaskSegment7,MatrixMaskSegment8,MatrixMaskSegment9,MatrixMaskSegment10,MatrixMaskSegment11,MatrixMaskSegment12, };*/ uint16 SegmentMask[12] = { 1,2,4,8,16,32,64,128,256,512,1024,2048}; 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; #endif // 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 }; // animation data //static tAnimation_Data CtrlLed_AnimationData[CTRLLED_CFG_LMM_MAX_NO_OF_VIRT_LS_CHANNELS] = { 0u }; //STATIC_AL tCtrlLed_Diag Ctrl_Diag; // 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 //{ 0, 40, 80, 120, 150, 180, 190, 200 }, //{ 0, 0, 0, 0, 0, 0, 0, 200 } { 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 //{ 0, 5, 24, 62, 103, 157, 178, 200 }, //{ 0, 0, 0, 0, 0, 0, 0, 200 } #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 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } #endif }; static tCtrlLed_LogicalChannel LS_X[LEDR_CFG_NO_OF_SINGLE_UNITS] = { 0u }; //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_Cycle50ms(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 uint16 CtrlLed_Interpolation(uint16 unInput, uint8 ucX_arr[8], uint8 ucY_arr[8], uint8 ucPointsNo); //STATIC_AL uint16 GetPWMValueFromCoding(uint8 ucCodedValue); 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); #ifndef REVISE_VERSION_VC1 void HandleAnimationBuckSetting(CtrlLed_tisLsTarget_perc TempBuckSetting[]); void HandleAnimationPwmValue(tiu16Percent_1_328 CeremonyData[8][16], uint8 MountingSide); #endif //STATIC_AL void CtrlLed_DTC_Handling(uint8 ucStatSafetyChType, tieError eErr); //----------------------------------------------------------------------------- /// \brief DTCs handling /// /// \descr Evaluate different errors and PASS/FAIL DTCs /// /// /// \param ucStatSafetyChType - channel assignation /// eErr - error status /// /// \return void //----------------------------------------------------------------------------- //STATIC_AL void CtrlLed_DTC_Handling(uint8 ucStatSafetyChType, tieError eErr) //{ // switch (ucStatSafetyChType) // { // case (uint8)StatCh_LB_FuSi: // case (uint8)StatCh_LB: // if (eErr == ERR_YES) // { // (void)FUNKTION_ABBLENDLICHT_DEFEKT(DEM_EVENT_STATUS_FAILED); // } // else // { // (void)FUNKTION_ABBLENDLICHT_DEFEKT(DEM_EVENT_STATUS_PASSED); // } // break; // case (uint8)StatCh_HB: // if (eErr == ERR_YES) // { // (void)FUNKTION_FERNLICHTLICHTHUPE_DEFEKT(DEM_EVENT_STATUS_FAILED); // } // else // { // (void)FUNKTION_FERNLICHTLICHTHUPE_DEFEKT(DEM_EVENT_STATUS_PASSED); // } // break; // case (uint8)StatCh_DRL: // if (eErr == ERR_YES) // { // (void)FUNKTION_TAGFAHRLICHTSTANDLICHTPARKLICHT_DEFEKT(DEM_EVENT_STATUS_FAILED); // } // else // { // (void)FUNKTION_TAGFAHRLICHTSTANDLICHTPARKLICHT_DEFEKT(DEM_EVENT_STATUS_PASSED); // } // break; // case (uint8)StatCh_SML: // if (eErr == ERR_YES) // { // (void)FUNKTION_SEITENMARKIERUNGSLICHT_DEFEKT(DEM_EVENT_STATUS_FAILED); // } // else // { // (void)FUNKTION_SEITENMARKIERUNGSLICHT_DEFEKT(DEM_EVENT_STATUS_PASSED); // } // break; // case (uint8)StatCh_CL: // if (eErr == ERR_YES) // { // (void)FUNKTION_ABBIEGELICHTAUTOBAHNLICHT_DEFEKT(DEM_EVENT_STATUS_FAILED); // } // else // { // (void)FUNKTION_ABBIEGELICHTAUTOBAHNLICHT_DEFEKT(DEM_EVENT_STATUS_PASSED); // } // break; // case (uint8)StatCh_TI: // if (eErr == ERR_YES) // { // (void)FUNKTION_FAHRTRICHTUNGSANZEIGER_DEFEKT(DEM_EVENT_STATUS_FAILED); // } // else // { // (void)FUNKTION_FAHRTRICHTUNGSANZEIGER_DEFEKT(DEM_EVENT_STATUS_PASSED); // } // break; // default: // break; // } // // // TBD // // (void)MATRIX_LED_CONTROLLER_SEGMENTABSCHALTUNG_FEHLGESCHLAGEN(0); //} //----------------------------------------------------------------------------- /// \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 = 0; if (unH_Opt != 0u) { switch (ucGammaAllocation) { case LEDR_GAMMA_CURVE_IDX_1: // Apply gamma curve 1 //unGammaCorr = CtrlLed_Interpolation(unH_Opt, Gamma_X[LEDR_GAMMA_CURVE_IDX_1 - 1u], Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - 1u], LEDR_CFG_GAMMA_CURVE_POINTS_NO); unGammaCorr = UtilMath_FastInterpolateU16_N17(Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - 1u], unH_Opt); //unGammaCorr = UtilMath_LinearInterpolateU16(Gamma_X[LEDR_GAMMA_CURVE_IDX_1 - 1u], Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - 1u], LEDR_CFG_GAMMA_CURVE_POINTS_NO, unH_Opt); break; case LEDR_GAMMA_CURVE_IDX_2: // Apply gamma curve 2 //unGammaCorr = CtrlLed_Interpolation(unH_Opt, Gamma_X[LEDR_GAMMA_CURVE_IDX_2 - 1u], Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - 1u], LEDR_CFG_GAMMA_CURVE_POINTS_NO); unGammaCorr = UtilMath_FastInterpolateU16_N17(Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - 1u], unH_Opt); //unGammaCorr = UtilMath_LinearInterpolateU16(Gamma_X[LEDR_GAMMA_CURVE_IDX_2 - 1u], Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - 1u], LEDR_CFG_GAMMA_CURVE_POINTS_NO, 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 = 0; if (unDutyCycle != 0u) { switch (ucGammaAllocation) { case LEDR_GAMMA_CURVE_IDX_1: // Apply gamma curve 1 //unGammaCorr = CtrlLed_Interpolation(unDutyCycle, Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - 1u], Gamma_X[LEDR_GAMMA_CURVE_IDX_1 - 1u], LEDR_CFG_GAMMA_CURVE_POINTS_NO); unGammaCorr = UtilMath_LinearInterpolateU16(Gamma_Y[LEDR_GAMMA_CURVE_IDX_1 - 1u], Gamma_X[LEDR_GAMMA_CURVE_IDX_1 - 1u], (sint32) LEDR_CFG_GAMMA_CURVE_POINTS_NO, unDutyCycle); break; case LEDR_GAMMA_CURVE_IDX_2: // Apply gamma curve 2 //unGammaCorr = CtrlLed_Interpolation(unDutyCycle, Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - 1u], Gamma_X[LEDR_GAMMA_CURVE_IDX_2 - 1u], LEDR_CFG_GAMMA_CURVE_POINTS_NO); unGammaCorr = UtilMath_LinearInterpolateU16(Gamma_Y[LEDR_GAMMA_CURVE_IDX_2 - 1u], Gamma_X[LEDR_GAMMA_CURVE_IDX_2 - 1u], (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 = 0u; uint8 ucIdx = 0u; uint8 ucLMMIllum_No = 0u; // go thru all logical single units for (ucIdx = 0; 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 = 0u; 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 + 1u); // 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 = 0u; } 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 = 0u; tisLsSafetyStatusErrorArr LsSafetyStatusErrorArr; tisVirtLsStatusFaultArr LsStatusFaultArr; tisVirtLsStatusFaultArr LsStatusFaultArr_prev; tisMxSegStatusErrorArr ppCtrlLedMxSwitchStatusError0; tisAllMlcSwitchStatus ppAllMlcSwitchStatus; tisAnimationEnable CeremonyCammand_Enable; // S Drv2 -> buck channels status (void)Rte_Read_LsStatusError0_asVal((tisLsSafetyStatusError *)LsSafetyStatusErrorArr); //Buck // CtrPxl -> MLC switches status (void)Rte_Read_SwitchStatusError0_asVal(&ppAllMlcSwitchStatus); //Lmm //Read AniEnable Signal Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&CeremonyCammand_Enable); //Clear the faults for (ucIdx = 0; ucIdx < LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS; ucIdx++) //12 { LsStatusFaultArr[ucIdx].eErr = ERR_SNA; //0 } #ifndef REVISE_VERSION_VC1 for (ucIdx = 0; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) //103 { // 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 a channel is not having any error then update it if (LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr != ERR_YES) { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = (tieError)DRV_ERR_STAT(LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u]) != FALSE ? ERR_YES : ERR_NO; } else { //Do nothing } LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eStatOn = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eStatOn; LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].unStatCurrent = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unStatCurrent; LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].unStatDutyCycle = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unStatDutyCycle; } // MLC is detected if ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard >= 0x01u) && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard <= 0x08u)) { uint8 ucDevIdx = LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u; 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) || (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 = ERR_YES; } else { //Do nothing } // MLC is detected and used by PXA 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 - 1u].eErr = ERR_YES; } else { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - 1u].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 - 1u].unStatDutyCycle = LS_X[ucIdx].PWM_PXA; } else { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - 1u].unStatDutyCycle = 0u; } // Update the pixel status ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - 1u].eStatOn = ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eStatSupported; } } } #else for (ucIdx = 0; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) //103 { // 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 - 1u].eErr != ERR_YES) { if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrOpenLoad == ERR_YES) //OpenLoad { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 1U; } else if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrShortToGnd == ERR_YES) //ShortToGnd { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 2U; } else if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrShortToSupply == ERR_YES) //ShortToSupply { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 3U; } else if (LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrDrvInternal == ERR_YES) //LED driver error //LED driver error { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 4U; } else if ((LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrOvercurrent == ERR_YES)) //Overcurrent { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 5U; } else if ((LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrDrvThermalShutdown == ERR_YES)) //ThermalShutdown { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 6U; } else if ((LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErrVLedOutOfTolerance == ERR_YES)) //Voltage out of tolerance { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 7U; } else //Normal { LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 0U; } } else { //LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eErr = 0U; } LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].eStatOn = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eStatOn; LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].unStatCurrent = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unStatCurrent; LsStatusFaultArr[LS_X[ucIdx].LMM_IllumNo - 1u].unStatDutyCycle = LsSafetyStatusErrorArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].unStatDutyCycle; } // MLC is detected if ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard >= 0x01u) && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard <= 0x05u)) //ucIdx > 11 { uint8 ucDevIdx = LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u; 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)) { //LsStatusFaultArr[LS_X[ucIdx].ChConfig.Led_DriverID - 1u].eErr = 10U; //MLC LED error if ((ucDevIdx == 4) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 5)) //HB Driver9 { LsStatusFaultArr[3].eErr = 10U; } if ((ucDevIdx == 4) && (ucSegmentIdx >= 6) && (ucSegmentIdx <= 11)) //HB Driver3 { LsStatusFaultArr[2].eErr = 10U; } if ((ucDevIdx == 3) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //TI Driver7 { LsStatusFaultArr[1].eErr = 10U; } if ((ucDevIdx == 1) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //TI Driver4 { LsStatusFaultArr[0].eErr = 10U; } if ((ucDevIdx == 0) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //DRL/POS Driver10 { LsStatusFaultArr[5].eErr = 10U; } if ((ucDevIdx == 2) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //DRL/POS Driver12 { LsStatusFaultArr[6].eErr = 10U; } } 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 == 4) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 5)) //HB Driver9 { LsStatusFaultArr[3].eErr = 11U; } if ((ucDevIdx == 4) && (ucSegmentIdx >= 6) && (ucSegmentIdx <= 11)) //HB Driver3 { LsStatusFaultArr[2].eErr = 11U; } if ((ucDevIdx == 3) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //TI Driver7 { LsStatusFaultArr[1].eErr = 11U; } if ((ucDevIdx == 1) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //TI Driver4 { LsStatusFaultArr[0].eErr = 11U; } if ((ucDevIdx == 0) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //DRL/POS Driver10 { LsStatusFaultArr[5].eErr = 11U; } if ((ucDevIdx == 2) && (ucSegmentIdx >= 0) && (ucSegmentIdx <= 11)) //DRL/POS Driver12 { LsStatusFaultArr[6].eErr = 11U; } } 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 - 1u].eErr = ERR_YES; } else { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - 1u].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 - 1u].unStatDutyCycle = LS_X[ucIdx].PWM_PXA; } else { ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - 1u].unStatDutyCycle = 0u; } // Update the pixel status ppCtrlLedMxSwitchStatusError0[LS_X[ucIdx].MatrixIdx - 1u].eStatOn = ppAllMlcSwitchStatus.asMlcStatusVal[ucDevIdx].asMxStatusFault[ucSegmentIdx].eStatSupported; } } } #endif if((CeremonyCammand_Enable.aboAnimationEnb == 1u) && (CeremonyCammand_Enable.eAnimationEnbQty == 0u)) //Diagnostic results are not invoked in animated mode { for (ucIdx = 0; ucIdx < LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS; ucIdx++) { LsStatusFaultArr[ucIdx].eErr = ERR_SNA; } } else { //do nothing } // store previous LsStatusFaultArr status (void)Rte_Memcpy(&LsStatusFaultArr_prev, &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 = 0u; // go thru all logical single units and copy the PWM data (LMM vs PXA) based on Prio for (ucIdx = 0; 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 (LS_X[ucIdx].PWM_Anima == 0u) { // in case PXA has an higher prio than LMM -> use PXA PWM if (LS_X[ucIdx].MatrixPrio != LEDR_PRIO_DEFAULT) { if (LS_X[ucIdx].LMM_IllumPrio != LEDR_PRIO_DEFAULT) { if (LS_X[ucIdx].MatrixPrio <= LS_X[ucIdx].LMM_IllumPrio) //11-30 { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_PXA; } else { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_LMM; } //if ((LS_X[ucIdx].MatrixPrio == 0u) && (LS_X[ucIdx].PWM_LMM != 0u)) //{ // LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_LMM; //} } else { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_PXA; } } else if (LS_X[ucIdx].LMM_IllumPrio != LEDR_PRIO_DEFAULT) { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_LMM; } else { LS_X[ucIdx].PWM = CTRLLED_PWM_ZERO; } } else { LS_X[ucIdx].PWM = LS_X[ucIdx].PWM_Anima; } } } } //----------------------------------------------------------------------------- /// \brief Map logical channels /// /// \descr Map single and group logical channels /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_LSMaping(void) { uint8 ucChNo = 0u; uint8 ucIdx = 0u; uint8 ucIdx_3 = 0u; uint8 ucLocalAssignCh = 0u; uint8 ucChannelGroup_Config[LEDR_CFG_COD_UNITxxx_CONFIG_NO_OF_BYTES] = { 0u }; uint8 ppCtrlLedLsTarget0_aucEnable[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS] = { 0u }; //AnimMa_setCodingData(Cod_GetAnimMaBlock()); //AnimMa_setCodingData(CodPrj_GetAnimMaBlock()); // start logical channel mapping - LMM based for (ucChNo = 0u; 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 = 0; ucIdx < LEDR_CFG_COD_UNITxxx_CONFIG_NO_OF_BYTES; ucIdx++) { // for each byte search for logical single channels for (ucIdx_3 = 0; ucIdx_3 < 8u; ucIdx_3++) { if (CHECK_BIT(ucChannelGroup_Config[ucIdx], ucIdx_3) != FALSE) { // Light source no. assigned to LightSourceGroup // TODO LogicalChGroup is never referenced -> can be deleted? LOC doesn't make sense. LS_X[(ucIdx * 8u) + 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 * 8u) + ucIdx_3].LMM_UsedIllum.unRaw, ucChNo); } } } } else { // LOGICAL_CH_NOT_USED } } // end logical channel mapping // Channel config mapping for (ucIdx = 0; 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 = 0; ucIdx < LEDR_CFG_MATRIX_NO_OF_SEGMENTS; ucIdx++) { if (Cod_GetLogicalUnitMtx(ucIdx) >(uint8) 0u) { LS_X[Cod_GetLogicalUnitMtx(ucIdx) - 1u].MatrixIdx = (ucIdx + 1u); } } for (ucIdx = 0; ucIdx < ANIMMA_NR_PIXELS; ucIdx++) { if (Cod_GetLogicalUnitAni(ucIdx) > (uint8)0u) { LS_X[Cod_GetLogicalUnitAni(ucIdx) - 1u].AnimaIdx = (ucIdx + 1u); } } for (ucIdx = 0; ucIdx < LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS; ucIdx++) { ppCtrlLedLsTarget0_aucEnable[ucIdx] = 1u; } // go thru all LS and update aulDrvChannelSwitch and ppCtrlLedExtSwitchTarget0_aulDrvChannel ports //for (ucIdx = 0u; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) //{ // if (LS_X[ucIdx].ChConfig.Led_DriverID > (uint8) 0u) // { // if ((uint32) LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard == (uint32) 0u) // { // aulDrvChannelSwitch[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = (uint32)LS_X[ucIdx].ChConfig.Led_DriverID - 1u; // copy LED driver ID no -1 (to sync with AppM) // } // // 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)) // { // ppCtrlLedExtSwitchTarget0_aulDrvChannel[LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u][LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = (uint32)LS_X[ucIdx].ChConfig.Led_DriverID - 1u; // copy LED driver ID no -1 (to sync with AppM) // aulDrvChannelSwitch[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = 0xFFFFFFFFu; // ppCtrlLedLsTarget0_aucEnable[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = 0u; // } // // update ppCtrlLedExtSwitchTarget0_aunDutyCycle with bypass data // if ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard >= 0x09u) && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard <= 0x0Cu)) // 9=DRV (FLEX00?!) ; 10..12=FLEX01-03 // { // aulDrvChannelSwitch[LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS + ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 0x09u) * 2u) + LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = (uint32)LS_X[ucIdx].ChConfig.Led_DriverID - 1u; // copy LED driver ID no -1 (to sync with AppM) // } // } //} //(void)Rte_Call_ppCodingData0_GetCHANNEL_GROUP_02_CONFIG(ucChGroup_02); //for (ucIdx = 1u; ucIdx <= (sizeof(aulDrvChannelParallel) / sizeof(aulDrvChannelParallel[0])); ucIdx++) //{ // if ((ucChGroup_02[0] & 0x0Fu) == ucIdx) // { // aulDrvChannelParallel[ucIdx - 1u] = (uint32)ucIdx; // } // else if ((ucChGroup_02[0] & 0xF0u) == ucIdx) // { // aulDrvChannelParallel[ucIdx - 1u] = (uint32)ucIdx; // } // else // { // // nop // } //} //(void)Rte_Call_ppAppMLsLink0_SetLsLink((const uint32 *)aulDrvChannelSwitch); //(void)Rte_Call_ppSysMonLsLink0_SetLsLink((const uint32 *)aulDrvChannelSwitch); //(void)Rte_Call_ppCddLedLsLink0_SetLsLink((const uint32 *)aulDrvChannelParallel, (const uint32 *)aulDrvChannelSwitch); //(void)Rte_Write_ppCtrlLedExtSwitchTarget0_aulDrvChannel((const tiu32LsChannelArr16 *)ppCtrlLedExtSwitchTarget0_aulDrvChannel[0]); 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 = 0u; uint8 ucGammaAllocation = 0u; uint16 unPWM_Ramp[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS]; CtrlLed_tisLsLmmTarget tmpFctRLsTarget0[LEDR_CFG_LSM_MAX_NO_OF_VIRT_LS_CHANNELS]; (void)Rte_Read_LsTarget0_asVal(tmpFctRLsTarget0); 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(100u); // send 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 { // nop } } 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 = 0u; uint8 ucMatrixGammaAlloc = Cod_GetGammaIndexMtx(); // go thru all anima pixels and perform ramp up / ramp down for (ucIdx = 0u; ucIdx < ANIMMA_NR_PIXELS; ucIdx++) { // Anima is active if ((AnimMaRamp_aucPxlIntTgt[ucIdx] * 328u) > CtrlLed_aunAnimaRamp[ucIdx]) { // Ramp Up CtrlLed_aunAnimaRamp[ucIdx] += (AnimMaRamp_aucPxlIntInc[ucIdx] * 328u); //If value exceeds over the target value, limit it to the target value if (CtrlLed_aunAnimaRamp[ucIdx] > (AnimMaRamp_aucPxlIntTgt[ucIdx] * 328u)) { CtrlLed_aunAnimaRamp[ucIdx] = AnimMaRamp_aucPxlIntTgt[ucIdx] * 328u; } else { //Do Nothing } } else if ((AnimMaRamp_aucPxlIntTgt[ucIdx] * 328u) < CtrlLed_aunAnimaRamp[ucIdx]) { // Ramp down if (CtrlLed_aunAnimaRamp[ucIdx] < (AnimMaRamp_aucPxlIntDec[ucIdx] * 328u)) { CtrlLed_aunAnimaRamp[ucIdx] = 0; } else { CtrlLed_aunAnimaRamp[ucIdx] -= (AnimMaRamp_aucPxlIntDec[ucIdx] * 328u); } } else { CtrlLed_aunAnimaRamp[ucIdx] = (AnimMaRamp_aucPxlIntTgt[ucIdx] * 328u); } (*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]) { CtrlLed_tisMxSegTarget tmpMxSegTargetArr[LEDR_CFG_MATRIX_NO_OF_SEGMENTS]; uint8 ucMatrixGammaAlloc = Cod_GetGammaIndexMtx(); uint8 ucChNo = 0u; // allow App control if diag is not active //if (Ctrl_Diag.MatrixSegmente.DiagStat == FALSE) { // Read PXA data (void)Rte_Read_MxTarget0_asSetting(tmpMxSegTargetArr); } //else //{ // tmpMxSegTargetArr[Ctrl_Diag.MatrixSegmente.MatrixSeg_No].unBrightness = CONV_LSB_1_328_U16(Ctrl_Diag.MatrixSegmente.MatrixSeg_Pwm); // tmpMxSegTargetArr[Ctrl_Diag.MatrixSegmente.MatrixSeg_No].unRampTimeDown = 0u; // tmpMxSegTargetArr[Ctrl_Diag.MatrixSegmente.MatrixSeg_No].unRampTimeUp = 0u; // tmpMxSegTargetArr[Ctrl_Diag.MatrixSegmente.MatrixSeg_No].ucPriority = CTRLLED_PRIO_HIGHEST; // highest priority //} 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 > 0u) { (*aunPXA_DutyCycle)[ucChNo].PXAPrio = CtrlLed_aucPXAPrio[ucChNo]; } else if (tmpMxSegTargetArr[ucChNo].ucPriority == LEDR_PRIO_DEFAULT) { (*aunPXA_DutyCycle)[ucChNo].PXAPrio = LEDR_PRIO_DEFAULT; } else { // nop } // start PXA Gamma HOPT TO HPWM (*aunPXA_DutyCycle)[ucChNo].unDutyCycle = CtrlLed_GammaCorrection((*aunPXA_DutyCycle)[ucChNo].unDutyCycle , ucMatrixGammaAlloc); } // end PXA Gamma } //----------------------------------------------------------------------------- /// \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 = 0u; // assign the pixel X PWM to the related Light source for (ucIdx = 0u; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) { // 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 - 1u].unDutyCycle; // include matrix prio LS_X[ucIdx].MatrixPrio = aunPXA_DutyCycle[LS_X[ucIdx].MatrixIdx - 1u].PXAPrio; } if (LS_X[ucIdx].AnimaIdx > 0u) { // store the AnimMa PWM LS_X[ucIdx].PWM_Anima = (*aunAnima_DutyCycle)[LS_X[ucIdx].AnimaIdx - 1u]; } } } //----------------------------------------------------------------------------- /// \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]) { //#ifdef REVISE_VERSION_VC1 //if (Flag_AnimationEnable == false) //{ // go thru all LS and update ppCtrlLedLsTarget0_asSetting and ppCtrlLedExtSwitchTarget0_aunDutyCycle ports for (uint8 ucIdx = 0u; 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 != 0u) // && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard == 0x09)) { if (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard == 0x00u) //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) != 0U && (LS_X[ucIdx].LMM_IllumNo != 0U)) { (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = CodPrj_GetLogicalUnitThermozoneIdx(ucIdx); } else { (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = 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)) { boolean boUseLMM = FALSE; boolean boIsBuckPWM = FALSE; //buck pwm not used if (boIsBuckPWM == FALSE) { // 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); // (*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); } //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) != 0u) { (*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); // set intensity to 100% for MLC if (LS_X[ucIdx].PWM != CTRLLED_PWM_ZERO) { (*ppCtrlLedExtSwitchTarget0_aunDutyCycle)[LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard - 1u][LS_X[ucIdx].ChConfig.MLC_Data.MLC_SwitchNo] = 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) != 0U) { (*ppCtrlLedLsTarget0_aulThermozone)[LS_X[ucIdx].ChConfig.Led_DriverID - 1u] = CodPrj_GetLogicalUnitThermozoneIdx(ucIdx); } } } } } // } //else //{ // for (uint8 ucIdx = 0u; ucIdx < ANIMATION_SEGMENT_NUM; ucIdx++) // { // LS_X[ANIMATION_SEGMENT_NUM].PWM = AnimationData_Rte[ANIMATION_SEGMENT_NUM]; // } // for (uint8 ucIdx = 0u; ucIdx < LEDR_CFG_NO_OF_SINGLE_UNITS; ucIdx++) // { // /*Note_Annotation*/ // if ((LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard >= 0x01u) && (LS_X[ucIdx].ChConfig.MLC_Data.MLC_OnBoard <= 0x08u)) // { // /*Note_Annotation set intensity to 100% for BUCK*/ // (*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); // /*Note_Annotation* buck pwm not used/ // /*Note_Annotation 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); // } // } //} //#endif } //----------------------------------------------------------------------------- /// \brief initialisation function for CtrlLed /// /// \descr /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- STATIC_AL void CtrlLed_Init(void) { uint8 ucIdx = 0u; CtrlLed_tieMountingSide ucSide = 0xFFU; #ifdef REVISE_VERSION_VC1 Flag_AnimationEnable = false; #endif for (ucIdx = 0u; 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; } (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 de initialisation function for CtrlLed /// /// \descr /// /// /// \param void /// /// \return void //----------------------------------------------------------------------------- //STATIC_AL void CtrlLed_DeInit(void) //{ // //} //----------------------------------------------------------------------------- /// \brief cyclic function for CtrlLed /// /// \descr CtrlLed_Cycle50ms() process the pixel animation /// /// \param void /// /// \return void //----------------------------------------------------------------------------- //STATIC_AL void CtrlLed_Cycle50ms(void) //{ // //(void)rcAnimMa50(); //} //----------------------------------------------------------------------------- /// \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 = 0u; uint8 ucIdx_1 = 0u; //CtrlLed_tieMountingSide ucSide = 0xFFU; uint16 *LeftTempPonit; uint16 *RightTempPonit; uint16 CeremonyLeftOutPut[ANIMATION_SEGMENT_NUM]; uint16 CeremonyRightOutPut[ANIMATION_SEGMENT_NUM]; tisMatrixAnimaLedTgt MatrixAnimaLedTgtReq; tisAnimationEnable CeremonyCammand_Enable; 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]; uint8 ppCtrlLedExtSwitchTarget0_aucEnable[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC]; tiu16Percent_1_328 ppCtrlLedExtSwitchTarget0_aunDutyCycle[CTRLLED_CFG_MAX_NO_OF_MLC][CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC]; (void)Rte_Memset(ppCtrlLedLsTarget0_aulThermozone, 0xFF, sizeof(tiu32Thermozone)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); (void)Rte_Memset(ppCtrlLedExtSwitchTarget0_aulThermozone, 0xFF, sizeof(tiu32Thermozone)*CTRLLED_CFG_MAX_NO_OF_MLC*CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC); (void)Rte_Memset(aunAnimationDetection, 0x0, sizeof(uint16)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); (void)Rte_Memset(ppCtrlLedLsTarget0_asSetting, 0x0, sizeof(CtrlLed_tisLsTarget_perc)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); (void)Rte_Memset(ppCtrlLedExtSwitchTarget0_aucEnable, 0x0, sizeof(uint8)*CTRLLED_CFG_MAX_NO_OF_MLC*CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC); (void)Rte_Memset(ppCtrlLedExtSwitchTarget0_aunDutyCycle, 0x0, sizeof(tiu16Percent_1_328)*CTRLLED_CFG_MAX_NO_OF_MLC*CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC); (void)Rte_Memset(CeremonyLeftOutPut, 0x0, sizeof(CeremonyLeftOutPut)); (void)Rte_Memset(CeremonyRightOutPut, 0x0, sizeof(CeremonyRightOutPut)); (void)Rte_Memset(&CeremonyCammand_Enable, 0x0, sizeof(tisAnimationEnable)); #undef REVISE_VERSION_VC1 #ifdef REVISE_VERSION_VC1 // Read Ani Enable Flag //Flag_AnimationEnable = true; //Read Ani Segment Data if (Flag_AnimationEnable == true) { for (ucIdx = 0; ucIdx < ANIMATION_SEGMENT_NUM; ucIdx++) { AnimationData_Rte[ANIMATION_SEGMENT_NUM] = 0xFF; } } // Validate the coding data CtrlLed_CodingDataValidation(); if (Flag_AnimationEnable == false) { //Clear the array before writing Data (void)Rte_Memset(AnimationData_Rte, 0x0, sizeof(uint8)*ANIMATION_SEGMENT_NUM); // 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(); } else { //Clear the array before writing Data (void)Rte_Memset(aunAnimationDetection, 0x0, sizeof(uint16)*LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS); //12 (void)Rte_Memset(ppCtrlLedExtSwitchTarget0_aucEnable, 0x0, sizeof(uint8)*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 CtrlLed_Update(&ppCtrlLedLsTarget0_asSetting, &ppCtrlLedExtSwitchTarget0_aunDutyCycle, &aunAnimationDetection, &ppCtrlLedLsTarget0_aulThermozone, &ppCtrlLedExtSwitchTarget0_aulThermozone); /*Note_Annotation*/ Rte_Write_ExtSwitchTarget0_aunDutyCycle((const tiu16Percent_1_328Arr16 *)ppCtrlLedExtSwitchTarget0_aunDutyCycle); Rte_Write_LsTarget0_asSetting((const CtrlLed_tisLsTarget_perc *)ppCtrlLedLsTarget0_asSetting); if (Flag_AnimationEnable == false) { Rte_Write_LsTarget0_aulThermozone((const tiu32Thermozone*)ppCtrlLedLsTarget0_aulThermozone); Rte_Write_ExtSwitchTarget0_aulThermozone((const tiu32ThermozoneArr16*)ppCtrlLedExtSwitchTarget0_aulThermozone); } else { // do nothing } // ppCtrlLedExtSwitchTarget0_aucEnable -> set it as 1 as a first step for (ucIdx = 0; ucIdx < CTRLLED_CFG_MAX_NO_OF_MLC; ucIdx++) { for (ucIdx_1 = 0; ucIdx_1 < CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC; ucIdx_1++) { ppCtrlLedExtSwitchTarget0_aucEnable[ucIdx][ucIdx_1] = 1; } } Rte_Write_ExtSwitchTarget0_aucEnable((const uint8 *)ppCtrlLedExtSwitchTarget0_aucEnable[0]); // CtrlLed_DrvErr_Handling(); #else // Validate the coding data CtrlLed_CodingDataValidation(); //Rte_Call_GetMountingSide(&ucSide); //mover mountingside check to INIT Rte_Read_ppareSigPrepAnimationEnable_sAnimationEnable(&CeremonyCammand_Enable); if((CeremonyCammand_Enable.aboAnimationEnb == 1u) && (CeremonyCammand_Enable.eAnimationEnbQty == 0u)) //Enable { Flag_AnimationEnable = true; } else { Flag_AnimationEnable = false; //Disable } //mover mountingside check to INIT //if (ucSide == eIoHwAbUser_MountingSide_Left) //{ // CtrlLed_MountingSide = CTRLLED_MOUNTINSIDE_LEFT; //} //else if (ucSide == eIoHwAbUser_MountingSide_Right) //{ // CtrlLed_MountingSide = CTRLLED_MOUNTINSIDE_RIGHT; //} //else //{ // CtrlLed_MountingSide = ANIMMA_MOUNTINGSIDE_UNKNOWN; //} if (FlagtoControl2F == 1U) { if (CornerLightControlto2F == true) { ppCtrlLedLsTarget0_asSetting[7].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[7].unDutyCycle = 32768u; } else { ppCtrlLedLsTarget0_asSetting[7].unCurrent = 0u; ppCtrlLedLsTarget0_asSetting[7].unDutyCycle = 0u; } if (ADBMatrixContro2F != 0) { ucADBMatrixContro2F = ADBMatrixContro2F; utADBMatrixContro2F = ADBMatrixContro2F; ucADBMatrixContro2F = (ucADBMatrixContro2F >> 8); utADBMatrixContro2F = (utADBMatrixContro2F << 8); utADBMatrixContro2F = (utADBMatrixContro2F | ucADBMatrixContro2F) & 0x0FFF; //max. PWM duty cycle (100%) ppCtrlLedLsTarget0_asSetting[2].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[2].unDutyCycle = 32768u; ppCtrlLedLsTarget0_asSetting[8].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[8].unDutyCycle = 32768u; } else { //min. PWM duty cycle (100%) ppCtrlLedLsTarget0_asSetting[2].unCurrent = 0u; ppCtrlLedLsTarget0_asSetting[2].unDutyCycle = 0u; ppCtrlLedLsTarget0_asSetting[8].unCurrent = 0u; ppCtrlLedLsTarget0_asSetting[8].unDutyCycle = 0u; } for (uint8 index = 0; index < 12u; index++) { ADB2FSegments = (utADBMatrixContro2F & SegmentMask[index]); if (ADB2FSegments == SegmentMask[index]) { if ((ADB2FSegments > 0) && (ADB2FSegments <= SegmentMask[index])) { ADB2FOutStatus = true; } else { ADB2FOutStatus = false; } } else { if ((ADB2FSegments > 0) && (ADB2FSegments < SegmentMask[index])) { ADB2FOutStatus = true; } else { ADB2FOutStatus = false; } } ADBMatrixControChannelEnable(index, ppCtrlLedExtSwitchTarget0_aunDutyCycle[4], ADB2FOutStatus); } } else if(Flag_AnimationEnable == true) { for (ucIdx_1 = 2; ucIdx_1 < 4; ucIdx_1++) //2,3 { ppCtrlLedLsTarget0_asSetting[ucIdx_1].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[ucIdx_1].unDutyCycle = 32768u; } for (ucIdx_1 = 8; ucIdx_1 < 10; ucIdx_1++) //8,9 { ppCtrlLedLsTarget0_asSetting[ucIdx_1].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[ucIdx_1].unDutyCycle = 32768u; } ppCtrlLedLsTarget0_asSetting[6].unCurrent = 32768u; //6 ppCtrlLedLsTarget0_asSetting[6].unDutyCycle = 32768; ppCtrlLedLsTarget0_asSetting[11].unCurrent = 32768u; //11 ppCtrlLedLsTarget0_asSetting[11].unDutyCycle = 32768u; for (ucIdx_1 = 0; ucIdx_1 < 2; ucIdx_1++) //0,1 //TI2 0 { ppCtrlLedLsTarget0_asSetting[ucIdx_1].unCurrent = 0u; ppCtrlLedLsTarget0_asSetting[ucIdx_1].unDutyCycle = 0u; } for (ucIdx_1 = 4; ucIdx_1 < 6; ucIdx_1++) //4,5 //LB 4 //Sig 5 { ppCtrlLedLsTarget0_asSetting[ucIdx_1].unCurrent = 0u; ppCtrlLedLsTarget0_asSetting[ucIdx_1].unDutyCycle = 0u; } ppCtrlLedLsTarget0_asSetting[7].unCurrent = 0u; //7 //CL 7 ppCtrlLedLsTarget0_asSetting[7].unDutyCycle = 0u; ppCtrlLedLsTarget0_asSetting[10].unCurrent = 0u; //10 //DRL2 10 ppCtrlLedLsTarget0_asSetting[10].unDutyCycle = 0u; //LeftTempPonit = &(Read_tesCeremonyCmdLeft_Test.Left1CereSegment01); //RightTempPonit = &(Read_tesCeremonyCmdRight_Test.Right1CereSegment01); Rte_Read_ppareSigPrepMatrixAnimaLedTgtReq_sMatrixAnimaLedTgt(&MatrixAnimaLedTgtReq); LeftTempPonit = &(MatrixAnimaLedTgtReq.aucLedTarget[0]); RightTempPonit = &(MatrixAnimaLedTgtReq.aucLedTarget[0]); for (ucIdx_1 = 0; ucIdx_1 < 65u; ucIdx_1++) //A total of 64 channel mappings were used this time { CeremonyDataLeft1 [ucIdx_1] = LeftTempPonit[ucIdx_1]; CeremonyDataRight1[ucIdx_1] = RightTempPonit[ucIdx_1]; } if (CtrlLed_MountingSide == CTRLLED_MOUNTINSIDE_LEFT) //Left { for (ucIdx_1 = 0; ucIdx_1 < 65u; ucIdx_1++) { CeremonyLeftOutPut[ucIdx_1] = (uint16)(((CeremonyDataLeft1[ucIdx_1] * 255u) / 255u) * 32767u /255u ); //CeremonyLeftOutPut[ucIdx_1] = CtrlLed_GammaCorrection(CeremonyLeftOutPut[ucIdx_1], 1u); } } else if (CtrlLed_MountingSide == CTRLLED_MOUNTINSIDE_RIGHT) //Right { for (ucIdx_1 = 0; ucIdx_1 < 65u; ucIdx_1++) { CeremonyRightOutPut[ucIdx_1] = (uint16)(((CeremonyDataRight1[ucIdx_1] *255) / 255u) * 32767u /255u ); //CeremonyRightOutPut[ucIdx_1] = CtrlLed_GammaCorrection(CeremonyRightOutPut[ucIdx_1], 1u); } } else { //do nothing } for (ucIdx_1 = 0; ucIdx_1 < 65u; ucIdx_1++) //A total of 64 channel mappings were used this time { if (CtrlLed_MountingSide == CTRLLED_MOUNTINSIDE_LEFT) //Left { if ((ucIdx_1 >= 0u) && (ucIdx_1 < 12u)) //Segments 1-12 DRL1_1 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[0][11 - ucIdx_1] = CeremonyLeftOutPut[AniMappingLeft[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 12u) && (ucIdx_1 < 24u)) //Segments 13-24 DRL1_2 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[2][23 - ucIdx_1] = CeremonyLeftOutPut[AniMappingLeft[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 24u) && (ucIdx_1 < 36u)) //Segments 25-36 TI1_1 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[1][35 - ucIdx_1] = CeremonyLeftOutPut[AniMappingLeft[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 36u) && (ucIdx_1 < 48u)) //Segments 37-48 TI1_2 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[3][47 - ucIdx_1] = CeremonyLeftOutPut[AniMappingLeft[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 48u) && (ucIdx_1 < 60u)) //Segments 49-60 HB { ppCtrlLedExtSwitchTarget0_aunDutyCycle[4][ucIdx_1 - 48] = CeremonyLeftOutPut[AniMappingLeft[ucIdx_1] - 1]; //Lmm Switch 1-12 } else if (ucIdx_1 == 60u) //Segments 61 TI2 64-1 { ppCtrlLedLsTarget0_asSetting[0].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[0].unDutyCycle = CeremonyLeftOutPut[63]; } else if (ucIdx_1 == 61u) //Segments 62 DRL2 39-1 { ppCtrlLedLsTarget0_asSetting[10].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[10].unDutyCycle = CeremonyLeftOutPut[38]; } else if (ucIdx_1 == 62u) //Segments 63 LB 1-1 { ppCtrlLedLsTarget0_asSetting[4].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[4].unDutyCycle = CeremonyLeftOutPut[0]; } else if (ucIdx_1 == 63u) //Segments 64 CL 65-1 { ppCtrlLedLsTarget0_asSetting[7].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[7].unDutyCycle = CeremonyLeftOutPut[64]; } else if (ucIdx_1 == 64u) //Segments 65 Sig 14-1 { ppCtrlLedLsTarget0_asSetting[5].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[5].unDutyCycle = CeremonyLeftOutPut[13]; } else { //do nothing } } else if (CtrlLed_MountingSide == CTRLLED_MOUNTINSIDE_RIGHT) //Right { if ((ucIdx_1 >= 0u) && (ucIdx_1 < 12u)) //Segments 1-12 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[0][11 - ucIdx_1] = CeremonyRightOutPut[AniMappingRight[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 12u) && (ucIdx_1 < 24u)) //Segments 13-24 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[2][23 - ucIdx_1] = CeremonyRightOutPut[AniMappingRight[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 24u) && (ucIdx_1 < 36u)) //Segments 25-36 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[1][35 - ucIdx_1] = CeremonyRightOutPut[AniMappingRight[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 36u) && (ucIdx_1 < 48u)) //Segments 37-48 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[3][47 - ucIdx_1] = CeremonyRightOutPut[AniMappingRight[ucIdx_1] - 1]; //Lmm Switch 12-1 } else if ((ucIdx_1 >= 48u) && (ucIdx_1 < 60u)) //Segments 49-60 { ppCtrlLedExtSwitchTarget0_aunDutyCycle[4][ucIdx_1 - 48] = CeremonyRightOutPut[AniMappingRight[ucIdx_1] - 1]; //Lmm Switch 1-12 } else if (ucIdx_1 == 60u) //Segments 61 TI2 { ppCtrlLedLsTarget0_asSetting[0].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[0].unDutyCycle = CeremonyRightOutPut[63]; } else if (ucIdx_1 == 61u) //Segments 62 DRL2 { ppCtrlLedLsTarget0_asSetting[10].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[10].unDutyCycle = CeremonyRightOutPut[38]; } else if (ucIdx_1 == 62u) //Segments 63 LB { ppCtrlLedLsTarget0_asSetting[4].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[4].unDutyCycle = CeremonyRightOutPut[0]; } else if (ucIdx_1 == 63u) //Segments 64 CL { ppCtrlLedLsTarget0_asSetting[7].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[7].unDutyCycle = CeremonyRightOutPut[64]; } else if (ucIdx_1 == 64u) //Segments 65 Sig { ppCtrlLedLsTarget0_asSetting[5].unCurrent = 32768u; ppCtrlLedLsTarget0_asSetting[5].unDutyCycle = CeremonyRightOutPut[13]; } else { //do nothing } } else { //do nothing } } } else { // 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); // ppCtrlLedExtSwitchTarget0_aucEnable -> set it as 1 as a first step for (ucIdx = 0; ucIdx < CTRLLED_CFG_MAX_NO_OF_MLC; ucIdx++) { for (ucIdx_1 = 0; ucIdx_1 < CTRLLED_CFG_MAX_NO_OF_SWITCHES_ON_MLC; ucIdx_1++) { ppCtrlLedExtSwitchTarget0_aucEnable[ucIdx][ucIdx_1] = 1; } } Rte_Write_ExtSwitchTarget0_aucEnable((const uint8 *)ppCtrlLedExtSwitchTarget0_aucEnable[0]); //Ctrl_Diag.LedChannel[0].DiagStat_prev = Ctrl_Diag.LedChannel[0].DiagStat; CtrlLed_DrvErr_Handling(); #endif } //----------------------------------------------------------------------------- /// \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 = 0; uint8 ucGammaCurvePointNo = 0; tieDataStatus codDataStat; #undef REVISE_VERSION_VC1 #ifdef REVISE_VERSION_VC1 /*Note_Annotation*/ //Rte_Read_CodingDataStatus(&codDataStat); /*Note_Annotation*/ // if ((codDataStat_prev == tieDataStatus_Invalid) && (codDataStat == tieDataStatus_Valid)) // { #ifndef UNIT_TEST /*Note_Annotation*/ CtrlLed_CodPrj_Init(); #endif // 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. /*Note_Annotation*/ for (ucGammaCurveNo = 0u; ucGammaCurveNo < LEDR_CFG_NO_OF_GAMMA_CURVES; ucGammaCurveNo++) { /*Note_Annotation*/ for (ucGammaCurvePointNo = 0u; ucGammaCurvePointNo < LEDR_CFG_GAMMA_CURVE_COD_POINTS_NO; ucGammaCurvePointNo++) { Gamma_Y[ucGammaCurveNo][ucGammaCurvePointNo] = CodPrj_GetGammaY(ucGammaCurveNo, ucGammaCurvePointNo); } } // Perform Logical channel mapping CtrlLed_LSMaping(); // } // keep the current status of coding data /*Note_Annotation*/ // codDataStat_prev = codDataStat; #else Rte_Read_CodingDataStatus(&codDataStat); // get the relevant coding data once coding status is valid if ((codDataStat_prev == tieDataStatus_Invalid) && (codDataStat == tieDataStatus_Valid)) { #ifndef UNIT_TEST CtrlLed_CodPrj_Init(); #endif // 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 = 0u; ucGammaCurveNo < LEDR_CFG_NO_OF_GAMMA_CURVES; ucGammaCurveNo++) { for (ucGammaCurvePointNo = 0u; ucGammaCurvePointNo < LEDR_CFG_GAMMA_CURVE_COD_POINTS_NO; ucGammaCurvePointNo++) { //Gamma_X[ucGammaCurveNo][ucGammaCurvePointNo] = CodPrj_GetGammaX(ucGammaCurveNo, ucGammaCurvePointNo); Gamma_Y[ucGammaCurveNo][ucGammaCurvePointNo] = CodPrj_GetGammaY(ucGammaCurveNo, ucGammaCurvePointNo); /*Temporary change need to be removed later if(Gamma_Y[ucGammaCurveNo][ucGammaCurvePointNo] > 0x7FFFu) { Gamma_Y[ucGammaCurveNo][ucGammaCurvePointNo] = 0x7FFF; } if(Gamma_X[ucGammaCurveNo][ucGammaCurvePointNo] > 0x7FFFu) { Gamma_X[ucGammaCurveNo][ucGammaCurvePointNo] = 0x7FFF; }*/ } } // Perform Logical channel mapping CtrlLed_LSMaping(); } // keep the current status of coding data codDataStat_prev = codDataStat; #endif } //----------------------------------------------------------------------------- /// \brief Interpolation fcuntion /// /// \descr CtrlLed_Interpolation() is returning the interpolated value based on /// Gamma_X and Gamma_Y points /// This function has been generated/tested with Simulink /// /// \param uint16 unInput - given H_OPT in % LSB: 1_328 /// uint8 ucX_arr[8] - given X points LSB: 0.5 /// uint8 ucY_arr[8] - given Y points LSB: 0.5 /// uint8 ucPointsNo - no of points LSB: 1 /// /// \return uint16 LSB: 1_328 //----------------------------------------------------------------------------- //STATIC_AL uint16 CtrlLed_Interpolation(uint16 unInput, uint8 ucX_arr[8], uint8 ucY_arr[8], uint8 ucPointsNo) //{ // /* SLLocal: Default storage class for local variables | Width: 16 */ // uint16 unInterpOut; /* // Unit: % // LSB: 0.003048780487804 OFF: 0 MIN/MAX: 0 .. 100 */ // uint16 unX_arr_rescaled[8u]; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: 0 .. 100 */ // // /* SLLocal: Default storage class for local variables | Width: 8 */ // uint8 ucIdx; // // /* SLLocal: Default storage class for local variables | Width: 8 */ // uint8 ucAux; // uint8 ucAux_a; // // for (ucIdx = 0u; ucIdx < 8u; ucIdx++) // { // /* TEST/Interpolation/Rescaler */ // unX_arr_rescaled[ucIdx] = (uint16)(((uint16)ucX_arr[ucIdx]) * 164u); // } // /* Begin execution of chart TEST/Interpolation/sf_binSearch */ // ucAux = 0u; // // /* # combined # update of variable(s) associated with TEST/Interpolation/PointsNo */ // if (ucPointsNo < 2u) { // ucAux_a = 0u; // } // else { // /* SLLocal: Default storage class for local variables | Width: 8 */ // uint8 ucAux_b; // // /* # combined # update of variable(s) associated with TEST/Interpolation/PointsNo */ // ucAux_a = (uint8)(ucPointsNo - 1u); // do { // ucAux_b = (uint8)(((uint16)(((uint16)ucAux) + ((uint16)ucAux_a))) >> 1u); // // /* # combined # update of variable(s) associated with TEST/Interpolation/Input */ // if (unInput < unX_arr_rescaled[ucAux_b]) { // ucAux_a = ucAux_b; // } // else { // ucAux = ucAux_b; // } // } while (ucAux < (ucAux_a - 1u)); // ucAux_a = ucAux + 1u; // } // /* End execution of chart TEST/Interpolation/sf_binSearch */ // // /* Switch: TEST/Interpolation/Sw.2 // TEST/Interpolation/Sw.2: Omitted comparison with constant. // # combined # Relational: TEST/Interpolation/Rel.3 // # combined # update of variable(s) associated with TEST/Interpolation/PointsNo */ // if (ucPointsNo < 1u) { // /* Switch: TEST/Interpolation/Sw.2 */ // unInterpOut = 0u; // } // else { // /* SLLocal: Default storage class for local variables | Width: 16 */ // uint16 unY_arr_rescaled[8]; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: 0 .. 100 */ // // /* SLLocal: Default storage class for local variables | Width: 8 */ // boolean bPassLowerEndValue; // // for (ucIdx = 0u; ucIdx < 8u; ucIdx++) // { // /* TEST/Interpolation/Rescaler1 */ // unY_arr_rescaled[ucIdx] = (uint16)(((uint16)ucY_arr[ucIdx]) * 164u); // } // // /* Logical: TEST/Interpolation/Log.1 // # combined # Relational: TEST/Interpolation/Rel.4 // # combined # Relational: TEST/Interpolation/Rel.1 // # combined # update of variable(s) associated with TEST/Interpolation/PointsNo // # combined # Selector: TEST/Interpolation/Sel.2 // # combined # update of variable(s) associated with TEST/Interpolation/Input */ // // Avoid MISRA-/QAC-Warning: Prio7 // // PRQA S 4404 1 // boolean evaluation - not an issue // bPassLowerEndValue = (ucPointsNo < 2u) || (unInput <= unX_arr_rescaled[ucAux]); // // /* Switch: TEST/Interpolation/Sw.1 // TEST/Interpolation/Sw.1: Omitted comparison with constant. // # combined # Logical: TEST/Interpolation/Log.2 // # combined # Relational: TEST/Interpolation/Rel.5 // # combined # Selector: TEST/Interpolation/Sel.1 // # combined # update of variable(s) associated with TEST/Interpolation/Input */ // if ((bPassLowerEndValue == TRUE) || (unInput >= unX_arr_rescaled[ucAux_a])) { // /* Switch: TEST/Interpolation/Sw.6 // TEST/Interpolation/Sw.6: Omitted comparison with constant. */ // if (bPassLowerEndValue == TRUE) { // /* Switch: TEST/Interpolation/Sw.6 // # combined # Switch: TEST/Interpolation/Sw.1 // # combined # Switch: TEST/Interpolation/Sw.2 // # combined # Selector: TEST/Interpolation/Sel.3 */ // unInterpOut = unY_arr_rescaled[ucAux]; // } // else { // /* Switch: TEST/Interpolation/Sw.6 // # combined # Switch: TEST/Interpolation/Sw.1 // # combined # Switch: TEST/Interpolation/Sw.2 // # combined # Selector: TEST/Interpolation/Sel.4 */ // unInterpOut = unY_arr_rescaled[ucAux_a]; // } // } // else { // /* SLLocal: Default storage class for local variables | Width: 32 */ // sint32 slMin; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: -6547206.24390055 .. 6547206.24085 // 177 */ // sint32 slx1x0; /* // Unit: % // LSB: 0.003048780487804 OFF: 0 MIN/MAX: -100 .. 100 */ // sint32 slxx0; /* // Unit: % // LSB: 0.003048780487804 OFF: 0 MIN/MAX: -100 .. 100 */ // // /* Sum: TEST/Interpolation/x1x0 // # combined # Selector: TEST/Interpolation/Sel.1 // # combined # Selector: TEST/Interpolation/Sel.2 */ // slx1x0 = ((sint32)unX_arr_rescaled[ucAux_a]) - ((sint32)unX_arr_rescaled[ucAux]); // // /* MinMax: TEST/Interpolation/MIL_dummy // # combined # Selector: TEST/Interpolation/Sel.2 // # combined # update of variable(s) associated with TEST/Interpolation/Input */ // if (unX_arr_rescaled[ucAux] < unInput) { // /* # combined # Selector: TEST/Interpolation/Sel.2 */ // slMin = (sint32)unX_arr_rescaled[ucAux]; // } // else { // /* # combined # update of variable(s) associated with TEST/Interpolation/Input */ // slMin = (sint32)unInput; // } // // /* Sum: TEST/Interpolation/xx0 // # combined # update of variable(s) associated with TEST/Interpolation/Input */ // slxx0 = ((sint32)unInput) - slMin; // // /* Switch: TEST/Interpolation/Sw.5 // TEST/Interpolation/Sw.5: Omitted comparison with constant. // # combined # Relational: TEST/Interpolation/Rel.2 // # combined # Selector: TEST/Interpolation/Sel.4 // # combined # Selector: TEST/Interpolation/Sel.3 */ // if (unY_arr_rescaled[ucAux] <= unY_arr_rescaled[ucAux_a]) { // /* SLLocal: Default storage class for local variables | Width: 32 */ // sint32 slDiv_1; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: -6547206.24390055 .. 6547206. // 24085177 */ // sint32 slMul_1; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: -6547206.24390055 .. 6547206. // 24085177 */ // // /* Product: TEST/Interpolation/Mul.1 // # combined # Sum: TEST/Interpolation/Sum.4 // # combined # Selector: TEST/Interpolation/Sel.4 // # combined # Selector: TEST/Interpolation/Sel.3 */ // slMul_1 = (slxx0 * (((sint32)unY_arr_rescaled[ucAux_a]) - ((sint32) // unY_arr_rescaled[ucAux]))) / ((sint32)328u); // // /* Product: TEST/Interpolation/Div.1 */ // if (slx1x0 != 0) { // slDiv_1 = (slMul_1 * (sint32)328u) / slx1x0; // } // else { // if (slMul_1 < (sint32)0u) { // slDiv_1 = (-2147483647L - 1L) /* INT32MIN */; // } // else { // slDiv_1 = 2147483647; // } // } // // /* Switch: TEST/Interpolation/Sw.5 // # combined # Switch: TEST/Interpolation/Sw.1 // # combined # Switch: TEST/Interpolation/Sw.2 // # combined # Sum: TEST/Interpolation/Sum.1 // # combined # Selector: TEST/Interpolation/Sel.3 */ // // Avoid MISRA-/QAC-Warning: Prio7 // // PRQA S 4393 1 // conversion is fine based on inputs data range // unInterpOut = (uint16)(((sint32)unY_arr_rescaled[ucAux]) + slDiv_1); // } // else { // /* SLLocal: Default storage class for local variables | Width: 32 */ // sint32 slDiv_2; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: -6547206.24390055 .. 6547206. // 24085177 */ // sint32 slMul_2; /* LSB: 0.003048780487804 OFF: 0 MIN/MAX: -6547206.24390055 .. 6547206. // 24085177 */ // // /* Product: TEST/Interpolation/Mul.2 // # combined # Sum: TEST/Interpolation/Sum.3 // # combined # Selector: TEST/Interpolation/Sel.3 // # combined # Selector: TEST/Interpolation/Sel.4 */ // slMul_2 = (slxx0 * (((sint32)unY_arr_rescaled[ucAux]) - ((sint32) // unY_arr_rescaled[ucAux_a]))) / ((sint32)328u); // // /* Product: TEST/Interpolation/Div.2 */ // if (slx1x0 != (sint32)0u) { // slDiv_2 = (slMul_2 * (sint32)328u) / slx1x0; // } // else { // if (slMul_2 < (sint32)0u) { // slDiv_2 = (-2147483647L - 1L) /* INT32MIN */; // } // else { // slDiv_2 = 2147483647; // } // } // // /* Switch: TEST/Interpolation/Sw.5 // # combined # Switch: TEST/Interpolation/Sw.1 // # combined # Switch: TEST/Interpolation/Sw.2 // # combined # Sum: TEST/Interpolation/Sum.2 // # combined # Selector: TEST/Interpolation/Sel.3 */ // // Avoid MISRA-/QAC-Warning: Prio7 // // PRQA S 4393 1 // conversion is fine based on inputs data range // unInterpOut = (uint16)(((sint32)unY_arr_rescaled[ucAux]) - slDiv_2); // } // } // } // // /* # combined # TargetLink outport: TEST/Interpolation/Interpolation_output */ // return unInterpOut; // // // Avoid MISRA-/QAC-Warnings: // // warning - QAC(Prio2) Msg: 5336 - Autogenerated code - checked and verified + program architecture and readability // // warning - QAC(Prio2) Msg: 5310 - Autogenerated code - checked and verified + program architecture and readability // // PRQA S 5336, 5310 1 // Program architecture and code readability. //} //----------------------------------------------------------------------------- /// \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; } // replacement of the output of LED channels (maybe: and on board switches to AppM) //FUNC(Std_ReturnType, ctaaCtrlLed_CODE) roCtrlLedExtTakeoverLedChannel0Start(uint8 channelNo, uint8 pwm) //{ // // The RTE client/server port type ptExtTakeoverLedChannel shall consist of following operations: // // // // operations parameters meaning // // Start IN uint8 channelNo 1 - 14 // // IN uint8 pwm 1 - 100 [%] // // return Std_ReturnType RTE_E_OK (0U) // // Stop IN uint8 channelNo 1 - 14 // Std_ReturnType ucReturnValue; // // // not sure why diag uses 17 and only 14 are defined // if ((channelNo > 0u) && (channelNo <= LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS + 3u) && (pwm <= CTRLLED_PWM_100)) // { // Ctrl_Diag.LedChannel[0].DiagStat = TRUE; // Ctrl_Diag.LedChannel[channelNo - 1u].LedChannel_ChPwm = pwm; // // ucReturnValue = RTE_E_OK; // } // else // { // ucReturnValue = RTE_E_NOK; // } // // return ucReturnValue; //} // //FUNC(Std_ReturnType, ctaaCtrlLed_CODE) roCtrlLedExtTakeoverLedChannel0Stop(uint8 channelNo) //{ // uint8 ucIdx = 0u; // Std_ReturnType ucReturnValue; // (void)channelNo; // // Ctrl_Diag.LedChannel[0u].DiagStat = FALSE; // // for the moment disable all channels when this fcn is called // for (ucIdx = 0u; ucIdx < (LEDR_CFG_LED_MAX_NO_OF_LS_CHANNELS + 3u); ucIdx++) // { // Ctrl_Diag.LedChannel[ucIdx].LedChannel_ChPwm = 0u; // } // // ucReturnValue = RTE_E_OK; // return ucReturnValue; //} // //// replacement of PXA requests //FUNC(Std_ReturnType, ctaaCtrlLed_CODE) roCtrlLedExtTakeoverMatrixSegmente0Start(uint8 segmentNo, uint8 pwm) //{ // Std_ReturnType ucReturnValue; // // if ((segmentNo > 0u) && (segmentNo < LEDR_CFG_MATRIX_NO_OF_SEGMENTS) && (pwm <= CTRLLED_PWM_100)) // { // Ctrl_Diag.MatrixSegmente.DiagStat = TRUE; // Ctrl_Diag.MatrixSegmente.MatrixSeg_Pwm = pwm; // Ctrl_Diag.MatrixSegmente.MatrixSeg_No = segmentNo - 1u; // // ucReturnValue = RTE_E_OK; // } // else // { // ucReturnValue = RTE_E_NOK; // } // // return ucReturnValue; //} // //FUNC(Std_ReturnType, ctaaCtrlLed_CODE) roCtrlLedExtTakeoverMatrixSegmente0Stop(uint8 segmentNo) //{ // Std_ReturnType ucReturnValue; // (void)segmentNo; // // Ctrl_Diag.MatrixSegmente.DiagStat = FALSE; // // ucReturnValue = RTE_E_OK; // return ucReturnValue; //} // //// replacement of CtrlLed output to AppM //FUNC(Std_ReturnType, ctaaCtrlLed_CODE) roCtrlLedExtTakeoverMlcSwitch0Start(uint8 ucMlcNo, uint8 ucMlcSwitchNo, uint8 ucPwm) //{ // Std_ReturnType ucReturnValue; // (void)ucMlcNo; // // if ((ucMlcSwitchNo < LEDR_CFG_MATRIX_NO_OF_SEGMENTS) && (ucPwm <= CTRLLED_PWM_100)) // { // Ctrl_Diag.MlcSwitch.DiagStat = TRUE; // Ctrl_Diag.MlcSwitch.MlcSwitch_ChPwm = ucPwm; // Ctrl_Diag.MlcSwitch.MlcSwitch_No = ucMlcSwitchNo; // // ucReturnValue = RTE_E_OK; // } // else // { // ucReturnValue = RTE_E_NOK; // } // // return ucReturnValue; //} // //FUNC(Std_ReturnType, ctaaCtrlLed_CODE) roCtrlLedExtTakeoverMlcSwitch0Stop(uint8 ucMlcNo) //{ // Std_ReturnType ucReturnValue; // (void)ucMlcNo; // // Ctrl_Diag.MlcSwitch.DiagStat = FALSE; // // ucReturnValue = RTE_E_OK; // return ucReturnValue; //} //----------------------------------------------------------------------------- /// \brief initialisation runnable /// /// \descr initialisation runnable for CtrlLed /// Called once at start up. /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void 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 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 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 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) RTE_RUNNABLE_roExtTakeoverCornerLightControlStart(uint8 CornerLightControl) { CornerLightControlto2F = CornerLightControl; FlagtoControl2F = 1U; return E_OK; } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverCornerLightControlStop /// /// \descr Corner light control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) RTE_RUNNABLE_roExtTakeoverCornerLightControlStop(uint8 CornerLightControl) { CornerLightControlto2F = CornerLightControl; FlagtoControl2F = 0U; return E_OK; } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverADBMatrixControlStart /// /// \descr High beam control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) RTE_RUNNABLE_roExtTakeoverADBMatrixControlStart(uint16 Ctrl2FHBSegment) { ADBMatrixContro2F = Ctrl2FHBSegment; FlagtoControl2F = 1U; return E_OK; } //----------------------------------------------------------------------------- /// \brief RTE_RUNNABLE_roExtTakeoverADBMatrixControlStop /// /// \descr High beam control in 2F mode /// /// \param void /// /// \return void //----------------------------------------------------------------------------- FUNC(Std_ReturnType, ctasLedR_CODE) RTE_RUNNABLE_roExtTakeoverADBMatrixControlStop(uint16 Ctrl2FHBSegment) { ADBMatrixContro2F = Ctrl2FHBSegment; FlagtoControl2F = 0U; return E_OK; } //----------------------------------------------------------------------------- /// \brief ADBMatrixControChannelEnable /// /// \descr /// /// \param void /// /// \return void //----------------------------------------------------------------------------- void ADBMatrixControChannelEnable(uint8 Num, tiu16Percent_1_328 *LedExtSwitchTargetDutyCycle, boolean Status) { 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]] = 0u; } } //----------------------------------------------------------------------------- // Stop declaration or definitions of functions //----------------------------------------------------------------------------- #define ctasLedR_STOP_SEC_CODE #include "LedR_MemMap.h"