35 #include <drivers/adc/adi_adc.h> 36 #include <adi_processor.h> 39 #include <drivers/pwr/adi_pwr.h> 40 #include <adi_adc_config.h> 41 #include <rtos_map/adi_rtos_map.h> 67 #pragma diag_suppress=Pm123,Pm073,Pm143,Pm050,Pm088,Pm140,Pm152 70 #include "adi_adc_def.h" 71 #include "adi_adc_data.c" 75 #define ADI_ADC_INVALID_HANDLE(h) (AdcDevInfo[0].hDevice != (h)) 79 #define ADI_MAX_ACQUISITION_TIME (((uint32_t)BITM_ADC_CNV_TIME_SAMPTIME << BITP_ADC_CNV_TIME_SAMPTIME) + 1u) 82 #define ADI_ADC_SAMPLE_MAX ((uint16_t)(4095u)) 90 #if defined(__ADUCM302x__) 91 extern void ADC_Int_Handler(
void);
93 extern void ADC0_Int_Handler(
void);
97 #if defined(__ADUCM302x__) 98 #define BITM_ADC_CFG_VREFVBAT (_ADI_MSK_3(0x00000008,0x00000008U, uint16_t )) 101 extern void DMA_ADC0_Int_Handler (
void);
107 static uint16_t ReadOutReg(uint32_t nChannelNum);
110 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 111 static ADI_ADC_RESULT DmaFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode);
113 static ADI_ADC_RESULT InterruptFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode);
117 static uint32_t GetNumChannels(uint32_t nChannels);
121 static void ManageFifoCompletion(ADI_ADC_DEVICE *pDevice);
122 static bool InitBufferProcessing(ADI_ADC_DEVICE *pDevice);
123 static void FlushFifo(ADI_ADC_DEVICE *pDevice, uint32_t nChannels);
126 static void EnableComparator(ADI_ADC_DEVICE *pDevice,
bool bEnable);
127 static void StaticConfiguration(ADI_ADC_DEVICE *pDevice);
151 uint32_t nMemorySize,
154 ADI_INT_STATUS_ALLOC();
155 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)pMemory;
158 if (nDeviceNum > (
sizeof (AdcDevInfo)/
sizeof(AdcDevInfo[0])))
168 if (AdcDevInfo[nDeviceNum].hDevice != NULL)
176 memset (pMemory, 0, nMemorySize);
178 ADI_ENTER_CRITICAL_REGION();
180 pDevice->pReg = AdcDevInfo[nDeviceNum].pReg;
181 ADI_EXIT_CRITICAL_REGION();
184 pDevice->pReg->CFG = BITM_ADC_CFG_RST;
187 NVIC_ClearPendingIRQ(ADC0_EVT_IRQn);
188 NVIC_EnableIRQ(ADC0_EVT_IRQn);
191 pDevice->pReg->IRQ_EN = BITM_ADC_IRQ_EN_RDY | BITM_ADC_IRQ_EN_ALERT | BITM_ADC_IRQ_EN_OVF | BITM_ADC_IRQ_EN_CALDONE | BITM_ADC_IRQ_EN_CNVDONE;
194 StaticConfiguration(pDevice);
200 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 201 pDevice->pfManageFifo = DmaFIFOManage;
205 pDevice->pfManageFifo = InterruptFIFOManage;
209 *phDevice = AdcDevInfo[nDeviceNum].hDevice;
226 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
242 pDevice->pReg->IRQ_EN = 0u;
245 pDevice->pReg->CNV_CFG = 0u;
247 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 249 NVIC_DisableIRQ(DMA0_CH24_DONE_IRQn);
253 NVIC_DisableIRQ(ADC0_EVT_IRQn);
259 AdcDevInfo[0].hDevice = (NULL);
280 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
281 uint32_t nClock = 0u;
282 uint16_t nCount = 0u;
292 if (bPowerUp ==
true)
294 if (IS_NOT_IN_ANY_STATE(ADC_STATUS_POWERED_UP))
301 nCount = (uint16_t)(nClock / 50000u);
304 pDevice->pReg->CFG |= BITM_ADC_CFG_PWRUP;
307 pDevice->pReg->PWRUP = (uint16_t)(((uint32_t)nCount << BITP_ADC_PWRUP_WAIT) & BITM_ADC_PWRUP_WAIT);
309 SET_STATE(ADC_STATUS_POWERED_UP);
319 if (IS_IN_STATE(ADC_STATUS_POWERED_UP))
322 if ( IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN) )
332 pDevice->pReg->CFG &= (uint16_t)(~(BITM_ADC_CFG_PWRUP));
333 CLR_STATE(ADC_STATUS_POWERED_UP);
360 ADI_CALLBACK pfCallback,
363 ADI_INT_STATUS_ALLOC();
365 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
373 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
380 ADI_ENTER_CRITICAL_REGION();
381 pDevice->pfCallback = pfCallback;
382 pDevice->pCBParam = pCBParam;
383 ADI_EXIT_CRITICAL_REGION();
411 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
419 if (IS_NOT_IN_STATE(ADC_STATUS_POWERED_UP))
424 if (bEnable ==
true) {
425 if (IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN)) {
429 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN)) {
437 pDevice->pReg->CFG |= BITM_ADC_CFG_EN;
438 SET_STATE(ADC_STATUS_SUB_SYSTEM_EN);
442 pDevice->pReg->CFG &= (uint16_t)(~BITM_ADC_CFG_EN);
443 CLR_STATE(ADC_STATUS_SUB_SYSTEM_EN | ADC_STATUS_SUB_SYSTEM_READY);
474 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
487 if (IS_NOT_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN))
493 if (IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_READY))
526 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
534 if (IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN))
540 pDevice->pReg->CFG &= (uint16_t)(~(BITM_ADC_CFG_REFBUFEN | BITM_ADC_CFG_VREFSEL | BITM_ADC_CFG_VREFVBAT));
545 pDevice->pReg->CFG |= BITM_ADC_CFG_REFBUFEN | BITM_ADC_CFG_VREFSEL;
549 pDevice->pReg->CFG |= BITM_ADC_CFG_REFBUFEN;
553 pDevice->pReg->CFG |= BITM_ADC_CFG_VREFVBAT;
587 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
598 pDevice->pReg->CFG |= BITM_ADC_CFG_SINKEN;
602 pDevice->pReg->CFG &= (uint16_t)~(BITM_ADC_CFG_SINKEN);
624 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
633 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN))
641 CLR_STATE(ADC_STATUS_CALIBRATION_DONE);
644 pDevice->pReg->STAT = BITM_ADC_STAT_CALDONE;
648 SET_STATE(ADC_STATUS_CALIBRATION_EN);
651 pDevice->pReg->CFG |= BITM_ADC_CFG_STARTCAL;
672 bool *pbCalibrationDone)
674 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
682 if (pbCalibrationDone == NULL)
691 if (IS_IN_STATE(ADC_STATUS_CALIBRATION_DONE))
693 *pbCalibrationDone =
true;
697 *pbCalibrationDone =
false;
724 uint32_t nAcqTimeInAClkCycles
727 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
736 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
742 if ((nAcqTimeInAClkCycles == 0u) || (nAcqTimeInAClkCycles > (ADI_MAX_ACQUISITION_TIME)))
750 nCnvTime = pDevice->pReg->CNV_TIME;
751 nCnvTime &= (uint16_t)(~BITM_ADC_CNV_TIME_SAMPTIME);
752 nCnvTime |= (uint16_t)((nAcqTimeInAClkCycles - ((uint32_t)1u)) << BITP_ADC_CNV_TIME_SAMPTIME);
753 pDevice->pReg->CNV_TIME = nCnvTime;
772 uint32_t nDelayInAClkCycles)
774 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
783 if (nDelayInAClkCycles > (BITM_ADC_CNV_TIME_DLY >> BITP_ADC_CNV_TIME_DLY))
789 nCnvTime = pDevice->pReg->CNV_TIME;
790 nCnvTime &= (uint16_t)(~BITM_ADC_CNV_TIME_DLY);
791 nCnvTime |= (uint16_t)(nDelayInAClkCycles << BITP_ADC_CNV_TIME_DLY);
792 pDevice->pReg->CNV_TIME = nCnvTime;
816 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
824 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
837 pDevice->pReg->AVG_CFG &= (uint16_t)(~BITM_ADC_AVG_CFG_OS);
838 if (IS_NOT_IN_STATE(ADC_STATUS_AVGERAGING_EN)) {
839 pDevice->pReg->AVG_CFG = 0u;
841 CLR_STATE(ADC_STATUS_OVERSAMPLING_EN);
852 nFactor = (uint16_t)1u << (((uint16_t)eResolution * 2u) - ((uint16_t)1u));
853 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN
854 | (uint16_t)(nFactor << BITP_ADC_AVG_CFG_FACTOR);
855 SET_STATE(ADC_STATUS_OVERSAMPLING_EN);
882 uint16_t nAveragingSamples
885 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
894 if ((nAveragingSamples == 0u) || (nAveragingSamples > 256u)
896 || ((nAveragingSamples & (nAveragingSamples - 1u)) != 0u))
900 if (IS_IN_STATE(ADC_STATUS_OVERSAMPLING_EN))
907 if (nAveragingSamples == 1u)
909 pDevice->pReg->AVG_CFG &= (uint16_t)(~BITM_ADC_AVG_CFG_EN);
910 CLR_STATE(ADC_STATUS_AVGERAGING_EN);
914 nFactor = nAveragingSamples >> 1;
915 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_EN | (uint16_t)(nFactor << BITP_ADC_AVG_CFG_FACTOR);
916 SET_STATE(ADC_STATUS_AVGERAGING_EN);
945 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
946 static volatile uint16_t* pRegister[4] = {
947 pREG_ADC0_LIM0_LO, pREG_ADC0_LIM1_LO, pREG_ADC0_LIM2_LO, pREG_ADC0_LIM3_LO
949 int32_t nChannelNum = 0;
956 if ((nLowLimit > (BITM_ADC_LIM0_LO_VALUE >> BITP_ADC_LIM0_LO_VALUE)) || (nChannelNum < 0) || (nChannelNum > 3))
962 nChannelNum = nGetChannelNumber(eChannel);
964 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
965 if (bEnable ==
true) {
967 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_LIM0_LO_VALUE)) |
968 (uint16_t)(nLowLimit << BITP_ADC_LIM0_LO_VALUE);
971 pDevice->ComparitorLo |= (1u << nChannelNum);
974 pDevice->ComparitorLo &= ~(1u << nChannelNum);
1001 uint16_t nHighLimit)
1003 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1004 static volatile uint16_t* pRegister[4] = {
1005 pREG_ADC0_LIM0_HI, pREG_ADC0_LIM1_HI, pREG_ADC0_LIM2_HI, pREG_ADC0_LIM3_HI
1007 int32_t nChannelNum = 0;
1010 if (pDevice == NULL)
1014 if ((nHighLimit > (BITM_ADC_LIM0_HI_VALUE >> BITP_ADC_LIM0_HI_VALUE)) || (nChannelNum < 0) || (nChannelNum > 3))
1020 nChannelNum = nGetChannelNumber(eChannel);
1022 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
1023 if (bEnable ==
true) {
1025 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_LIM0_HI_VALUE))
1026 | (uint16_t)(nHighLimit << BITP_ADC_LIM0_HI_VALUE);
1029 pDevice->ComparitorHi |= (1u << nChannelNum);
1032 pDevice->ComparitorHi &= ~(1u << nChannelNum);
1058 uint16_t nHysteresis)
1060 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1061 static volatile uint16_t* pRegister[4] = {
1062 pREG_ADC0_HYS0, pREG_ADC0_HYS1, pREG_ADC0_HYS2, pREG_ADC0_HYS3
1064 int32_t nChannelNum = 0;
1067 if (pDevice == NULL)
1071 if ((nHysteresis > (BITM_ADC_HYS0_VALUE >> BITP_ADC_HYS0_VALUE)) || (nChannelNum < 0) || (nChannelNum > 3))
1077 nChannelNum = nGetChannelNumber(eChannel);
1079 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
1080 if (bEnable ==
true) {
1081 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_HYS0_VALUE))
1082 | (uint16_t)(nHysteresis << BITP_ADC_HYS0_VALUE);
1085 pDevice->ComparitorHys |= (1u << nChannelNum);
1088 pDevice->ComparitorHys &= ~(1u << nChannelNum);
1112 uint32_t nNumMonitorCycles)
1115 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1118 static volatile uint16_t* pRegister[4] = {
1119 pREG_ADC0_HYS0, pREG_ADC0_HYS1, pREG_ADC0_HYS2, pREG_ADC0_HYS3
1121 int32_t nChannelNum = 0;
1124 if (pDevice == NULL)
1128 if ((nNumMonitorCycles > (BITM_ADC_HYS0_MONCYC >> BITP_ADC_HYS0_MONCYC)) || (nChannelNum < 0) || (nChannelNum > 3))
1134 nChannelNum = nGetChannelNumber(eChannel);
1136 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
1137 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_HYS0_MONCYC))
1138 | (uint16_t)(nNumMonitorCycles << BITP_ADC_HYS0_MONCYC);
1163 bool bEnableComparator
1166 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1168 if (pDevice == NULL)
1173 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN))
1178 if (IS_IN_ANY_STATE(ADC_STATUS_AVGERAGING_EN | ADC_STATUS_OVERSAMPLING_EN))
1183 if (pDevice->pfCallback == NULL) {
1187 if (bEnableComparator ==
true) {
1188 if((pDevice->ComparitorHi | pDevice->ComparitorLo) == 0u) {
1194 EnableComparator(pDevice, bEnableComparator);
1221 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1222 uint32_t nNumChannels = 0u;
1224 ADC_INT_BUFFER* pIntBuffer;
1227 if (pDevice == NULL)
1231 if (pBuffer == NULL) {
1240 nNumChannels = GetNumChannels(pBuffer->
nChannels);
1242 pIntBuffer = &pDevice->s_Buffer;
1244 pIntBuffer->nConfig = ADC_BUFFER_CONFIG_BUFFER_AUTO_MODE_EN;
1245 pIntBuffer->nStatus = ADC_BUFFER_STATUS_OK;
1248 pIntBuffer->nConfig |= ADC_BUFFER_CONFIG_BUFFER_SINGLE_CONV_EN;
1250 pIntBuffer->pUserBuffer = pBuffer;
1251 pIntBuffer->pCurDataBuffer = pBuffer->
pDataBuffer;
1253 pIntBuffer->nChannels = pBuffer->
nChannels;
1255 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INIT);
1283 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1287 if (pDevice == NULL)
1291 if (ppBuffer == NULL) {
1294 if (pDevice->pfCallback != NULL) {
1297 if (IS_NOT_IN_STATE(ADC_STATUS_NON_BLOCKING_EN)) {
1302 if (pDevice->s_Buffer.pUserBuffer == NULL) {
1309 if ((uint16_t)(pDevice->s_Buffer.nStatus & ADC_BUFFER_STATUS_OVERFLOW) != 0u) {
1312 *ppBuffer = pDevice->s_Buffer.pUserBuffer;
1313 pDevice->s_Buffer.pUserBuffer = NULL;
1314 CLR_STATE(ADC_STATUS_NON_BLOCKING_EN);
1337 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1340 if (pDevice == NULL)
1345 if (IS_IN_ANY_STATE(ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN)) {
1350 if (bEnable ==
true) {
1352 SET_STATE(ADC_STATUS_NON_BLOCKING_EN);
1355 NVIC_EnableIRQ(ADC0_EVT_IRQn);
1358 InitBufferProcessing(pDevice);
1361 NVIC_DisableIRQ(ADC0_EVT_IRQn);
1364 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_ABORT);
1366 CLR_STATE(ADC_STATUS_NON_BLOCKING_EN);
1390 bool *pbIsBufferAvailable)
1392 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1394 if (pDevice == NULL)
1398 if (pbIsBufferAvailable == NULL)
1402 if (pDevice->pfCallback != NULL) {
1407 if(IS_IN_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS))
1409 *pbIsBufferAvailable =
false;
1413 *pbIsBufferAvailable =
true;
1451 uint32_t nNumConversionPasses,
1453 uint32_t nBuffLength)
1455 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1456 uint32_t nNumChannels = 0u;
1459 ADC_INT_BUFFER* pIntBuffer;
1462 if (pDevice == NULL)
1466 if ((nChannels == 0u) || (nNumConversionPasses == 0u) || (pBuffer == NULL))
1470 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
1476 nNumChannels = GetNumChannels(nChannels);
1478 if (nBuffLength < ((nNumChannels *
sizeof(uint16_t)) * nNumConversionPasses))
1484 pDevice->pReg->STAT = 0xFFFFu;
1487 SET_STATE(ADC_STATUS_BLOCKING_EN);
1490 pIntBuffer = &pDevice->s_Buffer;
1492 pIntBuffer->nConfig = ADC_BUFFER_CONFIG_BUFFER_AUTO_MODE_EN;
1493 if (nNumConversionPasses == 1u) {
1494 pIntBuffer->nConfig |= ADC_BUFFER_CONFIG_BUFFER_SINGLE_CONV_EN;
1497 pIntBuffer->nStatus = ADC_BUFFER_STATUS_OK;
1498 pIntBuffer->pUserBuffer = NULL;
1499 pIntBuffer->pCurDataBuffer = pBuffer;
1500 pIntBuffer->nNumSamplesRemaining = nNumChannels * nNumConversionPasses;
1501 pIntBuffer->nChannels = nChannels;
1503 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INIT);
1505 InitBufferProcessing(pDevice);
1510 if ((uint16_t)(pDevice->s_Buffer.nStatus & ADC_BUFFER_STATUS_OVERFLOW) != 0u) {
1515 CLR_STATE(ADC_STATUS_BLOCKING_EN);
1518 NVIC_DisableIRQ(ADC0_EVT_IRQn);
1538 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1541 if (NULL == pDevice)
1547 NVIC_ClearPendingIRQ(ADC0_EVT_IRQn);
1552 pDevice->pReg->IRQ_EN = (BITM_ADC_IRQ_EN_RDY | BITM_ADC_IRQ_EN_ALERT | BITM_ADC_IRQ_EN_OVF | BITM_ADC_IRQ_EN_CALDONE | BITM_ADC_IRQ_EN_CNVDONE);
1554 NVIC_EnableIRQ(ADC0_EVT_IRQn);
1559 pDevice->pReg->IRQ_EN = 0u;
1561 NVIC_DisableIRQ(ADC0_EVT_IRQn);
1587 uint32_t nRefVoltage,
1588 uint32_t *pnBatVoltage)
1591 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1592 uint16_t nConvTimeBackup;
1593 uint16_t nAvgCfgBackup;
1594 uint32_t nAdcValue = 0u;
1595 uint32_t nClock = 0u;
1596 uint32_t nACLKDIVCNT;
1599 if (pDevice == NULL)
1603 if (pnBatVoltage == NULL)
1608 if (IS_NOT_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN)) {
1612 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN)) {
1620 nConvTimeBackup = pDevice->pReg->CNV_TIME;
1621 nAvgCfgBackup = pDevice->pReg->AVG_CFG;
1624 nACLKDIVCNT = (*pREG_CLKG0_CLK_CTL1 & BITM_CLKG_CLK_CTL1_ACLKDIVCNT) >> BITP_CLKG_CLK_CTL1_ACLKDIVCNT;
1629 nClock = nClock/nACLKDIVCNT;
1630 pDevice->pReg->CNV_TIME = (uint16_t)((nClock/2000000u) + ((uint16_t)1u));
1631 pDevice->pReg->AVG_CFG = 0u;
1634 pDevice->pReg->STAT = BITM_ADC_STAT_BATDONE;
1637 CLR_STATE(ADC_STATUS_BATTERY_DONE);
1640 pDevice->pReg->CNV_CFG = (BITM_ADC_CNV_CFG_SINGLE | BITM_ADC_CNV_CFG_BAT);
1643 while (IS_NOT_IN_STATE(ADC_STATUS_BATTERY_DONE)) { ; }
1646 pDevice->pReg->CNV_CFG = 0u;
1649 pDevice->pReg->CNV_TIME = nConvTimeBackup;
1650 pDevice->pReg->AVG_CFG = nAvgCfgBackup;
1656 nAdcValue = pDevice->pReg->BAT_OUT;
1657 *pnBatVoltage = (4u * nAdcValue * nRefVoltage) / ADI_ADC_SAMPLE_MAX;
1682 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1685 if (pDevice == NULL)
1691 if (bEnable ==
true)
1693 pDevice->pReg->CFG |= (uint16_t)BITM_ADC_CFG_TMPEN;
1694 SET_STATE(ADC_STATUS_TEMP_SENSOR_EN);
1698 pDevice->pReg->CFG &= (uint16_t)(~BITM_ADC_CFG_TMPEN);
1699 CLR_STATE(ADC_STATUS_TEMP_SENSOR_EN);
1731 uint32_t nRefVoltage,
1732 int32_t* pnTemperature
1736 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1737 uint16_t nConvTimeBackup;
1738 uint16_t nAvgCfgBackup;
1739 uint32_t nAdcTmpValue = 0u;
1740 uint32_t nAdcTmp2Value = 0u;
1741 uint32_t nClock = 0u;
1742 uint32_t nACLKDIVCNT;
1746 if (pDevice == NULL)
1750 if (pnTemperature == NULL)
1755 if (IS_NOT_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN | ADC_STATUS_TEMP_SENSOR_EN))
1760 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
1770 nACLKDIVCNT = (*pREG_CLKG0_CLK_CTL1 & BITM_CLKG_CLK_CTL1_ACLKDIVCNT) >> BITP_CLKG_CLK_CTL1_ACLKDIVCNT;
1771 nCnvTime = ((nClock / nACLKDIVCNT) / (uint16_t)15385u) + 1u;
1774 if (nCnvTime >= 256u) {
1779 nConvTimeBackup = pDevice->pReg->CNV_TIME;
1780 nAvgCfgBackup = pDevice->pReg->AVG_CFG;
1784 pDevice->pReg->CNV_TIME = (uint16_t)((nCnvTime << BITP_ADC_CNV_TIME_SAMPTIME) & BITM_ADC_CNV_TIME_SAMPTIME);
1785 pDevice->pReg->AVG_CFG = 0u;
1788 pDevice->pReg->STAT = BITM_ADC_STAT_TMPDONE | BITM_ADC_STAT_TMP2DONE;
1791 CLR_STATE(ADC_STATUS_TMP_DONE | ADC_STATUS_TMP2_DONE);
1794 pDevice->pReg->CNV_CFG = (BITM_ADC_CNV_CFG_SINGLE | BITM_ADC_CNV_CFG_TMP);
1795 while (IS_NOT_IN_STATE(ADC_STATUS_TMP_DONE)) { ; }
1796 nAdcTmpValue = pDevice->pReg->TMP_OUT;
1797 pDevice->pReg->CNV_CFG = 0u;
1801 pDevice->pReg->CNV_CFG = (BITM_ADC_CNV_CFG_SINGLE | BITM_ADC_CNV_CFG_TMP2);
1802 while (IS_NOT_IN_STATE(ADC_STATUS_TMP2_DONE)) { ; }
1803 pDevice->pReg->CNV_CFG = 0u;
1804 nAdcTmp2Value = pDevice->pReg->TMP2_OUT;
1807 pDevice->pReg->CNV_TIME = nConvTimeBackup;
1808 pDevice->pReg->AVG_CFG = nAvgCfgBackup;
1820 uint32_t nRVirRefByIdealSensitivity = 2070960834u;
1822 uint32_t nTempRG = 19380u;
1823 uint32_t nTmp2 = ((nAdcTmp2Value << 14u) + (nTempRG * nAdcTmpValue));
1825 uint32_t nOffsetPart = (335544320u/nRefVoltage);
1826 uint32_t nOffset = (161u * nOffsetPart);
1828 uint32_t nTmp3 = ((nAdcTmpValue << 12) - nOffset) << 8u;
1829 uint32_t nRatio = (nTmp3/(nTmp2 >> 10u));
1830 uint32_t nTemp = (nRatio * (nRVirRefByIdealSensitivity >> 16u)) >> 5u;
1832 int32_t iTemp = (int32_t)nTemp - ((int32_t)17901158);
1833 *pnTemperature = iTemp;
1849 static uint16_t ReadOutReg(uint32_t nChannelNum)
1851 const volatile uint16_t* pOutRegister = pREG_ADC0_CH0_OUT;
1852 pOutRegister += nChannelNum*2u;
1853 return *pOutRegister;
1857 static bool InitBufferProcessing(ADI_ADC_DEVICE *pDevice)
1859 uint32_t nCnvReg = ((uint32_t)(pDevice->pReg->CNV_CFG) & BITM_ADC_CNV_CFG_DMAEN);
1860 ADC_INT_BUFFER* pIntBuffer = &pDevice->s_Buffer;
1862 if (IS_NOT_IN_ANY_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS))
1865 pDevice->pReg->STAT = 0xFFFFu;
1868 pDevice->pReg->OVF = 0xFFFFu;
1872 nCnvReg |= pIntBuffer->nChannels;
1873 if ((uint16_t)(pIntBuffer->nConfig & ADC_BUFFER_CONFIG_BUFFER_AUTO_MODE_EN) != 0u) {
1874 nCnvReg |= BITM_ADC_CNV_CFG_AUTOMODE;
1876 if ((pIntBuffer->nConfig & ADC_BUFFER_CONFIG_BUFFER_SINGLE_CONV_EN) != 0u) {
1877 nCnvReg |= BITM_ADC_CNV_CFG_SINGLE;
1879 nCnvReg |= BITM_ADC_CNV_CFG_MULTI;
1882 SET_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
1884 pDevice->pReg->CNV_CFG |= (uint16_t)nCnvReg;
1886 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_ENABLED);
1892 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 1894 void DMA_ADC0_Int_Handler (
void)
1897 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *) AdcDevInfo[0].hDevice;
1899 DmaFIFOManage(pDevice, ADC_FIFO_MODE_DMA_BUFFER_PROCESS);
1904 static ADI_ADC_RESULT DmaFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode)
1906 uint16_t nCount = 0u;
1907 uint16_t chanNum = ADC0_CHANn;
1908 uint16_t IRQ_Backup;
1910 ADC_INT_BUFFER* pIntBuffer = &pDevice->s_Buffer;
1912 if(pDevice->s_Buffer.pCurDataBuffer == NULL) {
1914 if (eFifoMode == ADC_FIFO_MODE_INTERRUPT_PROCESS) {
1916 uint16_t nStat = pDevice->pReg->STAT & 0x00FFu;
1917 FlushFifo(pDevice, (uint32_t)nStat);
1918 pDevice->pReg->STAT = nStat;
1924 case ADC_FIFO_MODE_INIT:
1927 NVIC_EnableIRQ(DMA0_CH24_DONE_IRQn);
1929 pADI_DMA0->SRCADDR_CLR = 1U << chanNum;
1932 pADI_DMA0->EN_SET = 1U << chanNum;
1935 pADI_DMA0->RMSK_CLR = 1U << chanNum;
1938 pADI_DMA0->ALT_CLR = 1U << chanNum;
1941 nCount = (uint16_t)pIntBuffer->nNumSamplesRemaining;
1944 pPrimaryCCD[chanNum].DMASRCEND = (uint32_t)(&(pDevice->pReg->DMA_OUT));
1947 pPrimaryCCD[chanNum].DMADSTEND = (uint32_t)((
void*)pIntBuffer->pCurDataBuffer) + ((nCount * 2u) - 1u);
1953 ((nCount - (uint32_t)1U)<< DMA_BITP_CTL_N_MINUS_1) |
1954 (DMA_ENUM_CTL_CYCLE_CTL_BASIC << DMA_BITP_CTL_CYCLE_CTL) |
1958 pDevice->pReg->CNV_CFG |= BITM_ADC_CNV_CFG_DMAEN;
1961 case ADC_FIFO_MODE_ENABLED:
1964 case ADC_FIFO_MODE_INTERRUPT_PROCESS:
1966 pDevice->pReg->STAT = (pDevice->pReg->STAT & 0x00FFu);
1969 case ADC_FIFO_MODE_INTERRUPT_OVERFLOW:
1970 pIntBuffer->nStatus |= ADC_BUFFER_STATUS_OVERFLOW;
1973 case ADC_FIFO_MODE_DMA_BUFFER_PROCESS:
1974 pIntBuffer->nNumSamplesRemaining = 0u;
1975 ManageFifoCompletion(pDevice);
1978 case ADC_FIFO_MODE_ABORT:
1981 IRQ_Backup = pDevice->pReg->IRQ_EN;
1984 pDevice->pReg->IRQ_EN = 0u;
1987 pDevice->pReg->CNV_CFG = 0u;
1990 pADI_DMA0->EN_CLR = 1U << chanNum;
1993 pDevice->pReg->STAT = 0xFFFFu;
1996 CLR_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
1999 FlushFifo(pDevice, 0x00FFu);
2002 pDevice->pReg->IRQ_EN = IRQ_Backup;
2015 static ADI_ADC_RESULT InterruptFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode)
2017 ADC_INT_BUFFER* pIntBuffer = &pDevice->s_Buffer;
2019 if(pDevice->s_Buffer.pCurDataBuffer == NULL) {
2020 if (eFifoMode == ADC_FIFO_MODE_INTERRUPT_PROCESS) {
2021 uint16_t nStat = pDevice->pReg->STAT & 0x00FFu;
2022 FlushFifo(pDevice, (uint32_t)nStat);
2023 pDevice->pReg->STAT = nStat;
2030 case ADC_FIFO_MODE_INIT:
2033 pDevice->ActData.nCurChannel = 0u;
2037 case ADC_FIFO_MODE_ENABLED:
2040 case ADC_FIFO_MODE_INTERRUPT_PROCESS:
2042 while (pIntBuffer->nNumSamplesRemaining > 0u) {
2043 uint32_t nConvStatus = ((uint32_t)pDevice->pReg->STAT & (uint32_t)0x00FFu);
2044 if ((nConvStatus & 0x00FFu) == 0u)
2049 uint32_t nCurChannelBitM = ((uint32_t)1u << pDevice->ActData.nCurChannel);
2050 while ((nCurChannelBitM & nConvStatus) == 0u) {
2051 pDevice->ActData.nCurChannel++;
2052 if (pDevice->ActData.nCurChannel >= NUM_ADC_CHANNELS) {
2053 pDevice->ActData.nCurChannel = 0u;
2055 nCurChannelBitM = ((uint32_t)1u << pDevice->ActData.nCurChannel);
2058 assert ((pIntBuffer->nChannels & ((uint32_t)1u << pDevice->ActData.nCurChannel)) != 0u);
2060 *pIntBuffer->pCurDataBuffer = ReadOutReg( pDevice->ActData.nCurChannel);
2061 pIntBuffer->pCurDataBuffer++;
2064 pDevice->pReg->STAT = (uint16_t)nCurChannelBitM;
2065 pIntBuffer->nNumSamplesRemaining -= 1u;
2067 pDevice->ActData.nCurChannel += 1u;
2068 if ( pDevice->ActData.nCurChannel >= NUM_ADC_CHANNELS) {
2069 pDevice->ActData.nCurChannel = 0u;
2073 if (pIntBuffer->nNumSamplesRemaining == 0u) {
2074 ManageFifoCompletion(pDevice);
2079 case ADC_FIFO_MODE_INTERRUPT_OVERFLOW:
2081 pIntBuffer->nStatus |= ADC_BUFFER_STATUS_OVERFLOW;
2085 case ADC_FIFO_MODE_ABORT:
2087 uint16_t IRQ_Backup;
2090 IRQ_Backup = pDevice->pReg->IRQ_EN;
2093 pDevice->pReg->IRQ_EN = 0u;
2096 pDevice->pReg->CNV_CFG = 0u;
2099 pDevice->pReg->STAT = 0xFFFFu;
2102 CLR_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
2105 FlushFifo(pDevice, 0x00FFu);
2108 pDevice->pReg->IRQ_EN = IRQ_Backup;
2120 static void FlushFifo(ADI_ADC_DEVICE *pDevice, uint32_t nChannels)
2123 for (x = 0u; x < 8u; x++) {
2124 if ((nChannels & ((uint32_t)1u << x)) != 0u) {
2132 static void ManageFifoCompletion(ADI_ADC_DEVICE *pDevice)
2135 pDevice->pReg->CNV_CFG = 0u;
2136 CLR_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
2144 static uint32_t GetNumChannels(uint32_t nChannels)
2146 uint32_t n = nChannels & 0x000000FFu;
2148 n = (n & 0x00000055u) + ((n >> 1u) & 0x00000055u);
2149 n = (n & 0x00000033u) + ((n >> 2u) & 0x00000033u);
2150 n = (n + (n >> 4u)) & (0x0000000Fu);
2160 uint32_t nChannel = (uint32_t)eChannel & 0x000000FFu;
2162 if ((nChannel & (nChannel - (uint32_t)1u)) != 0u) {
2165 if ((nChannel & 0x000000AAu) != 0u) { retVal += 1; }
2166 if ((nChannel & 0x000000CCu) != 0u) { retVal += 2; }
2167 if ((nChannel & 0x000000F0u) != 0u) { retVal += 4; }
2173 static void StaticConfiguration(ADI_ADC_DEVICE *pDevice)
2175 uint16_t nCfgReg = 0u;
2178 #if ADI_ADC_CFG_RESOLUTION == 12 2179 pDevice->pReg->AVG_CFG = 0u;
2182 #if ADI_ADC_CFG_RESOLUTION == 13 2183 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0002u << BITP_ADC_AVG_CFG_FACTOR);
2184 #elif ADI_ADC_CFG_RESOLUTION == 14 2185 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0008u << BITP_ADC_AVG_CFG_FACTOR);
2186 #elif ADI_ADC_CFG_RESOLUTION == 15 2187 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0020u << BITP_ADC_AVG_CFG_FACTOR);
2188 #elif ADI_ADC_CFG_RESOLUTION == 16 2189 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0080u << BITP_ADC_AVG_CFG_FACTOR);
2191 #error "Invalid Resolution" 2194 SET_STATE(ADC_STATUS_OVERSAMPLING_EN);
2198 #if ADI_ADC_CFG_VREF == 0 2199 nCfgReg |= BITM_ADC_CFG_REFBUFEN | BITM_ADC_CFG_VREFSEL;
2200 #elif ADI_ADC_CFG_VREF == 1 2201 nCfgReg |= BITM_ADC_CFG_REFBUFEN;
2202 #elif ADI_ADC_CFG_VREF == 2 2203 nCfgReg |= BITM_ADC_CFG_VREFVBAT;
2206 pDevice->pReg->CFG = nCfgReg;
2208 #if ADI_ADC_ENABLE_STATIC_COMPARATOR == 1 2210 #if ADI_ADC_COMPARATOR_AIN0_HI_EN == 1 2214 #if ADI_ADC_COMPARATOR_AIN1_HI_EN == 1 2218 #if ADI_ADC_COMPARATOR_AIN2_HI_EN == 1 2222 #if ADI_ADC_COMPARATOR_AIN3_HI_EN == 1 2227 #if ADI_ADC_COMPARATOR_AIN0_LO_EN == 1 2231 #if ADI_ADC_COMPARATOR_AIN1_LO_EN == 1 2235 #if ADI_ADC_COMPARATOR_AIN2_LO_EN == 1 2239 #if ADI_ADC_COMPARATOR_AIN3_LO_EN == 1 2245 #if ADI_ADC_COMPARATOR_AIN0_HYS_EN == 1 2249 #if ADI_ADC_COMPARATOR_AIN1_HYS_EN == 1 2253 #if ADI_ADC_COMPARATOR_AIN2_HYS_EN == 1 2257 #if ADI_ADC_COMPARATOR_AIN3_HYS_EN == 1 2268 static void EnableComparator(ADI_ADC_DEVICE *pDevice,
bool bEnable)
2271 uint16_t nCnvCfg = 0u;
2272 volatile uint16_t* pLO_Register[4] = {pREG_ADC0_LIM0_LO, pREG_ADC0_LIM1_LO, pREG_ADC0_LIM2_LO, pREG_ADC0_LIM3_LO};
2273 volatile uint16_t* pHI_Register[4] = {pREG_ADC0_LIM0_HI, pREG_ADC0_LIM1_HI, pREG_ADC0_LIM2_HI, pREG_ADC0_LIM3_HI};
2274 volatile uint16_t* pHYS_Register[4] = {pREG_ADC0_HYS0, pREG_ADC0_HYS1, pREG_ADC0_HYS2, pREG_ADC0_HYS3};
2276 if (bEnable ==
true)
2279 for (x = 0u; x < NUM_ADC_COMPARATOR_CHANNELS; x++) {
2280 if((pDevice->ComparitorHi & (1u << x)) > 0u) {
2281 *pHI_Register[x] |= BITM_ADC_LIM0_HI_EN;
2283 if((pDevice->ComparitorLo & (1u << x)) > 0u) {
2284 *pLO_Register[x] |= BITM_ADC_LIM0_LO_EN;
2286 if((pDevice->ComparitorHys & (1u << x)) > 0u) {
2287 *pHYS_Register[x] |= BITM_ADC_HYS0_EN;
2290 nCnvCfg = (uint16_t)((uint16_t)pDevice->ComparitorHi | (uint16_t)pDevice->ComparitorLo);
2292 pDevice->pReg->IRQ_EN &= (uint16_t)(~BITM_ADC_IRQ_EN_CNVDONE);
2293 pDevice->pReg->CNV_CFG = (uint16_t)nCnvCfg | (uint16_t)(BITM_ADC_CNV_CFG_MULTI | BITM_ADC_CNV_CFG_AUTOMODE);
2294 SET_STATE(ADC_STATUS_COMPARATOR_EN);
2298 for (x = 0u; x < NUM_ADC_COMPARATOR_CHANNELS; x++) {
2299 *pHI_Register[x] &= (uint16_t)(~(BITM_ADC_LIM0_HI_EN));
2300 *pLO_Register[x] &= (uint16_t)(~(BITM_ADC_LIM0_LO_EN));
2301 *pHYS_Register[x] &= (uint16_t)(~(BITM_ADC_HYS0_EN));
2303 pDevice->pReg->CNV_CFG = 0u;
2304 pDevice->pReg->STAT = pDevice->pReg->STAT & 0x00FFu;
2305 CLR_STATE(ADC_STATUS_COMPARATOR_EN);
2306 pDevice->pReg->IRQ_EN |= BITM_ADC_IRQ_EN_CNVDONE;
2320 #if defined(__ADUCM302x__) 2321 void ADC_Int_Handler(
void)
2323 void ADC0_Int_Handler(
void)
2326 ADI_ADC_DEVICE *pDevice;
2329 pDevice = (ADI_ADC_DEVICE *) AdcDevInfo[0].hDevice;
2331 if ((pDevice->pReg->STAT & 0x00FFu) != 0u) {
2332 if (IS_NOT_IN_STATE(ADC_STATUS_COMPARATOR_EN)) {
2333 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INTERRUPT_PROCESS);
2335 pDevice->pReg->STAT = pDevice->pReg->STAT & (0x00FFu);
2338 if ((uint16_t)(pDevice->pReg->STAT & 0xFF00u) != 0u) {
2339 if ((pDevice->pReg->STAT & BITM_ADC_STAT_RDY) != 0u) {
2340 SET_STATE(ADC_STATUS_SUB_SYSTEM_READY);
2341 pDevice->pReg->STAT = BITM_ADC_STAT_RDY;
2342 if (pDevice->pfCallback != NULL) {
2346 if ((pDevice->pReg->STAT & BITM_ADC_STAT_CALDONE) != 0u) {
2347 SET_STATE(ADC_STATUS_CALIBRATION_DONE);
2348 pDevice->pReg->STAT = BITM_ADC_STAT_CALDONE;
2349 if (pDevice->pfCallback != NULL) {
2353 if ((pDevice->pReg->STAT & BITM_ADC_STAT_BATDONE) != 0u) {
2354 SET_STATE(ADC_STATUS_BATTERY_DONE);
2355 pDevice->pReg->STAT = BITM_ADC_STAT_BATDONE;
2358 if ((pDevice->pReg->STAT & BITM_ADC_STAT_TMPDONE) != 0u) {
2359 SET_STATE(ADC_STATUS_TMP_DONE);
2360 pDevice->pReg->STAT = BITM_ADC_STAT_TMPDONE;
2363 if ((pDevice->pReg->STAT & BITM_ADC_STAT_TMP2DONE) != 0u) {
2364 SET_STATE(ADC_STATUS_TMP2_DONE);
2365 pDevice->pReg->STAT = BITM_ADC_STAT_TMP2DONE;
2368 if (pDevice->pReg->OVF) {
2369 uint16_t nOvrFlowValue = pDevice->pReg->OVF;
2370 if (IS_NOT_IN_STATE(ADC_STATUS_COMPARATOR_EN)) {
2371 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INTERRUPT_OVERFLOW);
2373 pDevice->pReg->OVF = nOvrFlowValue;
2375 if (pDevice->pReg->ALERT) {
2376 uint32_t nAlertValue = pDevice->pReg->ALERT;
2378 if (IS_IN_STATE(ADC_STATUS_COMPARATOR_EN) && (pDevice->pfCallback != NULL)) {
2379 for (channel = 0u; channel < (NUM_ADC_COMPARATOR_CHANNELS); channel++) {
2383 if((nAlertValue & (1u << (2u * channel))) > 0u) {
2386 if((nAlertValue & (1u << ((2u * channel) + ((uint32_t)1u)))) > 0u)
2392 pDevice->pReg->ALERT = (uint16_t)nAlertValue;
#define ADI_ADC_COMPARATOR_AIN1_LO_VAL
ADI_ADC_RESULT adi_adc_Close(ADI_ADC_HANDLE hDevice)
Close the given device instance.
ADI_ADC_RESULT adi_adc_SetLowLimit(ADI_ADC_HANDLE hDevice, ADI_ADC_CHANNEL eChannel, bool bEnable, uint16_t nLowLimit)
Configure low limit for an ADC channel when it is used as a digital comparator.
ADI_ADC_RESULT adi_adc_IsCalibrationDone(ADI_ADC_HANDLE hDevice, bool *pbCalibrationDone)
Returns the status of the calibration which was initiated.
ADI_ADC_RESULT adi_adc_EnableIRQ(ADI_ADC_HANDLE hDevice, bool bEnable)
Enable/Disable ADC Interrupts.
ADI_ADC_RESULT adi_adc_EnableTemperatureSensor(ADI_ADC_HANDLE hDevice, bool bEnable)
Enable or disable the temperature sensor.
ADI_ADC_RESULT adi_adc_EnableAveraging(ADI_ADC_HANDLE hDevice, uint16_t nAveragingSamples)
Enable Averaging for all ADC channels.
#define ADI_ADC_COMPARATOR_AIN1_HI_VAL
#define ADI_ADC_CHANNEL_0
#define ADI_ADC_COMPARATOR_AIN2_LO_VAL
ADI_ADC_RESULT adi_adc_SetHysteresis(ADI_ADC_HANDLE hDevice, ADI_ADC_CHANNEL eChannel, bool bEnable, uint16_t nHysteresis)
Configure hysteresis for an ADC channel when it's used as a digital comparator.
ADI_ADC_RESULT adi_adc_ReadChannels(ADI_ADC_HANDLE hDevice, uint32_t nChannels, uint32_t nNumConversionPasses, void *pBuffer, uint32_t nBuffLength)
Sample the given channels for the given number of conversion passes and put it into the given buffer....
#define ADI_ADC_COMPARATOR_AIN3_HYS_CYC
ADI_ADC_RESULT adi_adc_SinkEnable(ADI_ADC_HANDLE hDevice, bool bEnable)
Enable/Disable Current Sink.
ADI_ADC_RESULT adi_adc_Open(uint32_t nDeviceNum, void *pMemory, uint32_t nMemorySize, ADI_ADC_HANDLE *phDevice)
Opens an ADC device instance.
#define ADI_ADC_COMPARATOR_AIN1_HYS_VAL
ADI_ADC_RESULT adi_adc_SetDelayTime(ADI_ADC_HANDLE hDevice, uint32_t nDelayInAClkCycles)
Set the delay time of ADC in ADC cycles for multi iteration mode.
ADI_ADC_RESULT adi_adc_EnableADCSubSystem(ADI_ADC_HANDLE hDevice, bool bEnable)
Enable/Disables the ADC Subsystem.
#define ADI_ADC_COMPARATOR_AIN0_HYS_CYC
ADI_ADC_RESULT adi_adc_SetNumMonitorCycles(ADI_ADC_HANDLE hDevice, ADI_ADC_CHANNEL eChannel, uint32_t nNumMonitorCycles)
Configure number of monitor cycles for an ADC channel when it's used as a digital comparator.
#define ADI_ADC_CHANNEL_3
ADI_ADC_RESULT adi_adc_PowerUp(ADI_ADC_HANDLE hDevice, bool bPowerUp)
Power up ADC.
#define ADI_ADC_COMPARATOR_AIN0_LO_VAL
ADI_ADC_RESULT adi_adc_GetBuffer(ADI_ADC_HANDLE hDevice, ADI_ADC_BUFFER **ppBuffer)
Get a processed buffer from the ADC Driver. This function is a blocking call and will only return onc...
ADI_ADC_RESULT adi_adc_GetBatteryVoltage(ADI_ADC_HANDLE hDevice, uint32_t nRefVoltage, uint32_t *pnBatVoltage)
Returns the battery voltage.
ADI_ADC_RESULT adi_adc_SetHighLimit(ADI_ADC_HANDLE hDevice, ADI_ADC_CHANNEL eChannel, bool bEnable, uint16_t nHighLimit)
Configure high limit for an ADC channel when it's used as a digital comparator.
#define ADI_ADC_COMPARATOR_AIN2_HYS_CYC
#define ADI_ADC_COMPARATOR_AIN3_HYS_VAL
#define ADI_ADC_COMPARATOR_AIN3_HI_VAL
ADI_PWR_RESULT adi_pwr_GetClockFrequency(const ADI_CLOCK_ID eClockId, uint32_t *pClock)
Get the frequency of the given clock. Obtain individual peripheral clock frequencies.
#define ADI_ADC_MEMORY_SIZE
ADI_ADC_RESULT adi_adc_IsBufferAvailable(ADI_ADC_HANDLE hDevice, bool *pbIsBufferAvailable)
This function return whether a filled buffer is available to be returned to the user....
uint32_t nNumConversionPasses
#define ADI_ADC_CHANNEL_1
#define ADI_ADC_COMPARATOR_AIN0_HI_VAL
#define ADI_ADC_COMPARATOR_AIN2_HI_VAL
#define ADI_ADC_COMPARATOR_AIN3_LO_VAL
#define ADI_ADC_COMPARATOR_AIN1_HYS_CYC
ADI_ADC_RESULT adi_adc_SetAcquisitionTime(ADI_ADC_HANDLE hDevice, uint32_t nAcqTimeInAClkCycles)
Set the acquisition time of ADC in ADC clock cycles.
ADI_ADC_RESULT adi_adc_SetResolution(ADI_ADC_HANDLE hDevice, ADI_ADC_RESOLUTION eResolution)
Set the resolution of ADC. he default resolution of ADC is 12-bit and the ADC increases the resolutio...
ADI_ADC_RESULT adi_adc_SubmitBuffer(ADI_ADC_HANDLE hDevice, ADI_ADC_BUFFER *pBuffer)
Submit the ADC buffer for processing to the ADC Module.
ADI_ADC_RESULT adi_adc_Enable(ADI_ADC_HANDLE hDevice, bool bEnable)
Enable/Disable ADC for sampling.
#define ADI_ADC_COMPARATOR_AIN0_HYS_VAL
ADI_ADC_RESULT adi_adc_IsReady(ADI_ADC_HANDLE hDevice, bool *pbReady)
Returns whether the ADC Subsystem is ready.
ADI_ADC_RESULT adi_adc_GetTemperature(ADI_ADC_HANDLE hDevice, uint32_t nRefVoltage, int32_t *pnTemperature)
Return the temperature in fixed point format in degree Celcius.
void adi_dma_Init(void)
Initialize the DMA peripheral.
struct __ADI_ADC_DEVICE * ADI_ADC_HANDLE
ADI_ADC_RESULT adi_adc_RegisterCallback(ADI_ADC_HANDLE hDevice, ADI_CALLBACK pfCallback, void *pCBParam)
Registering a callback function.
#define ADI_ADC_COMPARATOR_AIN2_HYS_VAL
ADI_ADC_RESULT adi_adc_EnableDigitalComparator(ADI_ADC_HANDLE hDevice, bool bEnableComparator)
Enable/Disable digital comparator for the given channel(s)
#define ADI_ADC_CHANNEL_2
ADI_ADC_RESULT adi_adc_SetVrefSource(ADI_ADC_HANDLE hDevice, ADI_ADC_VREF_SRC eVrefSrc)
Set the Voltage Reference source.
ADI_ADC_RESULT adi_adc_StartCalibration(ADI_ADC_HANDLE hDevice)
Start the ADC calibration.