/** * @file module_driver_sdadc.c * @author flagchip * @brief SDADC 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. * */ /* ******************************************************************************** * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- ------------ ---------- --------------- * 0.1.0 2024-07-25 Flagchip0084 N/A First version for FC7300 ******************************************************************************** */ #include "module_driver_sdadc.h" #if SDADC_INSTANCE_COUNT > 0U #include "module_driver_scg.h" #include "module_driver_pcc.h" #define SDADC_NISR_CH0_MASK 0x00010101u #define SDADC_ABNISR0_CH0_MASK 0x01010101u #define SDADC_ABNISR1_CH0_MASK 0x01010101u #define SDADC_EXTIS_CH0_MASK 0x01010101u #define LN2VALUE 0.69314718056f #define COMPUTATIONAL_ACCURACY_POS 1e-5f #define COMPUTATIONAL_ACCURACY_NEG -1e-5f static SDADC_Type *const s_apSdadcBase[SDADC_INSTANCE_COUNT] = SDADC_BASE_PTRS; void SDADC_ClearChannelIntFlags(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex); static float _pow2(float exponent) { float result = 1.0f; float term = 1.0f; float x = exponent * LN2VALUE; int n = 1; while (term > COMPUTATIONAL_ACCURACY_POS || term < COMPUTATIONAL_ACCURACY_NEG) { term *= x / (float)n; result += term; n++; } return result; } static float _Log2(float x) { int exponent = 0; while (x >= 2.0f) { x /= 2.0f; exponent++; } while (x < 1.0f) { x *= 2.0f; exponent--; } x /= 2.0f; exponent++; float ln_x = 0.0f; float term = x - 1.0f; int n = 1; while (term > COMPUTATIONAL_ACCURACY_POS || term < COMPUTATIONAL_ACCURACY_NEG) { ln_x += term / (float)n; term *= -(x - 1.0f); n++; } return (float)exponent + ln_x / LN2VALUE; } static uint32_t _ceilFloat(float xValue) { uint32_t u32Part = (uint32_t)xValue; uint32_t u32Ret; if (xValue > (float)u32Part) { u32Ret = (u32Part + 1U); } else { u32Ret = u32Part; } return u32Ret; } static uint32_t _cacuGainFactor(uint8_t u8Order, uint16_t u16Osr, uint32_t u32OptValue) { float fTemp; float fSum = 1.0F; uint32_t u32Ret; if (u16Osr > 0 && (u16Osr & (u16Osr - 1)) == 0) { u32Ret = u32OptValue; } else { fTemp = u8Order * _Log2((float)u16Osr); fSum = _pow2((float)_ceilFloat(fTemp) - fTemp); u32Ret = (uint32)(fSum * (float)u32OptValue); } return u32Ret; } static uint32_t SDADC_CacuMFShift(const SDADC_ChannelInitType *const pInitCfg) { SDADC_FilterChainCfgType *const pFCInitCfg = pInitCfg->pFilterChainCfg; uint32_t u32Temp; uint32_t u32Mfshift; if ((pFCInitCfg->u16MainOSR & (pFCInitCfg->u16MainOSR - 1)) == 0) { uint16_t u16Temp = pFCInitCfg->u16MainOSR; uint32_t u32Pow = 0; while ((u16Temp >> 1U) != 0) { u16Temp >>= 1U; u32Pow++; } u32Temp = pFCInitCfg->eMainOrder * u32Pow + 1U - (uint32_t)(pInitCfg->eResultFmt); } else { float fTemp; fTemp = _Log2((float)pFCInitCfg->u16MainOSR); u32Temp = _ceilFloat(pFCInitCfg->eMainOrder * fTemp) + 1 - (uint32_t)(pInitCfg->eResultFmt); } if (u32Temp < SDADC_MFSHIFT_DATALENGTH) { u32Mfshift = SDADC_MFSHIFT_LEFT | (SDADC_MFSHIFT_DATALENGTH - u32Temp); } else { u32Mfshift = SDADC_MFSHIFT_RIGHT | (u32Temp - SDADC_MFSHIFT_DATALENGTH); } return u32Mfshift; } static void SDADC_ModulatorInit(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, const SDADC_ModulatorCfgType *const pInitCfg, SDADC_MASELType eMasel) { uint32_t u32TempValue; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u32TempValue = SDADC_CMACSR_MASEL(eMasel) | SDADC_CMACSR_MACLKSEL(pInitCfg->eMaClkSrc) | SDADC_CMACSR_RSTSEL(pInitCfg->u8ResetCycle) | SDADC_CMACSR_DITHER_EN(pInitCfg->eDitherEnable) | SDADC_CMACSR_INCFGPV11(pInitCfg->ePosV11) | SDADC_CMACSR_GAINSEL(pInitCfg->eGain) | SDADC_CMACSR_CMENP(pInitCfg->u8PosInputCommonVolModeMask) | SDADC_CMACSR_CMENM(pInitCfg->u8NegInputCommonVolModeMask) | SDADC_CMACSR_INCFGP(pInitCfg->ePosInputSrc) | SDADC_CMACSR_INCFGM(pInitCfg->eNegInputSrc) | SDADC_CMACSR_INSEL(pInitCfg->eInputSel) | SDADC_CMACSR_INMOD(pInitCfg->eInputSelMode); pSdadc->CMACSR[u8ChannelIndex] = u32TempValue; } static void SDADC_FilterChainInit(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, const SDADC_FilterChainCfgType *const pInitCfg) { uint32_t u32TempValue; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u32TempValue = SDADC_CRTCSR_DLY_TRG(pInitCfg->tRectCfg.u8SignDelayTsignPosEdge) | SDADC_CRTCSR_CTRGSIGN_OEN(pInitCfg->tRectCfg.eChannelTrgSignOutEnable) | SDADC_CRTCSR_SSCH(pInitCfg->tRectCfg.eSignSignalChSel) | SDADC_CRTCSR_SSRC(pInitCfg->tRectCfg.eSignSignalSrcSel); pSdadc->CRTCSR[u8ChannelIndex] = u32TempValue; u32TempValue = SDADC_CSDR_DLY_NEG(pInitCfg->tRectCfg.u8SignNegDelay) | SDADC_CSDR_DLY_POS(pInitCfg->tRectCfg.u8SignPosDelay); pSdadc->CSDR[u8ChannelIndex] = u32TempValue; u32TempValue = SDADC_CICFR_NVALINT(pInitCfg->tIntgraterCfg.u8IntgratorCnt - 1) | SDADC_CICFR_NVALDIS(pInitCfg->tIntgraterCfg.u8IntgratorDiscardCnt) | SDADC_CICFR_SYNC_TRGEN(pInitCfg->tIntgraterCfg.eSyncSrc) | SDADC_CICFR_SYNC_TRGSEL(pInitCfg->tIntgraterCfg.u8SyncTrgSel) | SDADC_CICFR_NVALREP(pInitCfg->tIntgraterCfg.u8IntgratorRepeatCnt - 1) | SDADC_CICFR_ITRSEL(pInitCfg->tIntgraterCfg.eTrgType) | SDADC_CICFR_HTRPOL(pInitCfg->tIntgraterCfg.eHWTrgPolarity) | SDADC_CICFR_FCRC(pInitCfg->tIntgraterCfg.u8RestartFilterOnStart) | SDADC_CICFR_EXTSTP(pInitCfg->tIntgraterCfg.eStopControl) | SDADC_CICFR_IOGT(pInitCfg->tIntgraterCfg.eGateControl) | SDADC_CICFR_ISVAL(pInitCfg->tIntgraterCfg.u8IntgratShiftValue); pSdadc->CICFR[u8ChannelIndex] = u32TempValue; u32TempValue = SDADC_CDR_AFCM(pInitCfg->eAuxFilterMode) | SDADC_CDR_MFCM(pInitCfg->eMainFilterMode) | SDADC_CDR_AFORD(pInitCfg->eAuxOrder) | SDADC_CDR_MFORD(pInitCfg->eMainOrder) | SDADC_CDR_AFOSR(pInitCfg->u16AuxOSR - 1) | SDADC_CDR_MFOSR(pInitCfg->u16MainOSR - 1); SDADC_HWA_SetCDRn(pSdadc, u8ChannelIndex, u32TempValue); u32TempValue = SDADC_CCR_INTG_EN(pInitCfg->u8IntgraterEnable) | SDADC_CCR_RECT_EN(pInitCfg->u8RectEnable) | SDADC_CCR_AF_EN(pInitCfg->eAuxFilterMode) | SDADC_CCR_MF_EN(pInitCfg->u8MainFilterEnable) | SDADC_CCR_DBG_SEL(pInitCfg->u32DebugSel); u32TempValue = (SDADC_HWA_GetCCRn(pSdadc, u8ChannelIndex) & ~(SDADC_CCR_INTG_EN_MASK | SDADC_CCR_RECT_EN_MASK | SDADC_CCR_AF_EN_MASK | SDADC_CCR_MF_EN_MASK | SDADC_CCR_DBG_SEL_MASK)) | u32TempValue; SDADC_HWA_SetCCRn(pSdadc, u8ChannelIndex, u32TempValue); if (pInitCfg->eGainCompMode == SDADC_GAIN_CMP_BYPASS) { pSdadc->CGNR[u8ChannelIndex] = 0; SDADC_HWA_SetBIAS(pSdadc, u8ChannelIndex, 0); } else if (pInitCfg->eGainCompMode == SDADC_GAIN_CMP_INTERNAL_GAIN1) { pSdadc->CGNR[u8ChannelIndex] = _cacuGainFactor(pInitCfg->eMainOrder, pInitCfg->u16MainOSR, SDADC_HWA_GetGainOPT0(pSdadc, u8ChannelIndex)); SDADC_HWA_SetBIAS(pSdadc, u8ChannelIndex, (SDADC_HWA_GetOffsetOPT0(pSdadc, u8ChannelIndex) << 8U)); } else if (pInitCfg->eGainCompMode == SDADC_GAIN_CMP_INTERNAL_GAIN2) { pSdadc->CGNR[u8ChannelIndex] = _cacuGainFactor(pInitCfg->eMainOrder, pInitCfg->u16MainOSR, SDADC_HWA_GetGainOPT1(pSdadc, u8ChannelIndex)); SDADC_HWA_SetBIAS(pSdadc, u8ChannelIndex, (SDADC_HWA_GetOffsetOPT1(pSdadc, u8ChannelIndex) << 8U)); } else { pSdadc->CGNR[u8ChannelIndex] = pInitCfg->u32GainFactor & SDADC_CGNR_GAIN_FAC_MASK; SDADC_HWA_SetBIAS(pSdadc, u8ChannelIndex, (uint32_t)((pInitCfg->s32Offset) >> 8U)); } } static void SDADC_BiasInit(SDADC_HandleType *pSdadcHandle, const SDADC_InitType *const pInitCfg) { SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_ChannelInitType *pChannelCfg = NULL; uint8_t u8HrefValue = 0; for (uint8_t i = 0; i < SDADC_CHANNEL_CNT; i++) { if ((pInitCfg->pChannelCfg)[i] != NULL) { pChannelCfg = (pInitCfg->pChannelCfg)[i]; u8HrefValue |= (uint8_t)(1U << (i)); SDADC_HWA_SetCMENP(pSdadc, i, pChannelCfg->u8BiasPositiveInputMask); SDADC_HWA_SetCMENM(pSdadc, i, pChannelCfg->u8BiasNegativeInputMask); } } if (u8HrefValue) { uint32_t u32BSTCValue; SDADC_HWA_SetHFVREF_EN(pSdadc, u8HrefValue); SDADC_HWA_SetVCM_BEN(pSdadc, 1U); u32BSTCValue = pInitCfg->u32FunctionClk / (1U << (uint8_t)(pInitCfg->ePrescale)) / pInitCfg->u8CLKDiv / 2U; u32BSTCValue /= 500000U; u32BSTCValue += 1U; /*BSTC need 2us stable time(div_clk1)*/ SDADC_HWA_SetBSTC(pSdadc, u32BSTCValue); SDADC_HWA_SetBIAS_EN(pSdadc, 1U); } } static void SDADC_DetectInit(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, SDADC_DetectCfgType *const pInitCfg) { SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; uint32_t u32TempValue; u32TempValue = SDADC_CCR_LMT_SEL(pInitCfg->eLmtCheckSrc) | SDADC_CCR_ZCD_SEL(pInitCfg->eZCDCheckSrc) | SDADC_CCR_LMT_EN(pInitCfg->u8LmtCheckEnable) | SDADC_CCR_ZCD_EN(pInitCfg->u8ZCDCheckEnable) | SDADC_CCR_CAD_EN(pInitCfg->u8ClkAbsenceCheckEnable) | SDADC_CCR_SCD_EN(pInitCfg->u8ShortCircutCheckEnable); u32TempValue = (SDADC_HWA_GetCCRn(pSdadc, u8ChannelIndex) & ~(SDADC_CCR_LMT_SEL_MASK | SDADC_CCR_ZCD_SEL_MASK | SDADC_CCR_LMT_EN_MASK | SDADC_CCR_ZCD_EN_MASK | SDADC_CCR_CAD_EN_MASK | SDADC_CCR_SCD_EN_MASK)) | u32TempValue; SDADC_HWA_SetCCRn(pSdadc, u8ChannelIndex, u32TempValue); u32TempValue = SDADC_CPR_HLMT_BKEN(pInitCfg->u8HighLimitReachBreakEnable) | SDADC_CPR_WLMT_BKEN(pInitCfg->u8WindowLimitReachBreakEnable) | SDADC_CPR_LLMT_BKEN(pInitCfg->u8LowLimitReachBreakEnable) | SDADC_CPR_SCD_BKEN(pInitCfg->u8ShortCircuitDetectBreakEnable) | SDADC_CPR_CAD_BKEN(pInitCfg->u8ClockAbsenceDetectBreakEnable) | SDADC_CPR_LMTF_PROTEN(pInitCfg->u8LMTFlagProtectionEnable) | SDADC_CPR_LMTR_PROTEN(pInitCfg->u8LMTResultProtectionEnable) | SDADC_CPR_HYSTR_PROTEN(pInitCfg->u8LMTHysteresisProtectionEnable) | SDADC_CPR_SCD_PROTEN(pInitCfg->u8SCDFlagProtectionEnable) | SDADC_CPR_CAD_PROTEN(pInitCfg->u8CADFlagProtectionEnable) | SDADC_CPR_LMTAVT(pInitCfg->eLMTAvtType) | SDADC_CPR_CADLMT(pInitCfg->u8ClkAbsenceCnt) | SDADC_CPR_LMTOPT(pInitCfg->eLMTOptType) | SDADC_CPR_SCDOPT(pInitCfg->eSCDOptType) | SDADC_CPR_SCDCM(pInitCfg->eSCDCmtType) | SDADC_CPR_SCDLMT(pInitCfg->u8SCDLmtCnt); SDADC_HWA_SetCPRn(pSdadc, u8ChannelIndex, u32TempValue); SDADC_HWA_SetCLLMTn(pSdadc, u8ChannelIndex, (pInitCfg->u32LowLmt) << SDADC_CLLMT_LOLMT_SHIFT); SDADC_HWA_SetCHLMTn(pSdadc, u8ChannelIndex, (pInitCfg->u32HighLmt) << SDADC_CHLMT_HILMT_SHIFT); } static void SDADC_ChannelInit(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, const SDADC_ChannelInitType *const pChannelCfg) { uint32_t u32TempValue; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u32TempValue = SDADC_CCR_DMA_EN(pChannelCfg->u8DMAEnable) | SDADC_CCR_FIFO_EN(pChannelCfg->u8FIFOEnable); u32TempValue = (SDADC_HWA_GetCCRn(pSdadc, u8ChannelIndex) & ~(SDADC_CCR_DMA_EN_MASK | SDADC_CCR_FIFO_EN_MASK)) | u32TempValue; SDADC_HWA_SetCCRn(pSdadc, u8ChannelIndex, u32TempValue); u32TempValue = SDADC_CFR_SYNC_TRGEN(pChannelCfg->eSyncSrc) | SDADC_CFR_TRGLVL(pChannelCfg->eTrgLevel) | SDADC_CFR_SYNC_TRGSEL(pChannelCfg->u8SyncTrgSel) | SDADC_CFR_TRGSEL(pChannelCfg->eTrgType) | SDADC_CFR_CLKSEL(pChannelCfg->eRcvClkSel) | SDADC_CFR_FWMK(pChannelCfg->u8FIFOWaterMark) | SDADC_CFR_RDFMT(pChannelCfg->eResultFmt) | SDADC_CFR_MFSHIFT(SDADC_CacuMFShift(pChannelCfg)); if (pChannelCfg->eResultFmt == SDADC_RDFMT_LEFT_JUSTIFIED_SIGNED) { u32TempValue |= SDADC_CFR_CUTOFF(pChannelCfg->u8HPFCutOff); } else { u32TempValue |= SDADC_CFR_CUTOFF(0); } if (pChannelCfg->u8InternalModulator == SDADC_MASEL_INTERNAL) { u32TempValue |= SDADC_CFR_CLKEDG(SDADC_CLKEDG_POSEDGE); } else { u32TempValue |= SDADC_CFR_IBFMT(pChannelCfg->eInputBitFormat) | SDADC_CFR_CLKEDG(pChannelCfg->eSyncSrc); } SDADC_HWA_SetCFRn(pSdadc, u8ChannelIndex, u32TempValue); u32TempValue = SDADC_CTSCNT_SYNC_TRGEN(pChannelCfg->eTsSyncSrc) | SDADC_CTSCNT_SYNC_TRGSEL(pChannelCfg->u8TsSyncTrgSel) | SDADC_CTSCNT_TSRDM(pChannelCfg->eTsReadMode) | SDADC_CTSCNT_TSTRGM(pChannelCfg->eTsCounterTriggerMode) | SDADC_CTSCNT_INMXCP(pChannelCfg->eTsInputMuxCopy) | SDADC_CTSCNT_TS_EN(pChannelCfg->eTsCounterEnable) | SDADC_CTSCNT_TSCLKSEL(pChannelCfg->eTsCounterClkDiv); pSdadc->CTSCNT[u8ChannelIndex] = u32TempValue; } static void SDADC_InterruptInit(SDADC_HandleType *pSdadcHandle, const SDADC_InitType *const pInitCfg) { SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_ChannelInitType *pChannelCfg = NULL; uint32_t NormalIntCfg = 0x0U; uint32_t AbnormalIntCfg0 = 0x0U; uint32_t AbnormalIntCfg1 = 0x0U; uint32_t ExtIntCfg = 0x0U; for (uint8_t i = 0; i < SDADC_CHANNEL_CNT; i++) { if ((pInitCfg->pChannelCfg)[i] != NULL) { pChannelCfg = (pInitCfg->pChannelCfg)[i]; if (pChannelCfg->tIntCfg.u8COCIrqEnable) { NormalIntCfg |= SDADC_NIER_COCIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8FIFOReadyIrqEnable) { NormalIntCfg |= SDADC_NIER_FRDYIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8ZeroCrossDetectIrqEnable) { NormalIntCfg |= SDADC_NIER_ZCDIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8HighLimitReachIrqEnable) { AbnormalIntCfg0 |= SDADC_ABNIER0_HLMTIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8LowLimitReachIrqEnable) { AbnormalIntCfg0 |= SDADC_ABNIER0_LLMTIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8WindowLimitReachIrqEnable) { AbnormalIntCfg0 |= SDADC_ABNIER0_WLMTIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8ShortCircuitDetectIrqEnable) { AbnormalIntCfg0 |= SDADC_ABNIER0_SCDIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8DataSaturationDetectIrqEnable) { AbnormalIntCfg1 |= SDADC_ABNIER1_SATIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8ClockAbsenceDetectIrqEnable) { AbnormalIntCfg1 |= SDADC_ABNIER1_CADIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8FIFOOverFlowIrqEnable) { AbnormalIntCfg1 |= SDADC_ABNIER1_FOVFIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8FIFOUnderFlowIrqEnable) { AbnormalIntCfg1 |= SDADC_ABNIER1_FUNFIE0_MASK << (i); } if (pChannelCfg->tIntCfg.u8SignDelayCaptureIrqEnable) { ExtIntCfg |= SDADC_EXTIS_SD_CAPVLD0_MASK << (i); } if (pChannelCfg->tIntCfg.u8TSignChangedIrqEnable) { ExtIntCfg |= SDADC_EXTIS_TSIGN_P2N0_MASK << (i); } if (pChannelCfg->tIntCfg.u8TSValidIrqEnable) { ExtIntCfg |= SDADC_EXTIS_TSVLD0_MASK << (i); } } } pSdadc->NISR = 0xFFFFFFFFU; pSdadc->NIER = NormalIntCfg; pSdadc->ABNISR0 = 0xFFFFFFFFU; pSdadc->ABNIER0 = AbnormalIntCfg0; pSdadc->ABNISR1 = 0xFFFFFFFFU; pSdadc->ABNIER1 = AbnormalIntCfg1; pSdadc->EXTIS = 0xFFFFFFFFU; pSdadc->EXTIE = ExtIntCfg; } #if SDADC_DEV_ERROR_REPORT == STD_ON static uint8_t SDADC_InitParamCheck(const SDADC_InitType *const pInitCfg, uint8_t u8FunctionID) { SDADC_ChannelInitType *pChannelCfg; uint8_t u8CheckFailed = 0; if (pInitCfg == NULL) { u8CheckFailed = 1; return u8CheckFailed; } for (uint8_t i = 0; i < SDADC_CHANNEL_CNT; i++) { if ((pInitCfg->pChannelCfg)[i] != NULL) { pChannelCfg = (pInitCfg->pChannelCfg)[i]; if (pChannelCfg->eResultFmt != SDADC_RDFMT_LEFT_JUSTIFIED_SIGNED && pChannelCfg->u8HPFCutOff == 0) { u8CheckFailed = 1; break; } if (pChannelCfg->eTsReadMode == SDADC_TSRDM_DIRECT_MODE && pChannelCfg->u8FIFOEnable != 0) { u8CheckFailed = 1; break; } if (pChannelCfg->pFilterChainCfg) { if (pChannelCfg->pFilterChainCfg->tIntgraterCfg.eTrgType == SDADC_TRGSEL_HARDWARE && pChannelCfg->eTrgType == SDADC_TRGSEL_HARDWARE) { u8CheckFailed = 1; break; } } if (pChannelCfg->pModulatorCfg && pChannelCfg->pFilterChainCfg) { if (((pChannelCfg->pModulatorCfg)->eInputSelMode != SDADC_INMOD_SOFTWARE_CONTROL) && ((pChannelCfg->pFilterChainCfg)->eAuxFilterMode == SDADC_AFCM_ALWAYS_ON)) { u8CheckFailed = 1; break; } } } } if (u8CheckFailed) { SDADC_ReportDevError(u8FunctionID, SDADC_E_PARAM_INSTANCE); } return u8CheckFailed; } static uint8_t SDADC_HandleChannelCheck(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, uint8_t u8FunctionID) { uint8_t u8CheckFailed = 0; if (pSdadcHandle == NULL) { u8CheckFailed = 1; SDADC_ReportDevError(u8FunctionID, SDADC_E_PARAM_POINTER); } else if (pSdadcHandle->eInstance >= SDADC_INSTANCE_COUNT) { u8CheckFailed = 1; SDADC_ReportDevError(u8FunctionID, SDADC_E_PARAM_INSTANCE); } else if (u8ChannelIndex >= SDADC_CHANNEL_CNT) { u8CheckFailed = 1; SDADC_ReportDevError(u8FunctionID, SDADC_E_PARAM_CHANNEL); } return u8CheckFailed; } static uint8_t SDADC_HandleCheck(SDADC_HandleType *pSdadcHandle, uint8_t u8FunctionID) { uint8_t u8CheckFailed = 0; if (pSdadcHandle == NULL) { u8CheckFailed = 1; SDADC_ReportDevError(u8FunctionID, SDADC_E_PARAM_POINTER); } else if (pSdadcHandle->eInstance >= SDADC_INSTANCE_COUNT) { u8CheckFailed = 1; SDADC_ReportDevError(u8FunctionID, SDADC_E_PARAM_INSTANCE); } return u8CheckFailed; } #endif void SDADC_ClearChannelIntFlags(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_HWA_SetNISR(pSdadc, SDADC_NISR_CH0_MASK << u8ChannelIndex); SDADC_HWA_SetABNISR0(pSdadc, SDADC_ABNISR0_CH0_MASK << u8ChannelIndex); SDADC_HWA_SetABNISR1(pSdadc, SDADC_ABNISR1_CH0_MASK << u8ChannelIndex); SDADC_HWA_SetEXTIS(pSdadc, SDADC_EXTIS_CH0_MASK << u8ChannelIndex); } void SDADCn_IRQHandler(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; uint32_t u32NIInt; uint32_t u32ABInt0; uint32_t u32ABInt1; uint32_t u32EXInt; u32NIInt = (pSdadc->NISR); u32NIInt &= pSdadc->NIER; u32NIInt &= (SDADC_NISR_CH0_MASK << u8ChannelIndex); u32ABInt0 = (pSdadc->ABNISR0); u32ABInt0 &= pSdadc->ABNIER0; u32ABInt0 &= (SDADC_ABNISR0_CH0_MASK << u8ChannelIndex); u32ABInt1 = (pSdadc->ABNISR1); u32ABInt1 &= pSdadc->ABNIER1; u32ABInt1 &= (SDADC_ABNISR1_CH0_MASK << u8ChannelIndex); u32EXInt = (pSdadc->EXTIS); u32EXInt &= pSdadc->EXTIE; u32EXInt &= (SDADC_EXTIS_CH0_MASK << u8ChannelIndex); SDADC_ClearChannelIntFlags(pSdadcHandle, u8ChannelIndex); if (u32NIInt) { if ((u32NIInt & (SDADC_NISR_COC0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pCOCISRCallback != NULL)) { pSdadcHandle->tSettings.pCOCISRCallback(pSdadcHandle, u8ChannelIndex); } if ((u32NIInt & (SDADC_NISR_FRDY0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pFIFOISRCallback != NULL)) { pSdadcHandle->tSettings.pFIFOISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_FIFO_READY); } if ((u32NIInt & (SDADC_NISR_ZCD0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_ZERO_CROSS); } } if (u32ABInt0) { if ((u32ABInt0 & (SDADC_ABNISR0_SCD0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_SHORT_CIRCUIT); } if ((u32ABInt0 & (SDADC_ABNISR0_WLMT0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_WIN_LMT_REACH); } if ((u32ABInt0 & (SDADC_ABNISR0_HLMT0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_HIGH_LMT_REACH); } if ((u32ABInt0 & (SDADC_ABNISR0_LLMT0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_LOW_LMT_REACH); } } if (u32ABInt1) { if ((u32ABInt1 & (SDADC_ABNISR1_CAD0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_CLK_ABSENCE); } if ((u32ABInt1 & (SDADC_ABNISR1_SAT0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pDetectISRCallback != NULL)) { pSdadcHandle->tSettings.pDetectISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_DET_DATA_SATURATION); } if ((u32ABInt1 & (SDADC_ABNISR1_FOVF0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pFIFOISRCallback != NULL)) { pSdadcHandle->tSettings.pFIFOISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_FIFO_OVERFLOW); } if ((u32ABInt1 & (SDADC_ABNISR1_FUNF0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pFIFOISRCallback != NULL)) { pSdadcHandle->tSettings.pFIFOISRCallback(pSdadcHandle, u8ChannelIndex, SDADC_FIFO_UNDERFLOW); } } if (u32EXInt) { if ((u32EXInt & (SDADC_EXTIS_SD_CAPVLD0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pSignDelayISRCallback != NULL)) { pSdadcHandle->tSettings.pSignDelayISRCallback(pSdadcHandle, u8ChannelIndex); } if ((u32EXInt & (SDADC_EXTIS_TSIGN_P2N0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pTSignChangeISRCallback != NULL)) { pSdadcHandle->tSettings.pTSignChangeISRCallback(pSdadcHandle, u8ChannelIndex); } if ((u32EXInt & (SDADC_EXTIS_TSVLD0_MASK << u8ChannelIndex)) && (pSdadcHandle->tSettings.pTSValidISRCallback != NULL)) { pSdadcHandle->tSettings.pTSValidISRCallback(pSdadcHandle, u8ChannelIndex); } } } void SDADC_InitCfg(SDADC_InitType *pInitCfg) { if (pInitCfg == NULL) { return; } pInitCfg->u8BiasEnable = 1; pInitCfg->ePrescale = SDADC_PRESCALE_NO_PRESCALE; pInitCfg->eMenSel = SDADC_MENSEL_INTERNAL; pInitCfg->u8CLKDiv = 2; pInitCfg->u8Clk0Disable = 0; pInitCfg->u8Clk1Disable = 0; pInitCfg->u8Clk2Disable = 0; for (uint8_t i = 0; i < SDADC_CHANNEL_CNT; i++) { (pInitCfg->pChannelCfg)[i] = NULL; } pInitCfg->pPWMCfg = NULL; pInitCfg->pCOCISRCallback = NULL; pInitCfg->pFIFOISRCallback = NULL; pInitCfg->pDetectISRCallback = NULL; pInitCfg->pSignDelayISRCallback = NULL; pInitCfg->pTSignChangeISRCallback = NULL; pInitCfg->pTSValidISRCallback = NULL; } void SDADC_InitChannelCfg(SDADC_ChannelInitType *pInitCfg) { if (pInitCfg == NULL) { return; } pInitCfg->u8SyncTrgSel = 0; pInitCfg->eSyncSrc = SDADC_SYNC_TRGEN_SELF; pInitCfg->eTrgLevel = SDADC_TRGLVL_EDGE; pInitCfg->eTrgType = SDADC_TRGSEL_SOFTWARE; pInitCfg->eRcvClkSel = SDADC_CLKSEL_DIV_CLK1; pInitCfg->u8HPFCutOff = 0; pInitCfg->u8InternalModulator = SDADC_MASEL_INTERNAL; pInitCfg->eClkEdg = SDADC_CLKEDG_POSEDGE; pInitCfg->eInputBitFormat = SDADC_IBFMT_ONE_BIT_STREAM; pInitCfg->eResultFmt = SDADC_RDFMT_LEFT_JUSTIFIED_SIGNED; pInitCfg->u8TsSyncTrgSel = 0; pInitCfg->eTsSyncSrc = SDADC_SYNC_TRGEN_SELF; pInitCfg->eTsReadMode = SDADC_TSRDM_DEFAULT_MODE; pInitCfg->eTsCounterTriggerMode = SDADC_TSTRGM_RISING_EDGE; pInitCfg->eTsInputMuxCopy = SDADC_INMXCP_DISABLED; pInitCfg->eTsCounterEnable = SDADC_TS_EN_ENABLED; pInitCfg->eTsCounterClkDiv = SDADC_TSCLKSEL_MODULATOR_CLOCK; pInitCfg->u8FIFOEnable = 0; pInitCfg->u8FIFOWaterMark = 0; pInitCfg->u8DMAEnable = 0; pInitCfg->u8BiasPositiveInputMask = 0; pInitCfg->u8BiasNegativeInputMask = 0; pInitCfg->tIntCfg = (SDADC_IntInitType){0}; pInitCfg->pModulatorCfg = NULL; pInitCfg->pFilterChainCfg = NULL; pInitCfg->pDectectCfg = NULL; } void SDADC_InitModulatorCfg(SDADC_ModulatorCfgType *pInitCfg) { if (pInitCfg == NULL) { return; } pInitCfg->eMaClkSrc = SDADC_MACLKSEL_DIV_CLK1; pInitCfg->eDitherEnable = SDADC_DITHER_EN_DISABLED; pInitCfg->u8ResetCycle = 8; pInitCfg->ePosV11 = SDADC_INCFGPV11_DISABLED; pInitCfg->eGain = SDADC_GAINSEL_1; pInitCfg->u8PosInputCommonVolModeMask = 0; pInitCfg->u8NegInputCommonVolModeMask = 0; pInitCfg->ePosInputSrc = SDADC_INCFGP_FROM_PIN; pInitCfg->eNegInputSrc = SDADC_INCFGM_FROM_PIN; pInitCfg->eInputSel = SDADC_INSEL_PIN_0; pInitCfg->eInputSelMode = SDADC_INMOD_SOFTWARE_CONTROL; } void SDADC_InitPwmCfg(SDADC_PWMInitType *pInitCfg) { if (pInitCfg == NULL) { return; } pInitCfg->eTrgSignOEN = SDADC_TRGSIGN_OEN_DISABLED; pInitCfg->eClkSel = SDADC_PWM_CLKSEL_DIV_CLK0; pInitCfg->eBitRev = SDADC_BIT_REV_NORMAL; pInitCfg->ePwmPolarity = SDADC_PWM_POLARITY_POSITIVE; pInitCfg->ePwmPattern = SDADC_PWM_PATTERN_STOPPED; } void SDADC_InitFilterChainCfg(SDADC_FilterChainCfgType *pInitCfg) { if (pInitCfg == NULL) { return; } pInitCfg->u8IntgraterEnable = 0; pInitCfg->tIntgraterCfg.eSyncSrc = SDADC_SYNC_TRGEN_SELF; pInitCfg->tIntgraterCfg.u8SyncTrgSel = 0; pInitCfg->tIntgraterCfg.eHWTrgPolarity = SDADC_HTRPOL_HIGH_RISING; pInitCfg->tIntgraterCfg.eTrgType = SDADC_TRGSEL_HARDWARE; pInitCfg->tIntgraterCfg.u8RestartFilterOnStart = 0; pInitCfg->tIntgraterCfg.u8IntgratorCnt = 1; pInitCfg->tIntgraterCfg.u8IntgratorDiscardCnt = 0; pInitCfg->tIntgraterCfg.u8IntgratorRepeatCnt = 1; pInitCfg->tIntgraterCfg.u8IntgratShiftValue = 0; pInitCfg->tIntgraterCfg.eStopControl = SDADC_EXTSTP_INTERNAL; pInitCfg->tIntgraterCfg.eGateControl = SDADC_IOGT_ALWAYS_WORK; pInitCfg->u8RectEnable = 0; pInitCfg->tRectCfg.u8SignDelayTsignPosEdge = 0; pInitCfg->tRectCfg.eChannelTrgSignOutEnable = SDADC_CTRGSIGN_OEN_DISABLED; pInitCfg->tRectCfg.eSignSignalChSel = SDADC_SSCH_CH0; pInitCfg->tRectCfg.eSignSignalSrcSel = SDADC_SSRC_INTERNAL_PWM; pInitCfg->tRectCfg.u8SignPosDelay = 0; pInitCfg->tRectCfg.u8SignNegDelay = 0; pInitCfg->u8MainFilterEnable = 0; pInitCfg->eMainFilterMode = SDADC_MFCM_SINGLE_MODE; pInitCfg->eMainOrder = SDADC_MFORD_THIRD_ORDER; pInitCfg->u16MainOSR = 128; pInitCfg->u8AuxFilterEnable = 0; pInitCfg->eAuxFilterMode = SDADC_AFCM_ALWAYS_ON; pInitCfg->eAuxOrder = SDADC_AFORD_SECOND_ORDER; pInitCfg->u16AuxOSR = 32; pInitCfg->eGainCompMode = SDADC_GAIN_CMP_BYPASS; pInitCfg->u32GainFactor = 0; pInitCfg->s32Offset = 0; } void SDADC_InitDectCfg(SDADC_DetectCfgType *pInitCfg) { if (pInitCfg == NULL) { return; } pInitCfg->u8LmtCheckEnable = 0; pInitCfg->eLmtCheckSrc = SDADC_SEL_AUXILIARY; pInitCfg->u8ZCDCheckEnable = 0; pInitCfg->eZCDCheckSrc = SDADC_SEL_AUXILIARY; pInitCfg->u8ClkAbsenceCheckEnable = 0; pInitCfg->u8ShortCircutCheckEnable = 0; pInitCfg->u8HighLimitReachBreakEnable = 0; pInitCfg->u8LowLimitReachBreakEnable = 0; pInitCfg->u8WindowLimitReachBreakEnable = 0; pInitCfg->u8ShortCircuitDetectBreakEnable = 0; pInitCfg->u8ClockAbsenceDetectBreakEnable = 0; pInitCfg->u8LMTFlagProtectionEnable = 0; pInitCfg->u8LMTResultProtectionEnable = 0; pInitCfg->u8LMTHysteresisProtectionEnable = 0; pInitCfg->u8SCDFlagProtectionEnable = 0; pInitCfg->u8CADFlagProtectionEnable = 0; pInitCfg->eLMTAvtType = SDADC_LMTAVT_SET_ON_LARGER_CLEAR_ON_SMALLER; pInitCfg->u8ClkAbsenceCnt = 0; pInitCfg->eLMTOptType = SDADC_LMTOPT_DETECT_BOTH_HIGH_AND_LOW; pInitCfg->eSCDOptType = SDADC_SCDOPT_COUNT_ON_BOTH_0_AND_1; pInitCfg->eSCDCmtType = SDADC_SCDCM_ALWAYS_ON; pInitCfg->u8SCDLmtCnt = 0; pInitCfg->u32HighLmt = 0x0; pInitCfg->u32LowLmt = 0x0; } SDADC_RetStatusType SDADC_Init(SDADC_HandleType *pSdadcHandle, const SDADC_InitType *const pInitCfg) { SDADC_RetStatusType eRet = SDADC_E_OK; #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_INIT_ID)) { return SDADC_E_NOT_OK; } if (SDADC_InitParamCheck(pInitCfg, SDADC_INIT_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_ChannelInitType *pChannelCfg; uint32_t u32TempValue; uint8_t i; SDADC_InterruptInit(pSdadcHandle, pInitCfg); u32TempValue = SDADC_CTRL_CLKO0_DIS(pInitCfg->u8Clk0Disable) | SDADC_CTRL_CLKO1_DIS(pInitCfg->u8Clk1Disable) | SDADC_CTRL_CLKO2_DIS(pInitCfg->u8Clk2Disable) | SDADC_CTRL_PRESCALE(pInitCfg->ePrescale) | SDADC_CTRL_MCLK_DIV(pInitCfg->u8CLKDiv - 1) | SDADC_CTRL_MENSEL(pInitCfg->eMenSel); pSdadc->CTRL = u32TempValue; if (pInitCfg->pPWMCfg) { SDADC_PWMInitType *pPWMCfg = pInitCfg->pPWMCfg; pSdadc->PWM_GEN = SDADC_PWM_GEN_TRGSIGN_OEN(pPWMCfg->eTrgSignOEN) | SDADC_PWM_GEN_POL(pPWMCfg->ePwmPolarity) | SDADC_PWM_GEN_BIT_REV(pPWMCfg->eBitRev) | SDADC_PWM_GEN_CLKSEL(pPWMCfg->eClkSel) | SDADC_PWM_GEN_PATTERN(pPWMCfg->ePwmPattern); } for (i = 0; i < SDADC_CHANNEL_CNT; i++) { if ((pInitCfg->pChannelCfg)[i] != NULL) { pChannelCfg = (pInitCfg->pChannelCfg)[i]; SDADC_ChannelInit(pSdadcHandle, i, pChannelCfg); if (pChannelCfg->pModulatorCfg) { SDADC_ModulatorInit(pSdadcHandle, i, pChannelCfg->pModulatorCfg, pChannelCfg->u8InternalModulator); } if (pChannelCfg->pFilterChainCfg) { SDADC_FilterChainInit(pSdadcHandle, i, pChannelCfg->pFilterChainCfg); } if (pChannelCfg->pDectectCfg) { SDADC_DetectInit(pSdadcHandle, i, pChannelCfg->pDectectCfg); } } } if (pInitCfg->u8BiasEnable) { SDADC_BiasInit(pSdadcHandle, pInitCfg); } pSdadcHandle->tSettings.pCOCISRCallback = pInitCfg->pCOCISRCallback; pSdadcHandle->tSettings.pFIFOISRCallback = pInitCfg->pFIFOISRCallback; pSdadcHandle->tSettings.pDetectISRCallback = pInitCfg->pDetectISRCallback; pSdadcHandle->tSettings.pTSValidISRCallback = pInitCfg->pTSValidISRCallback; pSdadcHandle->tSettings.pSignDelayISRCallback = pInitCfg->pSignDelayISRCallback; pSdadcHandle->tSettings.pTSignChangeISRCallback = pInitCfg->pTSignChangeISRCallback; return eRet; } void SDADC_Deinit(SDADC_HandleType *pSdadcHandle, uint32_t RstHoldCount) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_DEINIT_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; /* NOTE: Before asserting this bit, the interrupt(s) should be disabled by deasserting the corresponding NVIC Interrupt Set-Enable Register or deasserting the interrupt enable bit(s), and the DMA function should be disabled by deasserting the DMA enable bit or disabling the DMA channels via DMAMUX. */ pSdadc->NIER = 0; pSdadc->ABNIER0 = 0; pSdadc->ABNIER1 = 0; pSdadc->EXTIE = 0; SDADC_HWA_SetDMA_EN(pSdadc, 0, 0); SDADC_HWA_SetDMA_EN(pSdadc, 1, 0); SDADC_HWA_SetDMA_EN(pSdadc, 2, 0); SDADC_HWA_SetRESET(pSdadc, 1U); for (volatile uint32_t j = RstHoldCount; j > 0; j--) asm volatile("nop"); SDADC_HWA_SetRESET(pSdadc, 0U); pSdadcHandle->tSettings.pCOCISRCallback = NULL; pSdadcHandle->tSettings.pFIFOISRCallback = NULL; pSdadcHandle->tSettings.pDetectISRCallback = NULL; pSdadcHandle->tSettings.pSignDelayISRCallback = NULL; pSdadcHandle->tSettings.pTSignChangeISRCallback = NULL; pSdadcHandle->tSettings.pTSValidISRCallback = NULL; } void SDADC_ChannelEnable(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, uint8_t u8Enable) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_CHANNELENABLE_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_HWA_SetCH_EN(pSdadc, u8ChannelIndex, u8Enable); } SDADC_RetStatusType SDADC_MainEnable(SDADC_HandleType *pSdadcHandle, uint8_t u8Enable) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_MAIN_ENABLE_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_RetStatusType eRet = SDADC_E_OK; uint32_t u32Counter = 0xFFFFFFFFU; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_HWA_SetMEN(pSdadc, u8Enable); if (u8Enable) { if (SDADC_HWA_GetBIAS_EN(pSdadc)) { while (u32Counter--) { if (SDADC_HWA_GetBIAS_ON(pSdadc)) { break; } } } while (u32Counter--) { if (SDADC_HWA_GetCHRDY(pSdadc)) { break; } } } else { while (u32Counter--) { if (SDADC_HWA_GetCHON(pSdadc) == 0) { break; } } } if (u32Counter == 0U) { eRet = SDADC_E_NOT_OK; } return eRet; } void SDADC_ChannelSWTrigger(SDADC_HandleType *pSdadcHandle, SDADC_ChannelMaskType u8ChannelMask) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_CHANNELSWTRIGGER_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u8ChannelMask = u8ChannelMask & 0x7U; pSdadc->CTRL = (pSdadc->CTRL & ~0x7U) | u8ChannelMask; } void SDADC_ClearChannelSWTrigger(SDADC_HandleType *pSdadcHandle, SDADC_ChannelMaskType u8ChannelMask) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_CLEARCHANNELSWTRIGGER_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u8ChannelMask = u8ChannelMask & 0x7U; pSdadc->CTRL &= (uint32_t)(~u8ChannelMask); } void SDADC_IntegratorSWTrigger(SDADC_HandleType *pSdadcHandle, SDADC_ChannelMaskType u8ChannelMask) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_INTEGRATORSWTRIGGER_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u8ChannelMask = u8ChannelMask & 0x7U; pSdadc->EXTCTRL = (pSdadc->EXTCTRL & ~0x7U) | u8ChannelMask; } void SDADC_ClearIntegratorSWTrigger(SDADC_HandleType *pSdadcHandle, SDADC_ChannelMaskType u8ChannelMask) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_INTEGRATORSWTRIGGER_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; u8ChannelMask = u8ChannelMask & 0x7U; pSdadc->EXTCTRL &= (uint32_t)(~u8ChannelMask); } void SDADC_EnablePWMSignTriggerOut(SDADC_HandleType *pSdadcHandle, uint8_t u8Enable) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_ENABLEPWMSIGNTRIGGEROUT_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_HWA_SetTRGSIGN_OEN(pSdadc, u8Enable); } void SDADC_EnableTSignTriggerOut(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, uint8_t u8Enable) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_ENABLETSIGNTRIGGEROUT_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_HWA_SetCTRGSIGN_OEN(pSdadc, u8ChannelIndex, u8Enable); } SDADC_RetStatusType SDADC_GetConversionResult(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, uint32_t *pData) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCONVERSIONRESULT_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_RetStatusType eRet = SDADC_E_OK; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; *pData = SDADC_HWA_GetCRDATAn(pSdadc, u8ChannelIndex); return eRet; } SDADC_RetStatusType SDADC_GetCaptureTimeStamp(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, uint16_t *pTimestamp, uint16_t *pLastCov) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCAPTURETIMESTAMP_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_RetStatusType eRet = SDADC_E_OK; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; if (pTimestamp) { *pTimestamp = (uint16_t)SDADC_HWA_GetTSTAMP(pSdadc, u8ChannelIndex); } if (pLastCov) { *pLastCov = (uint16_t)SDADC_HWA_GetTSDATA(pSdadc, u8ChannelIndex); } return eRet; } SDADC_RetStatusType SDADC_GetSignDelayCapture(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, uint8_t *pCapture) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETSIGNDELAYCAPTURE_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_RetStatusType eRet = SDADC_E_OK; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; *pCapture = (uint8_t)SDADC_HWA_GetSD_CAP(pSdadc, u8ChannelIndex); return eRet; } uint8_t SDADC_GetChannelReady(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCHANNELREADY_ID)) { return SDADC_E_NOT_OK; } #endif uint8_t u8Ret = 0; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; if ((pSdadc->MSR & ((1U << u8ChannelIndex) << SDADC_MSR_CHRDY_SHIFT)) != 0U) { u8Ret = 1U; } else { u8Ret = 0U; } return u8Ret; } uint8_t SDADC_GetChannelConverting(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCHANNELCONVERTING_ID)) { return SDADC_E_NOT_OK; } #endif uint8_t u8Ret = 0; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; if ((pSdadc->NISR & (SDADC_MSR_CHON0_MASK << u8ChannelIndex)) != 0U) { u8Ret = 1U; } else { u8Ret = 0U; } return u8Ret; } uint8_t SDADC_GetChannelConversionComplete(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCHANNELCONVERSIONCOMPLETE_ID)) { return SDADC_E_NOT_OK; } #endif uint8_t u8Ret = 0; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; if ((pSdadc->NISR & (SDADC_NISR_COC0_MASK << u8ChannelIndex)) != 0U) { u8Ret = 1U; } else { u8Ret = 0U; } return u8Ret; } uint8_t SDADC_GetChannelFIFOEmpty(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCHANNELFIFOEMPTY_ID)) { return SDADC_E_NOT_OK; } #endif uint8_t u8Ret = 0; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; if ((pSdadc->MSR & ((1U << u8ChannelIndex) << SDADC_MSR_FIFO_EMPTY_SHIFT)) != 0U) { u8Ret = 1U; } else { u8Ret = 0U; } return u8Ret; } uint8_t SDADC_GetChannelFIFOReady(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_GETCHANNELFIFOREADY_ID)) { return SDADC_E_NOT_OK; } #endif uint8_t u8Ret = 0; SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; if ((pSdadc->NISR & (SDADC_NISR_FRDY0_MASK << u8ChannelIndex)) != 0U) { u8Ret = 1U; } else { u8Ret = 0U; } return u8Ret; } void SDADC_ClearChannelFIFOReady(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_CLEARCHANNELFIFOREADY_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; pSdadc->NISR = SDADC_NISR_FRDY0_MASK << u8ChannelIndex; } void SDADC_ClearChannelConversionComplete(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_CLEARCHANNELCONVERSIONCOMPLETE_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; pSdadc->NISR = SDADC_NISR_COC0_MASK << u8ChannelIndex; } SDADC_RetStatusType SDADC_StartPwmGeneration(SDADC_HandleType *pSdadcHandle, SDADC_PWMPatternType ePattern) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_STARTPWMGENERATION_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_RetStatusType u8Ret; if (SDADC_HWA_GetON(pSdadc)) { u8Ret = SDADC_E_NOT_OK; } else { SDADC_HWA_SetPATTERN(pSdadc, ePattern); u8Ret = SDADC_E_OK; } return u8Ret; } SDADC_RetStatusType SDADC_StopPwmGeneration(SDADC_HandleType *pSdadcHandle) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleCheck(pSdadcHandle, SDADC_STOPPWMGENERATION_ID)) { return SDADC_E_NOT_OK; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; SDADC_RetStatusType u8Ret; if (SDADC_HWA_GetON(pSdadc)) { SDADC_HWA_SetPATTERN(pSdadc, SDADC_PWM_PATTERN_STOPPED); u8Ret = SDADC_E_OK; } else { u8Ret = SDADC_E_NOT_OK; } return u8Ret; } void SDADC_SetInterrupptEnable(SDADC_HandleType *pSdadcHandle, uint8_t u8ChannelIndex, SDADC_InterruptType eIntType, uint8_t u8Enable) { #if SDADC_DEV_ERROR_REPORT == STD_ON if (SDADC_HandleChannelCheck(pSdadcHandle, u8ChannelIndex, SDADC_SETINTERRUPPTENABLE_ID)) { return; } #endif SDADC_Type *const pSdadc = s_apSdadcBase[pSdadcHandle->eInstance]; switch (eIntType) { case SDADC_COCI_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearCOC0(pSdadc); SDADC_HWA_SetCOCIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearCOC1(pSdadc); SDADC_HWA_SetCOCIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearCOC2(pSdadc); SDADC_HWA_SetCOCIE2(pSdadc, u8Enable); } } break; case SDADC_FIFO_READY_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearFRDY0(pSdadc); SDADC_HWA_SetFRDYIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearFRDY1(pSdadc); SDADC_HWA_SetFRDYIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearFRDY2(pSdadc); SDADC_HWA_SetFRDYIE2(pSdadc, u8Enable); } } break; case SDADC_FIFO_OVERFLOW_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearFOVF0(pSdadc); SDADC_HWA_SetFOVFIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearFOVF1(pSdadc); SDADC_HWA_SetFOVFIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearFOVF2(pSdadc); SDADC_HWA_SetFOVFIE2(pSdadc, u8Enable); } } break; case SDADC_FIFO_UNDERFLOW_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearFUNF0(pSdadc); SDADC_HWA_SetFUNFIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearFUNF1(pSdadc); SDADC_HWA_SetFUNFIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearFUNF2(pSdadc); SDADC_HWA_SetFUNFIE2(pSdadc, u8Enable); } } break; case SDADC_ZERO_CROSS_DETECT_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearZCD0(pSdadc); SDADC_HWA_SetZCDIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearZCD1(pSdadc); SDADC_HWA_SetZCDIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearZCD2(pSdadc); SDADC_HWA_SetZCDIE2(pSdadc, u8Enable); } } break; case SDADC_HIGH_LIMIT_REACH_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearHLMT0(pSdadc); SDADC_HWA_SetHLMTIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearHLMT1(pSdadc); SDADC_HWA_SetHLMTIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearHLMT2(pSdadc); SDADC_HWA_SetHLMTIE2(pSdadc, u8Enable); } } break; case SDADC_LOW_LIMIT_REACH_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearLLMT0(pSdadc); SDADC_HWA_SetLLMTIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearLLMT1(pSdadc); SDADC_HWA_SetLLMTIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearLLMT2(pSdadc); SDADC_HWA_SetLLMTIE2(pSdadc, u8Enable); } } break; case SDADC_WINDOW_LIMIT_REACH_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearWLMT0(pSdadc); SDADC_HWA_SetWLMTIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearWLMT1(pSdadc); SDADC_HWA_SetWLMTIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearWLMT2(pSdadc); SDADC_HWA_SetWLMTIE2(pSdadc, u8Enable); } } break; case SDADC_SHORT_CIRCUIT_DETECT_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearSCD0(pSdadc); SDADC_HWA_SetSCDIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearSCD1(pSdadc); SDADC_HWA_SetSCDIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearSCD2(pSdadc); SDADC_HWA_SetSCDIE2(pSdadc, u8Enable); } } break; case SDADC_DATA_SATURATION_DETECT_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearSAT0(pSdadc); SDADC_HWA_SetSATIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearSAT1(pSdadc); SDADC_HWA_SetSATIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearSAT2(pSdadc); SDADC_HWA_SetSATIE2(pSdadc, u8Enable); } } break; case SDADC_CLOCK_ABSENCE_DETECT_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearCAD0(pSdadc); SDADC_HWA_SetCADIE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearCAD1(pSdadc); SDADC_HWA_SetCADIE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearCAD2(pSdadc); SDADC_HWA_SetCADIE2(pSdadc, u8Enable); } } break; case SDADC_SIGN_DELAY_CAPTURE_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearSD_CAPVLD0(pSdadc); SDADC_HWA_SetSD_CAPVLD_IE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearSD_CAPVLD1(pSdadc); SDADC_HWA_SetSD_CAPVLD_IE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearSD_CAPVLD2(pSdadc); SDADC_HWA_SetSD_CAPVLD_IE2(pSdadc, u8Enable); } } break; case SDADC_TSIGN_CHANGED_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearTSIGN_P2N0(pSdadc); SDADC_HWA_SetTSIGN_P2N_IE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearTSIGN_P2N1(pSdadc); SDADC_HWA_SetTSIGN_P2N_IE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearTSIGN_P2N2(pSdadc); SDADC_HWA_SetTSIGN_P2N_IE2(pSdadc, u8Enable); } } break; case SDADC_TS_VALID_INTERRUPT: { if (u8ChannelIndex == 0) { SDADC_HWA_ClearTSVLD0(pSdadc); SDADC_HWA_SetTSVLD_IE0(pSdadc, u8Enable); } else if (u8ChannelIndex == 1) { SDADC_HWA_ClearTSVLD1(pSdadc); SDADC_HWA_SetTSVLD_IE1(pSdadc, u8Enable); } else { SDADC_HWA_ClearTSVLD2(pSdadc); SDADC_HWA_SetTSVLD_IE2(pSdadc, u8Enable); } } break; default: break; } } #endif /* #if SDADC_INSTANCE_COUNT > 0U */