//*****************************************************************************
// (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   CddLed_Adapter.c
///
/// \brief  CddLed adapter for Hh001 project 
///
/// \author OTT, Peter ALDE-RT/EES6
//-----------------------------------------------------------------------------
/*VC1 Release1 temporarily deleted when integration */
//#define E2E_Remove
// standard includes
#include <Std_Types.h>
#include <AL_Helper.h>

#include <CddLed.h>
#include <Rte_ctadCddLed.h>
#ifndef E2E_Remove
#include <E2EWrapper_ctadCddLed.h>
#endif

#ifndef UNIT_TEST
#include <Swc/CodM/Api/CodM.h>
//#define CDDLED_Para_LED_VOLT_CHECK_ENABLE   applicationCodingData.Led1.LedErrDetect.reserved1[0]  // because of missing parameter
#define CDDLED_Para_LED_VOLT_CHECK_ENABLE   applicationCodingData.Led1.LedErrDetect.LED_VOLT_CHECK_ENABLE  // future parameter
#else
uint8 CddLed_ucVoltCheckEnable = 0u;
#define CDDLED_Para_LED_VOLT_CHECK_ENABLE    CddLed_ucVoltCheckEnable
#endif


//-----------------------------------------------------------------------------
// Defines
//-----------------------------------------------------------------------------
#define E2E_FaultThresh_LsTarget    20u  // 20 * 10ms data rate = 200ms
#define E2E_FaultThresh_DrvSettings 10u  // 10 * 20ms data rate = 200ms


//-----------------------------------------------------------------------------
// Start definitions of initialized boolean variables
//-----------------------------------------------------------------------------
#define ctadCddLed_START_SEC_VAR_INIT_BOOLEAN
#include <../Cfg/CddLed_MemMap.h>

STATIC_AL boolean CddLed_boLsTargetError    = FALSE;
STATIC_AL boolean CddLed_boDrvSettingsError = FALSE;


#define ctadCddLed_STOP_SEC_VAR_INIT_BOOLEAN
#include <../Cfg/CddLed_MemMap.h>
//-----------------------------------------------------------------------------
// End definitions of initialized boolean variables
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Start definitions of initialized 8 bit variables
//-----------------------------------------------------------------------------
#define ctadCddLed_START_SEC_VAR_INIT_8
#include <../Cfg/CddLed_MemMap.h>

STATIC_AL uint8 CddLed_ucLsTargetDebounceCnt    = 0u;  // E2E debounce counters
STATIC_AL uint8 CddLed_ucDrvSettingsDebounceCnt = 0u;

#define ctadCddLed_STOP_SEC_VAR_INIT_8
#include <../Cfg/CddLed_MemMap.h>
//-----------------------------------------------------------------------------
// End definitions of initialized 8 bit variables
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Start definitions of non initialized structures and unions or arrays variables
//-----------------------------------------------------------------------------
#define ctadCddLed_START_SEC_VAR_NO_INIT_UNSPECIFIED
#include <../Cfg/CddLed_MemMap.h>

STATIC_AL tCddLedStatus CddLed_sStatus;
STATIC_AL tieDataStatus CddLed_CodMCodingDataStatus;

#define ctadCddLed_STOP_SEC_VAR_NO_INIT_UNSPECIFIED
#include <../Cfg/CddLed_MemMap.h>
//-----------------------------------------------------------------------------
// End definitions of non initialized structures and unions or arrays variables
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
// Start declaration or definitions of functions
//-----------------------------------------------------------------------------
#define ctadCddLed_START_SEC_CODE
#include <../Cfg/CddLed_MemMap.h>


//-----------------------------------------------------------------------------
// Local function prototypes
//-----------------------------------------------------------------------------
STATIC_AL void CddLed_PrepareStatus(tisCddLedStatus* pStatusToRte);


//-----------------------------------------------------------------------------
// Function definitions
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
/// \brief  Get status from driver
///
/// \descr  Read status from driver and prepare RTE port contents
///
/// \param  tisCddLedStatus* pStatusToRte pointer to RTE message
///
/// \return void
//-----------------------------------------------------------------------------
STATIC_AL void CddLed_PrepareStatus(tisCddLedStatus* pStatusToRte)
{
  CddLed_GetStatus(&CddLed_sStatus);

  for (uint32 ul = 0u; ul < CDDLED_Cfg_NbOfChannels; ul++)
  {
    pStatusToRte->asStatus[ul].eChnSts                    = (uint8)CddLed_sStatus.aStatus[ul].Chn;
    pStatusToRte->asStatus[ul].eVinSts                    = (uint8)CddLed_sStatus.aStatus[ul].Vin;
    pStatusToRte->asStatus[ul].unVLed                     = CddLed_sStatus.aStatus[ul].unVLed;
    pStatusToRte->asStatus[ul].sTempData.boThermalWarning = CddLed_sStatus.aStatus[ul].TempData.boThermalWarning;

    if (CddLed_CodMCodingDataStatus == tieDataStatus_Valid)
    {
      pStatusToRte->asStatus[ul].eErr = (uint8)CddLed_sStatus.aStatus[ul].Err;
    }
    else
    {
      pStatusToRte->asStatus[ul].eErr = eCddLed_Reset;  // no buck startup without coding data
    }
  }

  pStatusToRte->bfSysMonTargetQty = ( (CddLed_boLsTargetError    != FALSE)
                                   || (CddLed_boDrvSettingsError != FALSE) ) ? INVALID_VALUE_ERROR : 0u;
}

