//*****************************************************************************
// (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   CddSwi_Adapter.c
///
/// \brief  Default adapter
///
/// \author ZHAO, Kai ALDE-RT/EES6
//-----------------------------------------------------------------------------
#define E2E_Remove
#include <Std_Types.h>
#include <AL_Helper.h>

#include <Rte_ctadCddSwi.h>
#ifndef E2E_Remove
#include <E2EWrapper_ctadCddSwi.h>
//#include <E2E_PH_Types.h>
#endif
#include <CddSwi.h>
#include <../Cfg/CddSwi_Cfg.h>


#define FAULT_THRESH 19u

//-----------------------------------------------------------------------------
// Start definitions of initialized 8 bit variables
//-----------------------------------------------------------------------------
#define ctadCddSwi_START_SEC_VAR_INIT_8
#include <../Cfg/CddSwi_MemMap.h>
#ifndef E2E_Remove
STATIC_AL uint8 CddSwi_E2E_Read_DebounceCounter  = 0u;
STATIC_AL uint8 CddSwi_E2E_Write_DebounceCounter = 0u;
#endif
#define ctadCddSwi_STOP_SEC_VAR_INIT_8
#include <../Cfg/CddSwi_MemMap.h>
//-----------------------------------------------------------------------------
// End definitions of initialized 8 bit variables
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Start definitions of initialized boolean variables
//-----------------------------------------------------------------------------
#define ctadCddSwi_START_SEC_VAR_INIT_BOOLEAN
#include <../Cfg/CddSwi_MemMap.h>
#ifndef E2E_Remove
STATIC_AL boolean CddSwi_E2E_Read_FaultActive  = FALSE;
STATIC_AL boolean CddSwi_E2E_Write_FaultActive = FALSE;
#endif
#define ctadCddSwi_STOP_SEC_VAR_INIT_BOOLEAN
#include <../Cfg/CddSwi_MemMap.h>
//-----------------------------------------------------------------------------
// End definitions of initialized boolean variables
//-----------------------------------------------------------------------------


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


//-----------------------------------------------------------------------------
// Local function prototypes
//-----------------------------------------------------------------------------
#ifndef E2E_Remove
STATIC_AL boolean CddSwi_ReadE2E_ErrorCheck(uint32 E2E_ReadReturnVal);
STATIC_AL boolean CddSwi_WriteE2E_ErrorCheck(uint32 E2E_WriteReturnVal);
#endif
//-----------------------------------------------------------------------------
/// \brief  Init runnable
///
/// \descr  Init runnable to be called at MCU startup
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
FUNC(void, ctadCddSwi_CODE) ctadCddSwi_riCddSwiInit(void)
{
    /* riCddSwiInit_Start User Code start*/
  tisAllSwitchStatus aStatus;
#ifndef E2E_Remove
  (void)E2EPW_ReadInit_ppareSysMonSwiTarget_sAllSwitchTarget();
  (void)E2EPW_WriteInit_ppaseCddSwiStatus_sAllSwitchStatus();
#endif

  CddSwi_Init();

  for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
  {
    aStatus.asSwitchStatus[i] = CddSwi_GetState(i);
  }
#ifndef E2E_Remove
  (void)E2EPW_Write_ppaseCddSwiStatus_sAllSwitchStatus(&aStatus);
#else
  (void)Rte_Write_ppaseCddSwiStatus_sAllSwitchStatus(&aStatus);
#endif
  /* riCddSwiInit_Start User Code end*/
}

boolean CddSwi_GetCodMDataStatus(void)
{
  tieDataStatus      tCodingDataStatus;
  // read Coding Data Status
  (void)Rte_Read_ppareCodMCodingDataStatus0_eCompleteCodingDataStatus(&tCodingDataStatus);
  return (boolean)tCodingDataStatus;
}
//-----------------------------------------------------------------------------
/// \brief  rpCddSwiCycle10ms
///
/// \descr  Cyclic runnable adapter for CddSwi_Cycle10ms.
///
/// \param  -
///
/// \return void
//-----------------------------------------------------------------------------
FUNC(void, ctadCddSwi_CODE) ctadCddSwi_rpCddSwi10ms(void)
{
    /* rpCddSwi10ms_Start User Code start*/
	tisAllSwitchStatus tStatus;
	tisAllSwitchTarget tTgtVal;
#ifndef E2E_Remove
	uint32 E2E_ReadReturnVal, E2E_WriteReturnVal;
	boolean boReadError, boWriteError;

	E2E_ReadReturnVal = E2EPW_Read_ppareSysMonSwiTarget_sAllSwitchTarget(&tTgtVal);
	boReadError = CddSwi_ReadE2E_ErrorCheck(E2E_ReadReturnVal);
#else
	(void)Rte_Read_ppareSysMonSwiTarget_sAllSwitchTarget(&tTgtVal); /*add explanation 2022.11.14 */
#endif
#ifndef E2E_Remove
	if (boReadError == FALSE)
	{
#endif
		for (uint8 i = 0; i < CFG_SWI_OUTPUTS_CNT; i++)
		{
			CddSwi_SetTgt(i, tTgtVal.aunTgtVal[i]);
			tStatus.asSwitchStatus[i] = CddSwi_GetState(i);
		}
#ifndef E2E_Remove
	}
	tStatus.bfSysMonTargetQty = (CddSwi_E2E_Read_FaultActive == TRUE) ? INVALID_VALUE_ERROR : 0x00;
	CddSwi_Cycle10ms();

	E2E_WriteReturnVal = E2EPW_Write_ppaseCddSwiStatus_sAllSwitchStatus(&tStatus);
	boWriteError = CddSwi_WriteE2E_ErrorCheck(E2E_WriteReturnVal);
	(void)boWriteError;
#else if 
		tStatus.bfSysMonTargetQty = 0;
		CddSwi_Cycle10ms();
		(void)Rte_Write_ppaseCddSwiStatus_sAllSwitchStatus(&tStatus); /*add explanation 2022.11.14 */
#endif
    //if boWriteError == FALSE, write successful
    // else boWriteError = TRUE, no action nessessary for now.
    /* rpCddSwi10ms_Start User Code end*/
}


