//*****************************************************************************
// (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    VehHub.c
///
///  \author  gdx
///
///  \date    02.17.2023
///
///  \brief   VehHub
///
///
///
// ----------------------------------------------------------------------------

#include "VehHub/VehHub.h"
#include "SigPrep0/Api/SigPrep0_GlobalType_Temp.h"
#include "SigPrep0/SigPrep_Common.h"
#include "Rte_ctaaVehicleHub.h"
#include "Bsw/SwcNvmWrapper/SwcNvmWrapper.h"
#include "SysMon/SysMon_Failsafe.h"

//#define ADB_DEBUG

/* Variable Declare */
STATIC_AL tisLightCmd  sLightCmd;
STATIC_AL tisGeneralInfo  sGeneralInfo;
STATIC_AL tisVehicleDynamic  sVehicleDynamic;
STATIC_AL tisEnvironment  sEnvironment;
STATIC_AL tisBMSInfo  sBMSInfo;
STATIC_AL tisADASInfo  sADASInfo;
STATIC_AL tisDoorInfo  sDoorInfo;
STATIC_AL tisGlobalTime  sGlobalTime;
STATIC_AL tisAdvanceLightCmd sAdvanceLightCmd;
STATIC_AL tieComnQtySts eQtyBdcm14;
STATIC_AL tieComnQtySts eQtyBdcmRt7;
STATIC_AL uint8 ucADCM_ADB_Available;
STATIC_AL uint8 ucBDCM_RT_7_ADCM_Available_St;
STATIC_AL uint8 ucCSM_ADB_AHBSwitch_St;
STATIC_AL uint8 ucCSM_ADB_AHBSwitch_StPre;
STATIC_AL boolean boAdbEnable;
STATIC_AL uint8 eAdbActivation;
STATIC_AL uint16 usFlashCmdTimer;
STATIC_AL boolean boFlashCmdPre;

#define VehicleHub_START_SEC_CODE
#include "ctaaVehicleHub_MemMap.h"

void RTE_rpVehicleHub10ms(void);
void RTE_riVehicleHubInit(void);
STATIC_AL void VehHubUpdate10ms(void);
STATIC_AL void VehHub_Init(void);
STATIC_AL void Read_CSM_ADBSwitch_St(uint8 *data);
STATIC_AL void Write_CSM_ADBSwitch_St(const uint8 *data);
STATIC_AL void VehHub_AdbActivation(void);
STATIC_AL uint8 VehHub_SetMsgQty(uint8 status, uint8 eErr);

void RTE_rpVehicleHub10ms(void)
{
  VehHubUpdate10ms();
}

void RTE_riVehicleHubInit(void)
{
  VehHub_Init();
}

/* 10ms Call */
STATIC_AL void VehHubUpdate10ms(void)
{
#ifndef ADB_DEBUG
  VehHub_AdbActivation();
#else
  sAdvanceLightCmd.boAdbEnable = 0x0u;
  sAdvanceLightCmd.eAdbActivation = 0x0u;
#endif

}