//-----------------------------------------------------------------------------
/// \brief  Init runnable
///
/// \descr  Init runnable to be called at MCU startup
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void riCddLedInit(void)
{
  tisCddLedStatus_ASIL StatusToRte;
#ifndef E2E_Remove
  (void)E2EPW_WriteInit_ppaseCddLedStatus_sStatus();  // do this once for initialization
  (void)E2EPW_ReadInit_ppareSysMonLsTarget0_sSetting();
  (void)E2EPW_ReadInit_ppareSysMonLedBuckDriverSettings_sSettings();
#endif
  (void)Rte_Read_ppareCodMCodingDataStatus0_eFUSACodingDataStatus(&CddLed_CodMCodingDataStatus);  // check for valid coding data

  CddLed_Init();
  CddLed_SetPara(TRUE);

  CddLed_PrepareStatus(&StatusToRte);
#ifndef E2E_Remove
  (void)E2EPW_Write_ppaseCddLedStatus_sStatus(&StatusToRte);  // no safety reaction planned
#else
  (void)Rte_Write_ppaseCddLedStatus_sStatus(&StatusToRte);
#endif
  // PRQA S 5324 1 // HIS metrics violation: STCAL>7
}


//-----------------------------------------------------------------------------
/// \brief  CddLed_E2E_ReadCheck
///
/// \descr  This function checks the result of E2E macro
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
#ifndef E2E_Remove
STATIC_AL boolean CddLed_E2E_ReadCheck(boolean* pboErrValid, uint8* pucErrCnt, uint32 ul_RetVal, uint8 ucFaultThresh)
{
  boolean boDecrement = FALSE;
  boolean boIncrement = FALSE;
  boolean boSigValid  = FALSE;

  uint32 ulRetVal_Byte0_2 =  ul_RetVal         & 0xFFFFFFu;
  uint32 ulRetVal_Byte_3  = (ul_RetVal >> 24u) & 0xFFu;

  if (ul_RetVal == E2E_E_OK)  // completely ok
  {
    boDecrement = TRUE;
    boSigValid  = TRUE;
  }
  else if ((ulRetVal_Byte0_2 == 0u) && (*pucErrCnt < ucFaultThresh)) // E2E problem but RTE reception ok
  {
    if (ulRetVal_Byte_3 == (uint32)E2E_P04STATUS_OKSOMELOST)  // fully acceptable
    {
      boDecrement = TRUE;
      boSigValid  = TRUE;
    }
    else if (ulRetVal_Byte_3 == (uint32)E2E_P04STATUS_REPEATED)  // not ok but may be used
    {
      boIncrement = TRUE;
      boSigValid  = TRUE;
    }
    else
    {
      boIncrement = TRUE;  // failure
    }
  }
  else
  {
    boIncrement = TRUE;  // failure
  }

  *pucErrCnt = ((boIncrement != FALSE) && (*pucErrCnt < ucFaultThresh)) ? *pucErrCnt + 1u : *pucErrCnt;
  *pucErrCnt = ((boDecrement != FALSE) && (*pucErrCnt >      0u      )) ? *pucErrCnt - 1u : *pucErrCnt;

  *pboErrValid = (*pucErrCnt >= ucFaultThresh) ? TRUE  : *pboErrValid;
  *pboErrValid = (*pucErrCnt ==       0u     ) ? FALSE : *pboErrValid;
  
  return boSigValid;  // TRUE if usage of target value is allowed unless no failsafe reaction requested
}
#endif

