533 lines
16 KiB
C
533 lines
16 KiB
C
/**
|
|
* @file module_driver_tmu.c
|
|
* @author Flagchip
|
|
* @brief TMU driver source code
|
|
* @version 2.0.0
|
|
* @date 2024-08-20
|
|
*
|
|
* SDK Version: 2.6.0
|
|
*
|
|
|
|
* @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd.
|
|
*
|
|
* @details
|
|
*/
|
|
/*********************************************************************************
|
|
* Revision History:
|
|
*
|
|
* Version Date Initials CR# Descriptions
|
|
* --------- ---------- ------------ ---------- ---------------
|
|
* 0.1.0 2022-12-30 Flagchip074 N/A First version for FC7xxx
|
|
* 0.2.0 2023-02-15 Flagchip074 N/A FC7xxx release version
|
|
******************************************************************************** */
|
|
|
|
#include "module_driver_tmu.h"
|
|
|
|
#if TMU_INSTANCE_COUNT > 0U
|
|
#if TMU_SUPPORT_TV_ECMP
|
|
#include "module_driver_adc.h"
|
|
#endif
|
|
#include "module_driver_pcc.h"
|
|
|
|
#ifndef TMU_DEV_ERROR_REPORT
|
|
#define TMU_DEV_ERROR_REPORT STD_OFF
|
|
#endif
|
|
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
#define TMU_ReportDevError(func, error) ReportDevError(TMU_MODULE_ID, func, error)
|
|
#endif
|
|
|
|
|
|
/********* Local Variables ************/
|
|
/** @brief TMU peripheral base pointers */
|
|
static TMU_Type *const s_apTmuBase[TMU_INSTANCE_COUNT] = TMU_BASE_PTRS;
|
|
#if TMU_SUPPORT_TV_ECMP
|
|
static ADC_Type *const s_apTmuAdcUsedBase[ADC_INSTANCE_COUNT] = ADC_BASE_PTRS;
|
|
#endif
|
|
/**
|
|
* @brief TMU interrupt process
|
|
*
|
|
*/
|
|
void TMU_ProcessIRQHandler(TMU_HandleType* pTmuHandle)
|
|
{
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
#if TMU_SUPPORT_TV_ECMP
|
|
ADC_Type *const pAdc = s_apTmuAdcUsedBase[pTmuHandle->u8AdcIntanceUsed];
|
|
if (TMU_HWA_GetVoltageTemperatureCompare1InterruptEnableStatus(pTmu) == true)
|
|
{
|
|
if (TMU_HWA_GetVoltageTemperatureCompareFlag1(pTmu) == true)
|
|
{
|
|
ADC_HWA_ClearECMPHighFlag(pAdc, ADC_ECMP1);
|
|
ADC_HWA_ClearECMPLowFlag(pAdc, ADC_ECMP1);
|
|
ADC_HWA_ClearECMPWinFlag(pAdc, ADC_ECMP1);
|
|
TMU_HWA_ClearVoltageTemperatureCompareFlag1(pTmu);
|
|
if (pTmuHandle->tSettings.TMU_TempCompareFlag1InterruptCallback != NULL)
|
|
{
|
|
pTmuHandle->tSettings.TMU_TempCompareFlag1InterruptCallback(pTmuHandle);
|
|
}
|
|
}
|
|
}
|
|
if (TMU_HWA_GetVoltageTemperatureCompare0InterruptEnableStatus(pTmu) == true)
|
|
{
|
|
if (TMU_HWA_GetVoltageTemperatureCompareFlag0(pTmu) == true)
|
|
{
|
|
ADC_HWA_ClearECMPHighFlag(pAdc, ADC_ECMP0);
|
|
ADC_HWA_ClearECMPLowFlag(pAdc, ADC_ECMP0);
|
|
ADC_HWA_ClearECMPWinFlag(pAdc, ADC_ECMP0);
|
|
TMU_HWA_ClearVoltageTemperatureCompareFlag0(pTmu);
|
|
if (pTmuHandle->tSettings.TMU_TempCompareFlag0InterruptCallback != NULL)
|
|
{
|
|
pTmuHandle->tSettings.TMU_TempCompareFlag0InterruptCallback(pTmuHandle);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
if (TMU_HWA_GetFlagTemperature150InterruptFlag(pTmu) == true)
|
|
{
|
|
if (TMU_HWA_Get150Flag(pTmu) == true)
|
|
{
|
|
if (pTmuHandle->tSettings.TMU_TempOver150InterruptCallback != NULL)
|
|
{
|
|
pTmuHandle->tSettings.TMU_TempOver150InterruptCallback(pTmuHandle);
|
|
}
|
|
TMU_HWA_Clear150Flag(pTmu);
|
|
}
|
|
}
|
|
if (TMU_HWA_GetFlagTemperature125InterruptFlag(pTmu) == true)
|
|
{
|
|
if (TMU_HWA_Get125Flag(pTmu) == true)
|
|
{
|
|
if (pTmuHandle->tSettings.TMU_TempOver125InterruptCallback != NULL)
|
|
{
|
|
pTmuHandle->tSettings.TMU_TempOver125InterruptCallback(pTmuHandle);
|
|
}
|
|
TMU_HWA_Clear125Flag(pTmu);
|
|
}
|
|
}
|
|
if (TMU_HWA_GetFlagTemperatureReadyInterruptFlag(pTmu) == true)
|
|
{
|
|
if (TMU_HWA_GetFlagTemperatureReady(pTmu) == true)
|
|
{
|
|
if (pTmuHandle->tSettings.TMU_TempFlagReadyInterruptCallback != NULL)
|
|
{
|
|
pTmuHandle->tSettings.TMU_TempFlagReadyInterruptCallback(pTmuHandle);
|
|
}
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_UNLOCK);
|
|
|
|
TMU_HWA_ClearFlagTemperatureReady(pTmu);
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
}
|
|
}
|
|
if (TMU_HWA_GetVoltageTemperatureReadyInterruptFlag(pTmu) == true)
|
|
{
|
|
if (TMU_HWA_GetVoltageTemperatureReady(pTmu) == true)
|
|
{
|
|
if (pTmuHandle->tSettings.TMU_TempVoltageReadyInterruptCallback != NULL)
|
|
{
|
|
pTmuHandle->tSettings.TMU_TempVoltageReadyInterruptCallback(pTmuHandle);
|
|
}
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_UNLOCK);
|
|
|
|
TMU_HWA_ClearVoltageTemperatureReady(pTmu);
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the TMU instance
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @param pInitCfg: the configurations of the TMU instance
|
|
*/
|
|
void TMU_Init(TMU_HandleType* pTmuHandle, const TMU_InitType *const pInitCfg)
|
|
{
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if((pTmuHandle == NULL) || (pInitCfg == NULL))
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_POINTER);
|
|
}
|
|
else if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
uint32_t u32FlagCtrl;
|
|
uint32_t u32VoltageCtrl;
|
|
uint8_t u8FlagStartupCnt;
|
|
uint8_t u8VoltageStartupCnt;
|
|
|
|
PCC_ClkSrcType eAdcClkName = PCC_CLK_TMU0;
|
|
uint32_t u32TmuClk;
|
|
u32TmuClk = PCC_GetPccFunctionClock(eAdcClkName);
|
|
|
|
u8FlagStartupCnt = (uint8_t)((u32TmuClk * 11U) / 127000000U + 1U);
|
|
u8VoltageStartupCnt = (uint8_t)((u32TmuClk * 5U) / 127000000U + 1U);
|
|
if (u8FlagStartupCnt > 15U)
|
|
{
|
|
u8FlagStartupCnt = 15U;
|
|
}
|
|
if (u8VoltageStartupCnt > 7U)
|
|
{
|
|
u8VoltageStartupCnt = 7U;
|
|
}
|
|
|
|
pTmuHandle->tStatus.bTemperatureOver125IntEn = pInitCfg->bTemperatureOver125IntEn;
|
|
pTmuHandle->tStatus.bTemperatureOver150IntEn = pInitCfg->bTemperatureOver150IntEn;
|
|
pTmuHandle->tStatus.bFlagTempReadyIntEn = pInitCfg->bFlagTempReadyIntEn;
|
|
pTmuHandle->tStatus.bVoltageTempReadyIntEn = pInitCfg->bVoltageTempReadyIntEn;
|
|
|
|
u32FlagCtrl = TMU_TF_CTRL_TF_HYSOFF(pInitCfg->eFlagTempHysteresisCon) |
|
|
TMU_TF_CTRL_TF_START_CNT(u8FlagStartupCnt) |
|
|
#ifdef TMU_SUPPORT_STOP
|
|
TMU_TF_CTRL_TF_STOP_EN(pInitCfg->bFlagTempStopModeEn) |
|
|
#endif
|
|
TMU_TF_CTRL_TF_FILT_BYP(pInitCfg->eFlagTempFilterBypassCon);
|
|
TMU_HWA_SetFlagTempCtrl(pTmu, u32FlagCtrl);
|
|
|
|
u32VoltageCtrl = TMU_TV_CTRL_TV_START_CNT(u8VoltageStartupCnt);
|
|
#else
|
|
uint32_t u32VoltageCtrl = 0U;
|
|
pTmuHandle->tStatus.bVoltageTempCompareFlag1IntEn = pInitCfg->bVoltageTempCompareFlag1IntEn;
|
|
pTmuHandle->tStatus.bVoltageTempCompareFlag0IntEn = pInitCfg->bVoltageTempCompareFlag0IntEn;
|
|
#endif
|
|
#ifdef TMU_SUPPORT_STOP
|
|
u32VoltageCtrl |= TMU_TV_CTRL_TV_STOP_EN(pInitCfg->bVoltageTempStopModeEn);
|
|
#endif
|
|
|
|
TMU_HWA_SetVoltageTempCtrl(pTmu, u32VoltageCtrl);
|
|
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
/**
|
|
* @brief Enable the Flag-based temperature sensor
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @return TMU_StatusType TMU_STATUS_SUCCESS when enable successfully, others fail
|
|
*/
|
|
TMU_StatusType TMU_FlagTempEnable(TMU_HandleType* pTmuHandle)
|
|
{
|
|
TMU_StatusType eRet = TMU_STATUS_ERROR;
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
uint32_t u32TimeOut = 15000000U;
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_UNLOCK);
|
|
TMU_HWA_SetFlagTemperature150InterruptFlag(pTmu, pTmuHandle->tStatus.bTemperatureOver150IntEn);
|
|
TMU_HWA_SetFlagTemperature125InterruptFlag(pTmu, pTmuHandle->tStatus.bTemperatureOver125IntEn);
|
|
TMU_HWA_SetFlagTemperatureEnableStatus(pTmu, true);
|
|
while ((TMU_HWA_GetFlagTemperatureReady(pTmu) != true) && (u32TimeOut != 0U))
|
|
{
|
|
u32TimeOut--;
|
|
}
|
|
if (u32TimeOut != 0U)
|
|
{
|
|
TMU_HWA_SetFlagTemperatureReadyInterruptFlag(pTmu, pTmuHandle->tStatus.bFlagTempReadyIntEn);
|
|
eRet = TMU_STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
eRet = TMU_STATUS_TIMEOUT;
|
|
}
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
return eRet;
|
|
}
|
|
|
|
/**
|
|
* @brief Disable the Flag-based temperature sensor
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @return TMU_StatusType TMU_STATUS_SUCCESS when disable successfully, others fail
|
|
*/
|
|
TMU_StatusType TMU_FlagTempDisable(TMU_HandleType* pTmuHandle)
|
|
{
|
|
TMU_StatusType eRet = TMU_STATUS_ERROR;
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
uint32_t u32TimeOut = 15000000U;
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_UNLOCK);
|
|
/* Before clearing the flag-enable bit, the bit TF_RDYF_IE, TF_150F_IE, and TF_125F_IE must be cleared first. */
|
|
TMU_HWA_SetFlagTemperature150InterruptFlag(pTmu, false);
|
|
TMU_HWA_SetFlagTemperature125InterruptFlag(pTmu, false);
|
|
TMU_HWA_SetFlagTemperatureReadyInterruptFlag(pTmu, false);
|
|
TMU_HWA_SetFlagTemperatureEnableStatus(pTmu, false);
|
|
TMU_HWA_ClearFlagTemperatureReady(pTmu);
|
|
while ((TMU_HWA_GetFlagTemperatureEnableStatus(pTmu) == true) && (u32TimeOut != 0U))
|
|
{
|
|
u32TimeOut--;
|
|
}
|
|
if (u32TimeOut != 0U)
|
|
{
|
|
eRet = TMU_STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
eRet = TMU_STATUS_TIMEOUT;
|
|
}
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
return eRet;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Enable the Voltage-based temperature sensor
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @return TMU_StatusType TMU_STATUS_SUCCESS when enable successfully, others fail
|
|
*/
|
|
TMU_StatusType TMU_VoltageTempEnable(TMU_HandleType* pTmuHandle)
|
|
{
|
|
TMU_StatusType eRet = TMU_STATUS_ERROR;
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
uint32_t u32TimeOut = 15000000U;
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_UNLOCK);
|
|
TMU_HWA_SetVoltageTemperatureEnableStatus(pTmu, true);
|
|
while ((TMU_HWA_GetVoltageTemperatureReady(pTmu) != true) && (u32TimeOut != 0U))
|
|
{
|
|
u32TimeOut--;
|
|
}
|
|
if (u32TimeOut != 0U)
|
|
{
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
TMU_HWA_SetVoltageTemperatureReadyInterruptFlag(pTmu, pTmuHandle->tStatus.bVoltageTempReadyIntEn);
|
|
#endif
|
|
eRet = TMU_STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
eRet = TMU_STATUS_TIMEOUT;
|
|
}
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
return eRet;
|
|
}
|
|
|
|
/**
|
|
* @brief Disable the Voltage-based temperature sensor
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @return TMU_StatusType TMU_STATUS_SUCCESS when disable successfully, others fail
|
|
*/
|
|
TMU_StatusType TMU_VoltageTempDisable(TMU_HandleType* pTmuHandle)
|
|
{
|
|
TMU_StatusType eRet = TMU_STATUS_ERROR;
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
uint32_t u32TimeOut = 15000000U;
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_UNLOCK);
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
/* Before clearing the Voltage-enable bit, the bit TV_RDYF_IE must be cleared first. */
|
|
TMU_HWA_SetVoltageTemperatureReadyInterruptFlag(pTmu, false);
|
|
#endif
|
|
TMU_HWA_SetVoltageTemperatureEnableStatus(pTmu, false);
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
TMU_HWA_ClearVoltageTemperatureReady(pTmu);
|
|
#endif
|
|
while ((TMU_HWA_GetVoltageTemperatureEnableStatus(pTmu) == true) && (u32TimeOut != 0U))
|
|
{
|
|
u32TimeOut--;
|
|
}
|
|
if (u32TimeOut != 0U)
|
|
{
|
|
eRet = TMU_STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
eRet = TMU_STATUS_TIMEOUT;
|
|
}
|
|
TMU_HWA_SetTemperatureLockStatus(pTmu, TMU_TF_TV_LOCK);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
return eRet;
|
|
}
|
|
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
/**
|
|
* @brief Check if cleaning flag is required
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
*/
|
|
void TMU_TempOverClear(TMU_HandleType* pTmuHandle)
|
|
{
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
if (TMU_HWA_Get150Flag(pTmu))
|
|
{
|
|
if (!TMU_HWA_Get150Status(pTmu))
|
|
{
|
|
TMU_HWA_Clear150Flag(pTmu);
|
|
}
|
|
}
|
|
if (TMU_HWA_Get125Flag(pTmu))
|
|
{
|
|
if (!TMU_HWA_Get125Status(pTmu))
|
|
{
|
|
TMU_HWA_Clear125Flag(pTmu);
|
|
}
|
|
}
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifdef TMU_SUPPORT_STOP
|
|
#if !TMU_SUPPORT_TV_ECMP
|
|
/**
|
|
* @brief Set the Flag-based temperature sensor is enabled/disabled in stop mode
|
|
*
|
|
*@param pTmuHandle: TMU processing handle
|
|
* @param bEnable: whether Flag-based temperature sensor is enabled in stop mode if TF_EN is active.
|
|
*/
|
|
void TMU_FlagTempSetStopMode(TMU_HandleType* pTmuHandle, bool bEnable)
|
|
{
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
TMU_HWA_ConfigFlagTemperatureStopMode(pTmu, bEnable);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Set the Voltage-based temperature sensor is enabled/disabled in stop mode
|
|
*
|
|
*@param pTmuHandle: TMU processing handle
|
|
* @param bEnable: whether Voltage-based temperature sensor is enabled in stop mode if TV_EN is active.
|
|
*/
|
|
void TMU_VoltageTempSetStopMode(TMU_HandleType* pTmuHandle, bool bEnable)
|
|
{
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
TMU_HWA_ConfigVoltageTemperatureStopMode(pTmu, bEnable);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifdef TMU_SUPPORT_TRIM
|
|
/**
|
|
* @brief Get the temperature code from ADC
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @return uint32_t the value records the ADC conversion results for voltage-based temperature sensor result in 135 Celsius
|
|
*/
|
|
uint32_t TMU_GetTcode(TMU_HandleType* pTmuHandle)
|
|
{
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
return 0U;
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
return TMU_HWA_GetTemperatureCode(pTmu);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
/**
|
|
* @brief Get the slope factor
|
|
*
|
|
* @param pTmuHandle: TMU processing handle
|
|
* @return uint32_t the value records the slope factor for voltage-based temperature sensor
|
|
*/
|
|
uint32_t TMU_GetTslope(TMU_HandleType* pTmuHandle)
|
|
{
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
if(pTmuHandle->eIntance >= TMU_INSTANCE_MAX)
|
|
{
|
|
TMU_ReportDevError(TMU_INIT_ID, TMU_E_PARAM_INSTANCE);
|
|
return 0U;
|
|
}
|
|
else
|
|
{
|
|
#endif
|
|
TMU_Type *const pTmu = s_apTmuBase[pTmuHandle->eIntance];
|
|
return TMU_HWA_GetSlopeFactor(pTmu);
|
|
#if TMU_DEV_ERROR_REPORT == STD_ON
|
|
}
|
|
#endif
|
|
}
|
|
#endif
|
|
#endif /* #if TMU_INSTANCE_COUNT > 0U */
|