STATIC_AL void VehHub_Init(void)
{
  /* sLightCmd Init */
  sLightCmd.sPosition.boValue = 0u;
  sLightCmd.sPosition.eQty = 0u;
  sLightCmd.sDaytimeRunningLight.boValueLeft = 0u;
  sLightCmd.sDaytimeRunningLight.eQtyLeft = 0u;
  sLightCmd.sDaytimeRunningLight.boValueRight = 0u;
  sLightCmd.sDaytimeRunningLight.eQtyRight = 0u;
  sLightCmd.sTurn.boValueLeft = 0u;
  sLightCmd.sTurn.eQtyLeft = 0u;
  sLightCmd.sTurn.boValueRight = 0u;
  sLightCmd.sTurn.eQtyRight = 0u;
  sLightCmd.sTurn.eValueMode = 0u;
  sLightCmd.sTurn.eQtyMode = 0u;
  sLightCmd.sTail.boValue = 0u;
  sLightCmd.sTail.eQty = 0u;
  sLightCmd.sBrake.boValue = 0u;
  sLightCmd.sBrake.eQty = 0u;
  sLightCmd.sReversLight.boValue = 0u;
  sLightCmd.sReversLight.eQty = 0u;
  sLightCmd.sFog.boValue = 0u;
  sLightCmd.sFog.eQty = 0u;
  sLightCmd.sLowerBeam.boValue = 0u;
  sLightCmd.sLowerBeam.eQty = 0u;
  sLightCmd.sHighBeam.boValueLamp = 0u;
  sLightCmd.sHighBeam.eQtyLamp = 0u;
  sLightCmd.sHighBeam.boValueFlash = 0u;
  sLightCmd.sHighBeam.eQtyFlash = 0u;
  sLightCmd.sFrontLogoLight.boValue = 0u;
  sLightCmd.sFrontLogoLight.eQty = 0u;
  sLightCmd.sLightSwitch.eStatus = 0u;
  sLightCmd.sLightSwitch.eQty = 0u;
  ucCSM_ADB_AHBSwitch_St = 0x03u;
  eQtyBdcm14 = 0u;
  sLightCmd.sHazard.eStatus = 0u;
  sLightCmd.sHazard.eQty = 0u;

  /* sGeneralInfo Init */
  sGeneralInfo.sPowerMode.eStatus = 0u;
  sGeneralInfo.sPowerMode.eQty = 0u;
  sGeneralInfo.sMileage.ulValue = 0xFFFFFFu;
  sGeneralInfo.sMileage.eQty = 0u;

  /* sVehicleDynamic Init */
  sVehicleDynamic.sDrivingMode.eValue = 0u;
  sVehicleDynamic.sDrivingMode.eQty = 0u;
  sVehicleDynamic.sSpeed.usValue = 0u;
  sVehicleDynamic.sSpeed.eQty = 0u;
  sVehicleDynamic.sAccPedel.ucValue = 0u;
  sVehicleDynamic.sAccPedel.eQty = 0u;
  sVehicleDynamic.sActualGear.eValue = 0u;
  sVehicleDynamic.sActualGear.eQty = 0u;
  sVehicleDynamic.sAccelerationRate.usAccValueX = 0x7530u;
  sVehicleDynamic.sAccelerationRate.boAccStatusX = 0u;
  sVehicleDynamic.sAccelerationRate.usRollRateValueX = 0x7530u;
  sVehicleDynamic.sAccelerationRate.boRollRateStatusX = 0u;
  sVehicleDynamic.sAccelerationRate.eQtyX = 0u;
  sVehicleDynamic.sAccelerationRate.usAccValueY = 0x7530u;
  sVehicleDynamic.sAccelerationRate.boAccStatusY = 0u;
  sVehicleDynamic.sAccelerationRate.usPitchRateValueY = 0x7530u;
  sVehicleDynamic.sAccelerationRate.boPitchRateStatusY = 0u;
  sVehicleDynamic.sAccelerationRate.eQtyY = 0u;
  sVehicleDynamic.sAccelerationRate.usAccValueZ = 0x7530u;
  sVehicleDynamic.sAccelerationRate.boAccStatusZ = 0u;
  sVehicleDynamic.sAccelerationRate.usYawRateValueZ = 0x7530u;
  sVehicleDynamic.sAccelerationRate.boYawRateStatusZ = 0u;
  sVehicleDynamic.sAccelerationRate.eQtyZ = 0u;
  sVehicleDynamic.sSuspensionHeight.usValueFL = 0x7Fu;
  sVehicleDynamic.sSuspensionHeight.usValueFR = 0x7Fu;
  sVehicleDynamic.sSuspensionHeight.usValueRL = 0x7Fu;
  sVehicleDynamic.sSuspensionHeight.usValueRR = 0x7Fu;
  sVehicleDynamic.sSuspensionHeight.eQty = 0u;
  sVehicleDynamic.sSteerWheel.usAngelValue = 0xFFFFu;
  sVehicleDynamic.sSteerWheel.ucSpeedValue = 0xFFu;
  sVehicleDynamic.sSteerWheel.eQty = 0u;

  /* sEnvironment Init */
  sEnvironment.sWiperSpeed.eStatus = 0u;
  sEnvironment.sWiperSpeed.eQty = 0u;
  sEnvironment.sRainIntensity.eStatus = 0u;
  sEnvironment.sRainIntensity.eQty = 0u;
  sEnvironment.sOAT.ucValue = 0x7Eu;
  sEnvironment.sOAT.eQty = 0u;

  /* sBMSInfo Init */
  sBMSInfo.sCapacity.usPecentage = 0x1F4u;
  sBMSInfo.sCharging.eStatusDC = 0u;
  sBMSInfo.sCharging.eStatusAC = 0u;
  sBMSInfo.sCapacity.eQty = 0u;
  sBMSInfo.sCharging.eQtyDC = 0u;
  sBMSInfo.sCharging.eQtyAC = 0u;
  sBMSInfo.sEstimateRange.usValue = 0u;
  sBMSInfo.sPlugStatus.eStatus = 0u;
  sBMSInfo.sPlugStatus.eQty = 0u;
  sBMSInfo.sEstimateRange.eQty = 0u;

  /* sADASInfo Init */
  sADASInfo.sLeftObjectAlarmSet.eValue = 0u;
  sADASInfo.sLeftObjectAlarmSet.eQty = 0u;
  sADASInfo.sAPAFunction.eActive = 0u;
  sADASInfo.sAPAFunction.eStatus = 0u;
  sADASInfo.sAPAFunction.eQty = 0u;

  /* sDoorInfo Init */
  sDoorInfo.sTrunkPositionSt.eStatus = 0u;
  sDoorInfo.sTrunkPositionSt.eQty = 0u;
  sDoorInfo.sLockStatus.eValue = 0u;
  sDoorInfo.sLockStatus.eQty = 0u;
  sDoorInfo.sDoorSt.eStatusFL = 0u;
  sDoorInfo.sDoorSt.eStatusFR = 0u;
  sDoorInfo.sDoorSt.eStatusRL = 0u;
  sDoorInfo.sDoorSt.eStatusRR = 0u;
  sDoorInfo.sDoorSt.eQty = 0u;

  /* sGlobalTime Init */
  sGlobalTime.sAbsoluteTime.ucYear = 0x35u;// 2023 Year
  sGlobalTime.sAbsoluteTime.ucMonth = 0x1u;// 01 Month
  sGlobalTime.sAbsoluteTime.ucDay = 0x1u;// 01 Day
  sGlobalTime.sAbsoluteTime.ucHour = 0x0u;// 0 Hour
  sGlobalTime.sAbsoluteTime.ucMinute = 0x0u;// 0 Minute
  sGlobalTime.sAbsoluteTime.ucSecond = 0x0u;// 0 Second
  sGlobalTime.sAbsoluteTime.usMicrosec = 0u;
  sGlobalTime.sAbsoluteTime.eQty = 0u;

  /* other info Init */
  eQtyBdcmRt7 = 0u;
  ucADCM_ADB_Available = 0u;
  ucBDCM_RT_7_ADCM_Available_St = 0u;
  ucCSM_ADB_AHBSwitch_StPre = 0x03u;
  Read_CSM_ADBSwitch_St(&boAdbEnable);
  eAdbActivation = (boAdbEnable == 0u) ? 0x0u:0x1u;
  usFlashCmdTimer = 0u;
  boFlashCmdPre = sLightCmd.sHighBeam.boValueFlash;
}

STATIC_AL void Read_CSM_ADBSwitch_St(uint8 *data)
{
  uint8 *pData,i;

  pData = Rte_Pim_Pim_CSM_ADBSwitch_St();
  for(i=0u;i<1u;i++)
  {
    *(data+i) = *(pData+i);
  }
}

STATIC_AL void Write_CSM_ADBSwitch_St(const uint8 *data)
{
  uint8 *pData,i;

  pData = Rte_Pim_Pim_CSM_ADBSwitch_St();

  for(i=0u;i<1u;i++)
  {
    *(pData+i) = *(data+i);
  }

  SwcNvmWrapper_WriteNvmReq(ID_CSM_ADBSWITCH_ST,pData);
}