//-----------------------------------------------------------------------------
/// \brief  rrCddLedSysMonLsTarget
///
/// \descr  Function to be called on new target values
///         This shall be done event triggered by writing RTE target value
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void rrCddLedSysMonLsTarget0(void)
{
  tisLsTarget_ASIL TargetFromRte; // input from RTE
  tCddLedTarget    Target;        // CddLed API
  
#ifndef E2E_Remove
  uint32 ulRetVal = E2EPW_Read_ppareSysMonLsTarget0_sSetting(&TargetFromRte);

  boolean boSigValid = CddLed_E2E_ReadCheck(&CddLed_boLsTargetError, &CddLed_ucLsTargetDebounceCnt, ulRetVal, E2E_FaultThresh_LsTarget);
#else
  (void)Rte_Read_ppareSysMonLsTarget0_sSetting(&TargetFromRte);
#endif
  for (uint32 ul = 0u; ul < CDDLED_Cfg_NbOfChannels; ul++)
  {
    Target.aTarget[ul].unCurrent_mA        = TargetFromRte.asLsVal[ul].unCurrent;
    Target.aTarget[ul].unDutyCycle_1_32768 = TargetFromRte.asLsVal[ul].unDutyCycle;
  }
  
#ifndef E2E_Remove
  if ( (CddLed_boLsTargetError      == FALSE              )   // no E2E error reaction
    && (boSigValid                  != FALSE              )   // E2E signal check ok
    && (CddLed_CodMCodingDataStatus == tieDataStatus_Valid) ) // coding data available
#else 																		
  if ((CddLed_CodMCodingDataStatus == tieDataStatus_Valid))
#endif
  {
    CddLed_SetTarget(&Target);
  }
}


//-----------------------------------------------------------------------------
/// \brief  rpCddLedCycle20ms
///
/// \descr  Cyclic runnable adapter for CddLed_Cycle20ms.
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
void rpCddLedCycle20ms(void)
{
  tisCddLedStatus_ASIL     StatusToRte;
  tisLedBuckDriverSettings SettingsFromRte;
  tCddLedDriverSettings    DriverSettings;
#ifndef E2E_Remove
  uint32 ulRetVal = E2EPW_Read_ppareSysMonLedBuckDriverSettings_sSettings(&SettingsFromRte);

  boolean boSigValid = CddLed_E2E_ReadCheck(&CddLed_boDrvSettingsError, &CddLed_ucDrvSettingsDebounceCnt, ulRetVal, E2E_FaultThresh_DrvSettings);

  if (boSigValid != FALSE)
  {
#endif
#ifndef E2E_Remove
    DriverSettings.ulDisableErrE2E             = SettingsFromRte.bfDisableErrE2E;
    DriverSettings.ulDisableErrOpenLoad        = SettingsFromRte.bfDisableErrOpenLoad;
    DriverSettings.ulDisableErrOverCurrent     = SettingsFromRte.bfDisableErrOverCurrent;
    DriverSettings.ulDisableErrShortToGnd      = SettingsFromRte.bfDisableErrShortToGnd;
    DriverSettings.ulDisableErrShortToUbat     = SettingsFromRte.bfDisableErrShortToUbat;
    DriverSettings.ulDisableErrSpi             = SettingsFromRte.bfDisableErrSpi;
    DriverSettings.ulDisableErrThermalShutdown = SettingsFromRte.bfDisableErrThermalShutdown;
    DriverSettings.ulDisableErrUnderVoltage    = SettingsFromRte.bfDisableErrUnderVoltage;
    DriverSettings.ulDisableErrOverVoltage     = SettingsFromRte.bfDisableErrOverVoltage;

    if (CDDLED_Para_LED_VOLT_CHECK_ENABLE == 0u)
    {
      DriverSettings.ulDisableErrUnderVoltage    = 0xFFFu;   // disable voltage check
      DriverSettings.ulDisableErrOverVoltage     = 0xFFFu;
    }
#else
	DriverSettings.ulDisableErrE2E = 0u;
	DriverSettings.ulDisableErrOpenLoad = 0u;
	DriverSettings.ulDisableErrOverCurrent = 0u;
	DriverSettings.ulDisableErrShortToGnd = 0u;
	DriverSettings.ulDisableErrShortToUbat = 0u;
	DriverSettings.ulDisableErrSpi = 0u;
	DriverSettings.ulDisableErrThermalShutdown = 0u;
	DriverSettings.ulDisableErrUnderVoltage = 0xFFFu;
	DriverSettings.ulDisableErrOverVoltage = 0xFFFu;
#endif // !E2E_Remove

    CddLed_DriverSettings(&DriverSettings);
#ifndef E2E_Remove
  }
#endif
  CddLed_Cycle20ms();

  CddLed_PrepareStatus(&StatusToRte);
#ifndef E2E_Remove
  (void)E2EPW_Write_ppaseCddLedStatus_sStatus(&StatusToRte);  // no safety reaction planned
#else

  (void)Rte_Write_ppaseCddLedStatus_sStatus(&StatusToRte);
#endif
}


//-----------------------------------------------------------------------------
/// \brief  roCddLed_SetPara
///
/// \descr  Placeholder for parameter function
///
/// \param  pPara - pointer to booster parameter
///
/// \return void
//-----------------------------------------------------------------------------
void roCddLed_SetPara(tisCddLedParaPtr pPara)
{
  (void)pPara;
}

void riCddLedDeInit(void)
{
  return;
}

#define ctadCddLed_STOP_SEC_CODE
#include <../Cfg/CddLed_MemMap.h>
//-----------------------------------------------------------------------------
// End declaration or definitions of functions
//-----------------------------------------------------------------------------