//--------------------------------------------------------------------------------------------------
/// \brief  CddSwi_ReadE2E_ErrorCheck
///
/// \descr
///
/// \param  E2E_ReadReturnVal
///
/// \return boolean TRUE: CRC_ERR, FALSE: CRC_NO_ERR
//--------------------------------------------------------------------------------------------------
#ifndef E2E_Remove
STATIC_AL boolean CddSwi_ReadE2E_ErrorCheck(uint32 E2E_ReadReturnVal)
{
  boolean boRetVal = FALSE;
  uint32 StatusByte0_2, StatusByte3;

  StatusByte0_2 = (uint32)(((uint32)(E2E_ReadReturnVal)) & ((uint32)0x00FFFFFFU));
  StatusByte3 = (uint32)((((uint32)(E2E_ReadReturnVal)) >> 24U) & ((uint32)0x000000FFU));

  if (  ( (E2E_ReadReturnVal == E2E_E_OK)  ||  (StatusByte3 == E2E_P04STATUS_REPEATED) || (StatusByte3 == E2E_P04STATUS_OKSOMELOST) )
   &&   (StatusByte0_2 == 0x00)
   &&   (CddSwi_E2E_Read_FaultActive == FALSE)
   &&   (CddSwi_E2E_Read_DebounceCounter < FAULT_THRESH) )
  {
    if ((StatusByte3 == E2E_P04STATUS_REPEATED))
    {
      CddSwi_E2E_Read_DebounceCounter++;
    }
    else
    {
      if (CddSwi_E2E_Read_DebounceCounter > 0)
      {
        CddSwi_E2E_Read_DebounceCounter--;
      }
      else
      {
        CddSwi_E2E_Read_FaultActive = FALSE;
      }
    }
    boRetVal = FALSE;
  }
  else
  {
    if ( ( (E2E_ReadReturnVal == E2E_E_OK) ||
           ( (StatusByte3 == E2E_P04STATUS_OKSOMELOST) &&
             (StatusByte0_2 == 0x00)
           )
         ) == FALSE )
    {
      if (CddSwi_E2E_Read_DebounceCounter < FAULT_THRESH)
      {
        CddSwi_E2E_Read_DebounceCounter++;
      }
      else
      {
        CddSwi_E2E_Read_DebounceCounter = FAULT_THRESH;
        CddSwi_E2E_Read_FaultActive = TRUE;
      }
      boRetVal = TRUE;
    }
    else
    {
      if (CddSwi_E2E_Read_DebounceCounter > 0)
      {
        CddSwi_E2E_Read_DebounceCounter--;
        boRetVal = TRUE;
      }
      else
      {
        CddSwi_E2E_Read_FaultActive = FALSE;
        boRetVal = FALSE;
      }
    }
  }
  return boRetVal;
}
#endif
//--------------------------------------------------------------------------------------------------
/// \brief  CddSwi_WriteE2E_ErrorCheck
///
/// \descr
///
/// \param  E2E_WriteReturnVal
///
/// \return boolean TRUE: CRC_ERR, FALSE: CRC_NO_ERR
//--------------------------------------------------------------------------------------------------
#ifndef E2E_Remove
STATIC_AL boolean CddSwi_WriteE2E_ErrorCheck(uint32 E2E_WriteReturnVal)
{
  boolean boRetVal = FALSE;

  if ((E2E_WriteReturnVal == E2E_E_OK) && (CddSwi_E2E_Write_FaultActive == FALSE))
  {
    //?CddSwi_CRC_Write_DebounceCounter--;
    //CddSwi_E2E_Write_FaultActive = FALSE;
    boRetVal = FALSE;
  }
  else
  {
    if (E2E_WriteReturnVal != E2E_E_OK)
    {
      if (CddSwi_E2E_Write_DebounceCounter < FAULT_THRESH)
      {
        CddSwi_E2E_Write_DebounceCounter++;
      }
      else
      {
        CddSwi_E2E_Write_FaultActive = TRUE;
      }
    }
    else
    {
      if (CddSwi_E2E_Write_DebounceCounter > 0)
      {
        CddSwi_E2E_Write_DebounceCounter--;
      }
      else
      {
        CddSwi_E2E_Write_FaultActive = FALSE;
      }
    }
    boRetVal = CddSwi_E2E_Write_FaultActive;
  }
  return boRetVal;
}
#endif

FUNC(void, ctadCddSwi_CODE) ctadCddSwi_rdCddSwiDeInit(void)
{
    /* rdCddSwiDeInit_Start User Code start*/
    CddSwi_DeInit();
    /* rdCddSwiDeInit_Start User Code end*/

}
#define ctadCddSwi_STOP_SEC_CODE
#include <../Cfg/CddSwi_MemMap.h>
//-----------------------------------------------------------------------------
// End declaration or definitions of functions
//-----------------------------------------------------------------------------