STATIC_AL void VehHub_AdbActivation(void)
{
  tisSysMonCanErrorState VehHub_CanErrorState;
  tisCan0NodeErrorType VehHub_BodyCanErrorState;
  
  //read can0 state
  Rte_Read_PpareSysMonSysMonCanErrorState_sSysMonCanErrorState(&VehHub_CanErrorState);
  VehHub_BodyCanErrorState.Can0ErrorState = VehHub_CanErrorState.ucCAN0;

  if(usFlashCmdTimer > 0u)
  {
    usFlashCmdTimer--;
  }

  if((eQtyBdcmRt7 == 0u) && (ucBDCM_RT_7_ADCM_Available_St == 0u))
  {
    /* ucADCM_ADB_Available value Valid */
  }
  else
  {
    ucADCM_ADB_Available=0u;
  }

  if((eQtyBdcm14 == 0u) && (ucADCM_ADB_Available == 1u))
  {
    if(((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus == 0x01u))
    &&((sLightCmd.sLightSwitch.eQty == 0u) && (sLightCmd.sLightSwitch.eStatus == 0x01u))
    &&((sLightCmd.sLowerBeam.eQty == 0u) && (sLightCmd.sLowerBeam.boValue == 0x01u)))
    {
      /* ucCSM_ADB_AHBSwitch_St value Valid */
    }
    else
    {
      ucCSM_ADB_AHBSwitch_St = 0x03u;
    }
  }
  else
  {
    ucCSM_ADB_AHBSwitch_St = 0x03u;
  }

  switch(eAdbActivation)
  {
    /* OFF */
    case 0x0u:
      if(((ucCSM_ADB_AHBSwitch_StPre != 0x01u) && (ucCSM_ADB_AHBSwitch_St == 0x01u))
      &&((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus == 0x01u)))
      {
        boAdbEnable = ((boAdbEnable + 1u) & 0x1u);
        Write_CSM_ADBSwitch_St(&boAdbEnable);
        eAdbActivation = 0x1u;
      }

      if((sLightCmd.sHighBeam.eQtyFlash == 0u) && ((sLightCmd.sHighBeam.boValueFlash == 0x00u) && (boFlashCmdPre == 0x01u)))
      {
        usFlashCmdTimer = 500u;
      }
      break;

    /* inactive */
    case 0x1u:
      if(((ucCSM_ADB_AHBSwitch_StPre != 0x01u) && (ucCSM_ADB_AHBSwitch_St == 0x01u))
      &&((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus == 0x01u)))
      {
        boAdbEnable = ((boAdbEnable + 1u) & 0x1u);
        Write_CSM_ADBSwitch_St(&boAdbEnable);
        eAdbActivation = 0x0u;
      }

      if(((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus == 0x01u))
      &&((sLightCmd.sLightSwitch.eQty == 0u) && (sLightCmd.sLightSwitch.eStatus == 0x01u))
      &&((sLightCmd.sLowerBeam.eQty == 0u) && (sLightCmd.sLowerBeam.boValue == 0x01u))
      &&((sLightCmd.sHighBeam.eQtyLamp == 0u) && (sLightCmd.sHighBeam.boValueLamp == 0x00u))
      &&((sLightCmd.sFog.eQty == 0u) && (sLightCmd.sFog.boValue == 0x00u))
      && (ucADCM_ADB_Available == 1u))
      {
        eAdbActivation = 0x2u;
      }

      if((sLightCmd.sHighBeam.eQtyFlash == 0u) && ((sLightCmd.sHighBeam.boValueFlash == 0x00u) && (boFlashCmdPre == 0x01u)))
      {
        usFlashCmdTimer = 500u;
      }
      break;

    /* Standby */
    case 0x2u:
      if(((ucCSM_ADB_AHBSwitch_StPre != 0x01u) && (ucCSM_ADB_AHBSwitch_St == 0x01u))
      &&((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus == 0x01u)))
      {
        boAdbEnable = ((boAdbEnable + 1u) & 0x1u);
        Write_CSM_ADBSwitch_St(&boAdbEnable);
        eAdbActivation = 0x0u;
      }

      if(((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus != 0x01u))
      ||((sLightCmd.sLightSwitch.eQty == 0u) && (sLightCmd.sLightSwitch.eStatus != 0x01u))
      ||((sLightCmd.sLowerBeam.eQty == 0u) && (sLightCmd.sLowerBeam.boValue == 0x00u))
      ||((sLightCmd.sHighBeam.eQtyLamp == 0u) && (sLightCmd.sHighBeam.boValueLamp == 0x01u))
      ||((sLightCmd.sFog.eQty == 0u) && (sLightCmd.sFog.boValue == 0x01u))
      || (ucADCM_ADB_Available == 0u))
      {
        eAdbActivation = 0x1u;
      }

      if((sLightCmd.sHighBeam.eQtyFlash == 0u) && ((sLightCmd.sHighBeam.boValueFlash == 0x00u) && (boFlashCmdPre == 0x01u)))
      {
        usFlashCmdTimer = 500u;
      }

      if(((sEnvironment.sRainIntensity.eQty == 0u) && (sEnvironment.sRainIntensity.eStatus < 0x03u)) //0:No 1:Light 2:Moderate RAIN
      &&((sVehicleDynamic.sSpeed.eQty == 0u) && (sVehicleDynamic.sSpeed.usValue >= 300u))
      &&(usFlashCmdTimer == 0u)
      &&((sLightCmd.sHighBeam.eQtyFlash == 0u) && (sLightCmd.sHighBeam.boValueFlash != 0x01u)))
      {
        eAdbActivation = 0x3u;
      }
      break;

    /* active */
    case 0x3u:
      if(((ucCSM_ADB_AHBSwitch_StPre != 0x01u) && (ucCSM_ADB_AHBSwitch_St == 0x01u))
      &&((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus == 0x01u)))
      {
        boAdbEnable = ((boAdbEnable + 1u) & 0x1u);
        Write_CSM_ADBSwitch_St(&boAdbEnable);
        eAdbActivation = 0x0u;
      }

      if(((sGeneralInfo.sPowerMode.eQty == 0u) && (sGeneralInfo.sPowerMode.eStatus != 0x01u))
      ||((sLightCmd.sLightSwitch.eQty == 0u) && (sLightCmd.sLightSwitch.eStatus != 0x01u))
      ||((sLightCmd.sLowerBeam.eQty == 0u) && (sLightCmd.sLowerBeam.boValue == 0x00u))
      ||((sLightCmd.sHighBeam.eQtyLamp == 0u) && (sLightCmd.sHighBeam.boValueLamp == 0x01u))
      ||((sLightCmd.sFog.eQty == 0u) && (sLightCmd.sFog.boValue == 0x01u))
      || (ucADCM_ADB_Available == 0u))
      {
        eAdbActivation = 0x1u;
      }

      if(((sLightCmd.sHighBeam.eQtyFlash == 0u) && (sLightCmd.sHighBeam.boValueFlash == 0x01u))
      ||((sEnvironment.sRainIntensity.eQty == 1u) || (sEnvironment.sRainIntensity.eStatus >= 0x03u)) //3:Heavy 4~6:Reserved 7:Invalid Qty:Fail
      ||((sVehicleDynamic.sSpeed.eQty == 0u) && (sVehicleDynamic.sSpeed.usValue < 200u)) || (sVehicleDynamic.sSpeed.eQty != 0u))
      {
        eAdbActivation = 0x2u;
      }
      break;

    default:
      break;
  }

  if((VehHub_BodyCanErrorState.Bit.Node0.Bus_Off == 1)                 /* bodycan bus off */
    || (VehHub_BodyCanErrorState.Bit.Node0.Frame_Lost0 == 1)           /* bdcm node missing */ 
    || (VehHub_BodyCanErrorState.Bit.Node0.Frame_Lost1 == 1))          /* routine canrframe lost */
  {
    eAdbActivation = 0x1u;                                             /* set ADB state to inactive */
  }

  ucCSM_ADB_AHBSwitch_StPre=ucCSM_ADB_AHBSwitch_St;
  boFlashCmdPre = sLightCmd.sHighBeam.boValueFlash;

  /*sAdvanceLightCmd Write*/
  sAdvanceLightCmd.boAdbEnable = boAdbEnable;
  sAdvanceLightCmd.eAdbActivation = eAdbActivation;
}

STATIC_AL uint8 VehHub_SetMsgQty(uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty = (tibfQtyStsBits)TIMEOUT_ERROR;
  if (eSigPrepPduState_Failed == status)
  {
    switch (eErr)
    {
      case eSigPrepErrIndRteTimeout:
        wkQty = (tibfQtyStsBits)TIMEOUT_ERROR;
        break;
      case eSigPrepErrIndRteCrc:
        wkQty = (tibfQtyStsBits)CRC_ERROR;
        break;
      case eSigPrepErrIndRteAliveCounter:
        wkQty = (tibfQtyStsBits)SQC_ERROR;
        break;
      default:
        //do nothing
        break;
    }
  }
  else
  {
    wkQty = (tibfQtyStsBits)eSigPrepPduState_Passed;
  }

  return wkQty;
}

void RTE_VehHubBdcm14_WriteData(SG_sigGrpBDCM_14 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sLightCmd Write*/
    sLightCmd.sPosition.boValue = (*data).BDCM_PositionLamp_Cmd;
    sLightCmd.sPosition.eQty = wkQty;

    sLightCmd.sDaytimeRunningLight.boValueLeft = (*data).BDCM_LeftDaytimeRunningLight_Cmd;
    sLightCmd.sDaytimeRunningLight.eQtyLeft = wkQty;
    sLightCmd.sDaytimeRunningLight.boValueRight = (*data).BDCM_RightDaytimeRunningLight_Cmd;
    sLightCmd.sDaytimeRunningLight.eQtyRight = wkQty;

    sLightCmd.sTurn.boValueLeft = (*data).BDCM_LeftTurnLamp_Cmd;
    sLightCmd.sTurn.eQtyLeft = wkQty;
    sLightCmd.sTurn.boValueRight = (*data).BDCM_RightTurnLamp_Cmd;
    sLightCmd.sTurn.eQtyRight = wkQty;
    sLightCmd.sTurn.eValueMode = (*data).BDCM_TurnOnMode;
    sLightCmd.sTurn.eQtyMode = wkQty;

    sLightCmd.sTail.boValue = (*data).BDCM_TailLamp_Cmd;
    sLightCmd.sTail.eQty = wkQty;

    sLightCmd.sBrake.boValue = (*data).BDCM_BrakeLamp_Cmd;
    sLightCmd.sBrake.eQty = wkQty;

    sLightCmd.sReversLight.boValue = (*data).BDCM_ReversingLamp_Cmd;
    sLightCmd.sReversLight.eQty = wkQty;

    sLightCmd.sFog.boValue = (*data).BDCM_FogLamp_Cmd;
    sLightCmd.sFog.eQty = wkQty;

    sLightCmd.sLowerBeam.boValue = (*data).BDCM_LowerBeamLamp_Cmd;
    sLightCmd.sLowerBeam.eQty = wkQty;

    sLightCmd.sHighBeam.boValueLamp = (*data).BDCM_HighBeamLamp_Cmd;
    sLightCmd.sHighBeam.eQtyLamp = wkQty;
    sLightCmd.sHighBeam.boValueFlash = (*data).BDCM_HighBeamFlash_Cmd;
    sLightCmd.sHighBeam.eQtyFlash = wkQty;

    sLightCmd.sFrontLogoLight.boValue = (*data).BDCM_LogoLamp_Cmd;
    sLightCmd.sFrontLogoLight.eQty = wkQty;

    sLightCmd.sLightSwitch.eStatus = (*data).BDCM_LightKnob_St;
    sLightCmd.sLightSwitch.eQty = wkQty;

    ucCSM_ADB_AHBSwitch_St = (*data).CSM_ADB_AHBSwitch_St;
    eQtyBdcm14 = wkQty;

    sLightCmd.sHazard.eStatus = (*data).BDCM_WarnLampSwitch_St;
    wktemp1 = (*data).BDCM_WarnLampSwitch_Valid;
    if (wktemp1 == 1u)
    {
      sLightCmd.sHazard.eQty = 0u;
    }
    else
    {
      sLightCmd.sHazard.eQty = INVALID_VALUE_ERROR;
    }

    /*sDoorInfo Write*/
    sDoorInfo.sTrunkPositionSt.eStatus = (*data).BDCM_RearDoorPosition_St;
    sDoorInfo.sTrunkPositionSt.eQty = wkQty;
  }
  else
  {
    /*sLightCmd Qty update*/
    sLightCmd.sPosition.eQty = wkQty;
    sLightCmd.sDaytimeRunningLight.eQtyLeft = wkQty;
    sLightCmd.sDaytimeRunningLight.eQtyRight = wkQty;
    sLightCmd.sTurn.eQtyLeft = wkQty;
    sLightCmd.sTurn.eQtyRight = wkQty;
    sLightCmd.sTurn.eQtyMode = wkQty;
    sLightCmd.sTail.eQty = wkQty;
    sLightCmd.sBrake.eQty = wkQty;
    sLightCmd.sReversLight.eQty = wkQty;
    sLightCmd.sFog.eQty = wkQty;
    sLightCmd.sLowerBeam.eQty = wkQty;
    sLightCmd.sHighBeam.eQtyLamp = wkQty;
    sLightCmd.sHighBeam.eQtyFlash = wkQty;
    sLightCmd.sFrontLogoLight.eQty = wkQty;
    sLightCmd.sLightSwitch.eQty = wkQty;
    eQtyBdcm14 = wkQty;
    sLightCmd.sHazard.eQty = wkQty;

    /*sDoorInfo Qty update*/
    sDoorInfo.sTrunkPositionSt.eQty = wkQty;
  }
}

void RTE_VehHubBdcm19_WriteData(SG_sigGrpBDCM_19 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sDoorInfo Write*/
    sDoorInfo.sLockStatus.eValue = (*data).BDCM_LockUnlock;
    sDoorInfo.sLockStatus.eQty = wkQty;

    sDoorInfo.sDoorSt.eStatusFL = (*data).BDCM_FLDoor_St;
    sDoorInfo.sDoorSt.eStatusFR = (*data).BDCM_FRDoor_St;
    sDoorInfo.sDoorSt.eStatusRL = (*data).BDCM_RLDoor_St;
    sDoorInfo.sDoorSt.eStatusRR = (*data).BDCM_RRDoor_St;
    sDoorInfo.sDoorSt.eQty = wkQty;

    /*sGeneralInfo Write*/
    sGeneralInfo.sPowerMode.eStatus = (*data).BDCM_PowerMode;
    sGeneralInfo.sPowerMode.eQty = wkQty;

    /*sEnvironment Write*/
    sEnvironment.sWiperSpeed.eStatus = (*data).BDCM_WiperSpeed_St;
    sEnvironment.sWiperSpeed.eQty = wkQty;

    sEnvironment.sRainIntensity.eStatus = (*data).BDCM_RainIntensityLevel;
    sEnvironment.sRainIntensity.eQty = wkQty;
  }
  else
  {
    /*sDoorInfo Qty update*/
    sDoorInfo.sLockStatus.eQty = wkQty;
    sDoorInfo.sDoorSt.eQty = wkQty;

    /*sGeneralInfo Qty update*/
    sGeneralInfo.sPowerMode.eQty = wkQty;

    /*sEnvironment Qty update*/
    sEnvironment.sWiperSpeed.eQty = wkQty;
    sEnvironment.sRainIntensity.eQty = wkQty;
  }
}


void RTE_VehHubBdcmRt1_WriteData(SG_sigGrpBDCM_RT_1 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1,wktemp2,wktemp3;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sEnvironment Write*/
    sEnvironment.sOAT.ucValue = (*data).ACM_EnvironmentTemp;
    wktemp1 = (*data).BDCM_RT_1_ACM_Available_St;
    if (wktemp1 == 0u)
    {
      sEnvironment.sOAT.eQty = 0u;
    }
    else
    {
      sEnvironment.sOAT.eQty = INVALID_VALUE_ERROR;
    }

    /*sBMSInfo Write*/
    sBMSInfo.sCapacity.usPecentage = (*data).BMS_SOCReal;
    sBMSInfo.sCharging.eStatusDC = (*data).BMS_DCCharge_St;
    sBMSInfo.sCharging.eStatusAC = (*data).BMS_ACCharge_St;
    wktemp2 = (*data).BDCM_RT_1_BMS_Available_St;
    if (wktemp2 == 0u)
    {
      sBMSInfo.sCapacity.eQty = 0u;
      sBMSInfo.sCharging.eQtyDC = 0u;
      sBMSInfo.sCharging.eQtyAC = 0u;
    }
    else
    {
      sBMSInfo.sCapacity.eQty = INVALID_VALUE_ERROR;
      sBMSInfo.sCharging.eQtyDC = INVALID_VALUE_ERROR;
      sBMSInfo.sCharging.eQtyAC = INVALID_VALUE_ERROR;
    }

    sBMSInfo.sEstimateRange.usValue = (*data).VDCM_EstimateRange;
    sBMSInfo.sPlugStatus.eStatus = (*data).VDCM_ChargeDischargeCon_St;
    wktemp3 = (*data).BDCM_RT_1_VDCM_Available_St;
    if (wktemp3 == 0u)
    {
      sBMSInfo.sPlugStatus.eQty = 0u;
      sBMSInfo.sEstimateRange.eQty = 0u;
    }
    else
    {
      sBMSInfo.sEstimateRange.eQty = INVALID_VALUE_ERROR;
      sBMSInfo.sPlugStatus.eQty = INVALID_VALUE_ERROR;
    }

    /*sVehicleDynamic Write*/
    sVehicleDynamic.sDrivingMode.eValue = (*data).VDCM_DMSVehicleModeInfo;
    if (wktemp3 == 0u)
    {
      sVehicleDynamic.sDrivingMode.eQty = 0u;
    }
    else
    {
      sVehicleDynamic.sDrivingMode.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sEnvironment Qty update*/
    sEnvironment.sOAT.eQty = wkQty;

    /*sBMSInfo Qty update*/
    sBMSInfo.sCapacity.eQty = wkQty;
    sBMSInfo.sCharging.eQtyDC = wkQty;
    sBMSInfo.sCharging.eQtyAC = wkQty;
    sBMSInfo.sEstimateRange.eQty = wkQty;
    sBMSInfo.sPlugStatus.eQty = wkQty;

    /*sVehicleDynamic Qty update*/
    sVehicleDynamic.sDrivingMode.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt2_WriteData(SG_sigGrpBDCM_RT_2 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sGlobalTime Write*/
    sGlobalTime.sAbsoluteTime.ucYear = (*data).TBOX_AbsoluteTime_Year;
    sGlobalTime.sAbsoluteTime.ucMonth = (*data).TBOX_AbsoluteTime_Month;
    sGlobalTime.sAbsoluteTime.ucDay = (*data).TBOX_AbsoluteTime_Day;
    sGlobalTime.sAbsoluteTime.ucHour = (*data).TBOX_AbsoluteTime_Hour;
    sGlobalTime.sAbsoluteTime.ucMinute = (*data).TBOX_AbsoluteTime_Minute;
    sGlobalTime.sAbsoluteTime.ucSecond = (*data).TBOX_AbsoluteTime_Second;
    sGlobalTime.sAbsoluteTime.usMicrosec = 0;/*Matrix2.0 no this signal*/
    wktemp1 = (*data).BDCM_RT_2_TBOX_Available_St;
    if (wktemp1 == 0u)
    {
      sGlobalTime.sAbsoluteTime.eQty = 0u;
    }
    else
    {
      sGlobalTime.sAbsoluteTime.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sGlobalTime Qty update*/
    sGlobalTime.sAbsoluteTime.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt3_WriteData(SG_sigGrpBDCM_RT_3 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1,wktemp2,wktemp3,wktemp4,wktemp5;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sSpeed.usValue =(uint16)(((uint32)((*data).ESC_VehicleSpeed) * 9) >> 4);
    wktemp1 = (*data).ESC_VehicleSpeed_Valid;
    wktemp2 = (*data).BDCM_RT_3_ESC_Available_St;
    if ( (wktemp1 == 1u)
      && (wktemp2 == 0u) )
    {
      sVehicleDynamic.sSpeed.eQty = 0u;
    }
    else
    {
      sVehicleDynamic.sSpeed.eQty = INVALID_VALUE_ERROR;
    }

    sVehicleDynamic.sAccPedel.ucValue = (*data).VDCM_AccrPedPstn;
    wktemp3 = (*data).VDCM_AccrPedPstn_Valid;
    wktemp4 = (*data).BDCM_RT_3_VDCM_Available_St;
    if ( (wktemp3 == 1u)
      && (wktemp4 == 0u) )
    {
      sVehicleDynamic.sAccPedel.eQty = 0u;
    }
    else
    {
      sVehicleDynamic.sAccPedel.eQty = INVALID_VALUE_ERROR;
    }

    sVehicleDynamic.sActualGear.eValue = (*data).VDCM_ActlGear;
    wktemp5 = (*data).VDCM_ActlGear_Valid;
    if ( (wktemp5 == 1u)
      && (wktemp4 == 0u) )
    {
      sVehicleDynamic.sActualGear.eQty = 0u;
    }
    else
    {
      sVehicleDynamic.sActualGear.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sVehicleDynamic Qty update*/
    sVehicleDynamic.sSpeed.eQty = wkQty;
    sVehicleDynamic.sAccPedel.eQty = wkQty;
    sVehicleDynamic.sActualGear.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt4_WriteData(SG_sigGrpBDCM_RT_4 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sAccelerationRate.usAccValueX = (((*data).ACU_LongitudeAcceleration)/500 - 60) * 98 / 10 ;  //0.1m/s^2
    sVehicleDynamic.sAccelerationRate.boAccStatusX = (*data).ACU_LongitudeAccelerationSensor_St;
    sVehicleDynamic.sAccelerationRate.usRollRateValueX= (*data).ACU_RollRate;
    sVehicleDynamic.sAccelerationRate.boRollRateStatusX =(*data).ACU_RollRateSensor_St;
    wktemp1 = (*data).BDCM_RT_4_ACU_Available_St;
    if (wktemp1 == 0u)
    {
      sVehicleDynamic.sAccelerationRate.eQtyX = 0u;
    }
    else
    {
      sVehicleDynamic.sAccelerationRate.eQtyX = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sVehicleDynamic Qty update*/
    sVehicleDynamic.sAccelerationRate.eQtyX = wkQty;
  }
}

void RTE_VehHubBdcmRt5_WriteData(SG_sigGrpBDCM_RT_5 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sAccelerationRate.usAccValueY = (*data).ACU_LateralAcceleration;
    sVehicleDynamic.sAccelerationRate.boAccStatusY = (*data).ACU_LateralAccelerationSensor_St;
    sVehicleDynamic.sAccelerationRate.usPitchRateValueY= (*data).ACU_PitchRate;
    sVehicleDynamic.sAccelerationRate.boPitchRateStatusY =(*data).ACU_PitchRateSensor_St;
    wktemp1 = (*data).BDCM_RT_5_ACU_Available_St;
    if (wktemp1 == 0u)
    {
      sVehicleDynamic.sAccelerationRate.eQtyY = 0u;
    }
    else
    {
      sVehicleDynamic.sAccelerationRate.eQtyY = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sVehicleDynamic Qty update*/
    sVehicleDynamic.sAccelerationRate.eQtyY = wkQty;
  }
}

void RTE_VehHubBdcmRt6_WriteData(SG_sigGrpBDCM_RT_6 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sAccelerationRate.usAccValueZ = (*data).ACU_VerticalAcceleration;
    sVehicleDynamic.sAccelerationRate.boAccStatusZ = (*data).ACU_VerticalAccelerationSensor_St;
    sVehicleDynamic.sAccelerationRate.usYawRateValueZ= (*data).ACU_YawRate;
    sVehicleDynamic.sAccelerationRate.boYawRateStatusZ =(*data).ACU_YawRateSensor_St;
    wktemp1 = (*data).BDCM_RT_6_ACU_Available_St;
    if (wktemp1 == 0u)
    {
      sVehicleDynamic.sAccelerationRate.eQtyZ = 0u;
    }
    else
    {
      sVehicleDynamic.sAccelerationRate.eQtyZ = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sAccelerationRate.eQtyZ = wkQty;
  }
}

void RTE_VehHubBdcmRt7_WriteData(SG_sigGrpBDCM_RT_7 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sGeneralInfo Write*/
    sGeneralInfo.sMileage.ulValue = (*data).IDCM_VehicleTotalMileage;
    wktemp1 = (*data).BDCM_RT_7_IDCM_Available_St;
    ucBDCM_RT_7_ADCM_Available_St = (*data).BDCM_RT_7_ADCM_Available_St;
    ucADCM_ADB_Available = (*data).ADCM_ADB_Available;
    eQtyBdcmRt7 = wkQty;
    if (wktemp1 == 0u)
    {
      sGeneralInfo.sMileage.eQty = 0u;
    }
    else
    {
      sGeneralInfo.sMileage.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sGeneralInfo Write*/
    sGeneralInfo.sMileage.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt13_WriteData(SG_sigGrpBDCM_RT_13 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sSuspensionHeight.usValueFL = (*data).AIRS_Height_FL;
    sVehicleDynamic.sSuspensionHeight.usValueFR = (*data).AIRS_Height_FR;
    sVehicleDynamic.sSuspensionHeight.usValueRL = (*data).AIRS_Height_RL;
    sVehicleDynamic.sSuspensionHeight.usValueRR = (*data).AIRS_Height_RR;
    wktemp1 = (*data).BDCM_RT_13_AIRS_Available_St;
    if (wktemp1 == 0u)
    {
      sVehicleDynamic.sSuspensionHeight.eQty = 0u;
    }
    else
    {
      sVehicleDynamic.sSuspensionHeight.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sVehicleDynamic Qty update*/
    sVehicleDynamic.sSuspensionHeight.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt14_WriteData(SG_sigGrpBDCM_RT_14 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sADASInfo Write*/
    sADASInfo.sAPAFunction.eActive = (*data).APA_ActiveSubFun;
    sADASInfo.sAPAFunction.eStatus = (*data).APA_ParkingState;
    wktemp1 = (*data).BDCM_RT_14_APA_Available_St;
    if (wktemp1 == 0u)
    {
      sADASInfo.sAPAFunction.eQty = 0u;
    }
    else
    {
      sADASInfo.sAPAFunction.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sADASInfo Qty update*/
    sADASInfo.sAPAFunction.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt31_WriteData(SG_sigGrpBDCM_RT_31 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;
  uint8 wktemp1;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sVehicleDynamic Write*/
    sVehicleDynamic.sSteerWheel.usAngelValue = (*data).EPS_PinionAg_1;
    sVehicleDynamic.sSteerWheel.ucSpeedValue = (*data).EPS_PinionAgSpd_1;
    wktemp1 = (*data).EPS_PinionAg_Valid_1;
    if (wktemp1 == 1u)
    {
      sVehicleDynamic.sSteerWheel.eQty = 0u;
    }
    else
    {
      sVehicleDynamic.sSteerWheel.eQty = INVALID_VALUE_ERROR;
    }
  }
  else
  {
    /*sVehicleDynamic Qty update*/
    sVehicleDynamic.sSteerWheel.eQty = wkQty;
  }
}

void RTE_VehHubBdcmRt45_WriteData(SG_sigGrpBDCM_RT_45 *data, uint8 status, uint8 eErr)
{
  tieComnQtySts wkQty;

  wkQty = VehHub_SetMsgQty(status,eErr);

  if( wkQty == (tibfQtyStsBits)eSigPrepPduState_Passed )
  {
    /*sADASInfo Write*/
    sADASInfo.sLeftObjectAlarmSet.eValue = (*data).IDCM_LeftObjectAlarm_Set;
    sADASInfo.sLeftObjectAlarmSet.eQty = wkQty;
  }
  else
  {
    /*sADASInfo Qty update*/
    sADASInfo.sLeftObjectAlarmSet.eQty = wkQty;
  }
}

/*sLightCmd Read*/
void RTE_VehHubLightCmd_ReadData(tisLightCmd *data)
{
  (*data).sPosition.boValue=sLightCmd.sPosition.boValue;
  (*data).sPosition.eQty=sLightCmd.sPosition.eQty;

  (*data).sDaytimeRunningLight.boValueLeft =  sLightCmd.sDaytimeRunningLight.boValueLeft;
  (*data).sDaytimeRunningLight.eQtyLeft =  sLightCmd.sDaytimeRunningLight.eQtyLeft;
  (*data).sDaytimeRunningLight.boValueRight =  sLightCmd.sDaytimeRunningLight.boValueRight;
  (*data).sDaytimeRunningLight.eQtyRight =  sLightCmd.sDaytimeRunningLight.eQtyRight;

  (*data).sTurn.boValueLeft = sLightCmd.sTurn.boValueLeft;
  (*data).sTurn.eQtyLeft = sLightCmd.sTurn.eQtyLeft;
  (*data).sTurn.boValueRight = sLightCmd.sTurn.boValueRight;
  (*data).sTurn.eQtyRight = sLightCmd.sTurn.eQtyRight;
  (*data).sTurn.eValueMode = sLightCmd.sTurn.eValueMode;
  (*data).sTurn.eQtyMode = sLightCmd.sTurn.eQtyMode;

  (*data).sTail.boValue = sLightCmd.sTail.boValue;
  (*data).sTail.eQty = sLightCmd.sTail.eQty;

  (*data).sBrake.boValue = sLightCmd.sBrake.boValue;
  (*data).sBrake.eQty = sLightCmd.sBrake.eQty;

  (*data).sReversLight = sLightCmd.sReversLight;
  (*data).sReversLight = sLightCmd.sReversLight;

  (*data).sFog.boValue = sLightCmd.sFog.boValue;
  (*data).sFog.eQty = sLightCmd.sFog.eQty;

  (*data).sLowerBeam.boValue = sLightCmd.sLowerBeam.boValue;
  (*data).sLowerBeam.eQty = sLightCmd.sLowerBeam.eQty;

  (*data).sHighBeam.boValueLamp = sLightCmd.sHighBeam.boValueLamp;
  (*data).sHighBeam.eQtyLamp = sLightCmd.sHighBeam.eQtyLamp;
  (*data).sHighBeam.boValueFlash = sLightCmd.sHighBeam.boValueFlash;
  (*data).sHighBeam.eQtyFlash = sLightCmd.sHighBeam.eQtyFlash;

  (*data).sFrontLogoLight.boValue = sLightCmd.sFrontLogoLight.boValue;
  (*data).sFrontLogoLight.eQty = sLightCmd.sFrontLogoLight.eQty;

  (*data).sLightSwitch.eStatus = sLightCmd.sLightSwitch.eStatus;
  (*data).sLightSwitch.eQty = sLightCmd.sLightSwitch.eQty;

  //(*data).sAdbEnable.eStatus = sLightCmd.sAdbEnable.eStatus;
  //(*data).sAdbEnable.eQty = sLightCmd.sAdbEnable.eQty;

  (*data).sHazard.eStatus = sLightCmd.sHazard.eStatus;
  (*data).sHazard.eQty = sLightCmd.sHazard.eQty;
}

/*sDoorInfo Read*/
void RTE_VehHubDoorInfo_ReadData(tisDoorInfo *data)
{
  (*data).sTrunkPositionSt.eStatus =sDoorInfo.sTrunkPositionSt.eStatus;
  (*data).sTrunkPositionSt.eQty = sDoorInfo.sTrunkPositionSt.eQty;

  (*data).sLockStatus.eValue = sDoorInfo.sLockStatus.eValue;
  (*data).sLockStatus.eQty = sDoorInfo.sLockStatus.eQty;

  (*data).sDoorSt.eStatusFL = sDoorInfo.sDoorSt.eStatusFL;
  (*data).sDoorSt.eStatusFR = sDoorInfo.sDoorSt.eStatusFR;
  (*data).sDoorSt.eStatusRL = sDoorInfo.sDoorSt.eStatusRL;
  (*data).sDoorSt.eStatusRR = sDoorInfo.sDoorSt.eStatusRR;
  (*data).sDoorSt.eQty = sDoorInfo.sDoorSt.eQty;
}

/*sGeneralInfo Read*/
void RTE_VehHubGeneralInfo_ReadData(tisGeneralInfo *data)
{
  (*data).sPowerMode.eStatus = sGeneralInfo.sPowerMode.eStatus;
  (*data).sPowerMode.eQty = sGeneralInfo.sPowerMode.eQty;

  (*data).sMileage.ulValue = sGeneralInfo.sMileage.ulValue;
  (*data).sMileage.eQty = sGeneralInfo.sMileage.eQty;
}

/*sEnvironment Read*/
void RTE_VehHubEnvironment_ReadData(tisEnvironment *data)
{
  (*data).sWiperSpeed.eStatus = sEnvironment.sWiperSpeed.eStatus;
  (*data).sWiperSpeed.eQty = sEnvironment.sWiperSpeed.eQty;

  (*data).sRainIntensity.eStatus = sEnvironment.sRainIntensity.eStatus;
  (*data).sRainIntensity.eQty = sEnvironment.sRainIntensity.eQty;

  (*data).sOAT.ucValue = sEnvironment.sOAT.ucValue;
  (*data).sOAT.eQty = sEnvironment.sOAT.eQty;
}

/*sBMSInfo Read*/
void RTE_VehHubBMSInfo_ReadData(tisBMSInfo *data)
{
  (*data).sCapacity.usPecentage = sBMSInfo.sCapacity.usPecentage;
  (*data).sCapacity.eQty = sBMSInfo.sCapacity.eQty;

  (*data).sCharging.eStatusDC = sBMSInfo.sCharging.eStatusDC;
  (*data).sCharging.eStatusAC = sBMSInfo.sCharging.eStatusAC;
  (*data).sCharging.eQtyDC = sBMSInfo.sCharging.eQtyDC;
  (*data).sCharging.eQtyAC = sBMSInfo.sCharging.eQtyAC;

  (*data).sEstimateRange.usValue = sBMSInfo.sEstimateRange.usValue;
  (*data).sEstimateRange.eQty = sBMSInfo.sEstimateRange.eQty;

  (*data).sPlugStatus.eStatus = sBMSInfo.sPlugStatus.eStatus;
  (*data).sPlugStatus.eQty = sBMSInfo.sPlugStatus.eQty;
}

/*sVehicleDynamic Read*/
void RTE_VehHubVehicleDynamic_ReadData(tisVehicleDynamic *data)
{
  (*data).sDrivingMode.eValue = sVehicleDynamic.sDrivingMode.eValue;
  (*data).sDrivingMode.eQty = sVehicleDynamic.sDrivingMode.eQty;

  (*data).sSpeed.usValue = sVehicleDynamic.sSpeed.usValue;
  (*data).sSpeed.eQty = sVehicleDynamic.sSpeed.eQty;
  (*data).sAccPedel.ucValue = sVehicleDynamic.sAccPedel.ucValue;
  (*data).sAccPedel.eQty = sVehicleDynamic.sAccPedel.eQty;
  (*data).sActualGear.eValue = sVehicleDynamic.sActualGear.eValue;
  (*data).sActualGear.eQty = sVehicleDynamic.sActualGear.eQty;

  (*data).sAccelerationRate.usAccValueX = sVehicleDynamic.sAccelerationRate.usAccValueX;
  (*data).sAccelerationRate.boAccStatusX = sVehicleDynamic.sAccelerationRate.boAccStatusX;
  (*data).sAccelerationRate.usRollRateValueX = sVehicleDynamic.sAccelerationRate.usRollRateValueX;
  (*data).sAccelerationRate.boRollRateStatusX = sVehicleDynamic.sAccelerationRate.boRollRateStatusX;
  (*data).sAccelerationRate.eQtyX = sVehicleDynamic.sAccelerationRate.eQtyX;

  (*data).sAccelerationRate.usAccValueY = sVehicleDynamic.sAccelerationRate.usAccValueY;
  (*data).sAccelerationRate.boAccStatusY = sVehicleDynamic.sAccelerationRate.boAccStatusY;
  (*data).sAccelerationRate.usPitchRateValueY = sVehicleDynamic.sAccelerationRate.usPitchRateValueY;
  (*data).sAccelerationRate.boPitchRateStatusY = sVehicleDynamic.sAccelerationRate.boPitchRateStatusY;
  (*data).sAccelerationRate.eQtyY = sVehicleDynamic.sAccelerationRate.eQtyY;

  (*data).sAccelerationRate.usAccValueZ = sVehicleDynamic.sAccelerationRate.usAccValueZ;
  (*data).sAccelerationRate.boAccStatusZ = sVehicleDynamic.sAccelerationRate.boAccStatusZ;
  (*data).sAccelerationRate.usYawRateValueZ = sVehicleDynamic.sAccelerationRate.usYawRateValueZ;
  (*data).sAccelerationRate.boYawRateStatusZ = sVehicleDynamic.sAccelerationRate.boYawRateStatusZ;
  (*data).sAccelerationRate.eQtyZ = sVehicleDynamic.sAccelerationRate.eQtyZ;

  (*data).sSuspensionHeight.usValueFL = sVehicleDynamic.sSuspensionHeight.usValueFL;
  (*data).sSuspensionHeight.usValueFR = sVehicleDynamic.sSuspensionHeight.usValueFR;
  (*data).sSuspensionHeight.usValueRL = sVehicleDynamic.sSuspensionHeight.usValueRL;
  (*data).sSuspensionHeight.usValueRR = sVehicleDynamic.sSuspensionHeight.usValueRR;
  (*data).sSuspensionHeight.eQty = sVehicleDynamic.sSuspensionHeight.eQty;

  (*data).sSteerWheel.usAngelValue = sVehicleDynamic.sSteerWheel.usAngelValue;
  (*data).sSteerWheel.ucSpeedValue = sVehicleDynamic.sSteerWheel.ucSpeedValue;
  (*data).sSteerWheel.eQty = sVehicleDynamic.sSteerWheel.eQty;
}

/*sGlobalTime Read*/
void RTE_VehHubGlobalTime_ReadData(tisGlobalTime *data)
{
  (*data).sAbsoluteTime.ucYear = sGlobalTime.sAbsoluteTime.ucYear;
  (*data).sAbsoluteTime.ucMonth = sGlobalTime.sAbsoluteTime.ucMonth;
  (*data).sAbsoluteTime.ucDay = sGlobalTime.sAbsoluteTime.ucDay;
  (*data).sAbsoluteTime.ucHour = sGlobalTime.sAbsoluteTime.ucHour;
  (*data).sAbsoluteTime.ucMinute = sGlobalTime.sAbsoluteTime.ucMinute;
  (*data).sAbsoluteTime.ucSecond = sGlobalTime.sAbsoluteTime.ucSecond;
  (*data).sAbsoluteTime.usMicrosec = sGlobalTime.sAbsoluteTime.usMicrosec;
  (*data).sAbsoluteTime.eQty = sGlobalTime.sAbsoluteTime.eQty;
}

/*sADASInfo Read*/
void RTE_VehHubADASInfo_ReadData(tisADASInfo *data)
{
  (*data).sLeftObjectAlarmSet.eValue = sADASInfo.sLeftObjectAlarmSet.eValue;
  (*data).sLeftObjectAlarmSet.eQty = sADASInfo.sLeftObjectAlarmSet.eQty;

  (*data).sAPAFunction.eActive = sADASInfo.sAPAFunction.eActive;
  (*data).sAPAFunction.eStatus = sADASInfo.sAPAFunction.eStatus;
  (*data).sAPAFunction.eQty = sADASInfo.sAPAFunction.eQty;
}

/*sAdvanceLightCmd Read*/
void RTE_VehHubAdvanceLightCmd_ReadData(tisAdvanceLightCmd *data)
{
  (*data).boAdbEnable = sAdvanceLightCmd.boAdbEnable;
  (*data).eAdbActivation = sAdvanceLightCmd.eAdbActivation;
}

#define VehicleHub_STOP_SEC_CODE
#include "ctaaVehicleHub_MemMap.h"