66 #include <drivers/adc/adi_adc.h> 67 #include <adi_processor.h> 70 #include <drivers/pwr/adi_pwr.h> 71 #include <adi_adc_config.h> 72 #include <rtos_map/adi_rtos_map.h> 98 #pragma diag_suppress=Pm123,Pm073,Pm143,Pm050,Pm088,Pm140,Pm152 101 #include "adi_adc_def.h" 102 #include "adi_adc_data.c" 106 #define ADI_ADC_INVALID_HANDLE(h) (AdcDevInfo[0].hDevice != (h)) 110 #define ADI_MAX_ACQUISITION_TIME (((uint32_t)BITM_ADC_CNV_TIME_SAMPTIME << BITP_ADC_CNV_TIME_SAMPTIME) + 1u) 113 #define ADI_ADC_SAMPLE_MAX ((uint16_t)(4095u)) 121 #if defined(__ADUCM302x__) 122 extern void ADC_Int_Handler(
void);
124 extern void ADC0_Int_Handler(
void);
128 #if defined(__ADUCM302x__) 129 #define BITM_ADC_CFG_VREFVBAT (_ADI_MSK_3(0x00000008,0x00000008U, uint16_t )) 132 extern void DMA_ADC0_Int_Handler (
void);
138 static uint16_t ReadOutReg(uint32_t nChannelNum);
141 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 142 static ADI_ADC_RESULT DmaFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode);
144 static ADI_ADC_RESULT InterruptFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode);
148 static uint32_t GetNumChannels(uint32_t nChannels);
152 static void ManageFifoCompletion(ADI_ADC_DEVICE *pDevice);
153 static bool InitBufferProcessing(ADI_ADC_DEVICE *pDevice);
154 static void FlushFifo(ADI_ADC_DEVICE *pDevice, uint32_t nChannels);
157 static void EnableComparator(ADI_ADC_DEVICE *pDevice,
bool bEnable);
158 static void StaticConfiguration(ADI_ADC_DEVICE *pDevice);
182 uint32_t nMemorySize,
185 ADI_INT_STATUS_ALLOC();
186 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)pMemory;
189 if (nDeviceNum > (
sizeof (AdcDevInfo)/
sizeof(AdcDevInfo[0])))
199 if (AdcDevInfo[nDeviceNum].hDevice != NULL)
207 memset (pMemory, 0, nMemorySize);
209 ADI_ENTER_CRITICAL_REGION();
211 pDevice->pReg = AdcDevInfo[nDeviceNum].pReg;
212 ADI_EXIT_CRITICAL_REGION();
215 pDevice->pReg->CFG = BITM_ADC_CFG_RST;
218 NVIC_ClearPendingIRQ(ADC0_EVT_IRQn);
219 NVIC_EnableIRQ(ADC0_EVT_IRQn);
222 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;
225 StaticConfiguration(pDevice);
231 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 232 pDevice->pfManageFifo = DmaFIFOManage;
236 pDevice->pfManageFifo = InterruptFIFOManage;
240 *phDevice = AdcDevInfo[nDeviceNum].hDevice;
257 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
273 pDevice->pReg->IRQ_EN = 0u;
276 pDevice->pReg->CNV_CFG = 0u;
278 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 280 NVIC_DisableIRQ(DMA0_CH24_DONE_IRQn);
284 NVIC_DisableIRQ(ADC0_EVT_IRQn);
290 AdcDevInfo[0].hDevice = (NULL);
311 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
312 uint32_t nClock = 0u;
313 uint16_t nCount = 0u;
323 if (bPowerUp ==
true)
325 if (IS_NOT_IN_ANY_STATE(ADC_STATUS_POWERED_UP))
332 nCount = (uint16_t)(nClock / 50000u);
335 pDevice->pReg->CFG |= BITM_ADC_CFG_PWRUP;
338 pDevice->pReg->PWRUP = (uint16_t)(((uint32_t)nCount << BITP_ADC_PWRUP_WAIT) & BITM_ADC_PWRUP_WAIT);
340 SET_STATE(ADC_STATUS_POWERED_UP);
350 if (IS_IN_STATE(ADC_STATUS_POWERED_UP))
353 if ( IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN) )
363 pDevice->pReg->CFG &= (uint16_t)(~(BITM_ADC_CFG_PWRUP));
364 CLR_STATE(ADC_STATUS_POWERED_UP);
391 ADI_CALLBACK pfCallback,
394 ADI_INT_STATUS_ALLOC();
396 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
404 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
411 ADI_ENTER_CRITICAL_REGION();
412 pDevice->pfCallback = pfCallback;
413 pDevice->pCBParam = pCBParam;
414 ADI_EXIT_CRITICAL_REGION();
442 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
450 if (IS_NOT_IN_STATE(ADC_STATUS_POWERED_UP))
455 if (bEnable ==
true) {
456 if (IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN)) {
460 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN)) {
468 pDevice->pReg->CFG |= BITM_ADC_CFG_EN;
469 SET_STATE(ADC_STATUS_SUB_SYSTEM_EN);
473 pDevice->pReg->CFG &= (uint16_t)(~BITM_ADC_CFG_EN);
474 CLR_STATE(ADC_STATUS_SUB_SYSTEM_EN | ADC_STATUS_SUB_SYSTEM_READY);
505 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
518 if (IS_NOT_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN))
524 if (IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_READY))
557 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
565 if (IS_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN))
571 pDevice->pReg->CFG &= (uint16_t)(~(BITM_ADC_CFG_REFBUFEN | BITM_ADC_CFG_VREFSEL | BITM_ADC_CFG_VREFVBAT));
576 pDevice->pReg->CFG |= BITM_ADC_CFG_REFBUFEN | BITM_ADC_CFG_VREFSEL;
580 pDevice->pReg->CFG |= BITM_ADC_CFG_REFBUFEN;
584 pDevice->pReg->CFG |= BITM_ADC_CFG_VREFVBAT;
618 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
629 pDevice->pReg->CFG |= BITM_ADC_CFG_SINKEN;
633 pDevice->pReg->CFG &= (uint16_t)~(BITM_ADC_CFG_SINKEN);
655 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
664 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN))
672 CLR_STATE(ADC_STATUS_CALIBRATION_DONE);
675 pDevice->pReg->STAT = BITM_ADC_STAT_CALDONE;
679 SET_STATE(ADC_STATUS_CALIBRATION_EN);
682 pDevice->pReg->CFG |= BITM_ADC_CFG_STARTCAL;
703 bool *pbCalibrationDone)
705 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
713 if (pbCalibrationDone == NULL)
722 if (IS_IN_STATE(ADC_STATUS_CALIBRATION_DONE))
724 *pbCalibrationDone =
true;
728 *pbCalibrationDone =
false;
755 uint32_t nAcqTimeInAClkCycles
758 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
767 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
773 if ((nAcqTimeInAClkCycles == 0u) || (nAcqTimeInAClkCycles > (ADI_MAX_ACQUISITION_TIME)))
781 nCnvTime = pDevice->pReg->CNV_TIME;
782 nCnvTime &= (uint16_t)(~BITM_ADC_CNV_TIME_SAMPTIME);
783 nCnvTime |= (uint16_t)((nAcqTimeInAClkCycles - ((uint32_t)1u)) << BITP_ADC_CNV_TIME_SAMPTIME);
784 pDevice->pReg->CNV_TIME = nCnvTime;
803 uint32_t nDelayInAClkCycles)
805 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
814 if (nDelayInAClkCycles > (BITM_ADC_CNV_TIME_DLY >> BITP_ADC_CNV_TIME_DLY))
820 nCnvTime = pDevice->pReg->CNV_TIME;
821 nCnvTime &= (uint16_t)(~BITM_ADC_CNV_TIME_DLY);
822 nCnvTime |= (uint16_t)(nDelayInAClkCycles << BITP_ADC_CNV_TIME_DLY);
823 pDevice->pReg->CNV_TIME = nCnvTime;
847 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
855 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
868 pDevice->pReg->AVG_CFG &= (uint16_t)(~BITM_ADC_AVG_CFG_OS);
869 if (IS_NOT_IN_STATE(ADC_STATUS_AVGERAGING_EN)) {
870 pDevice->pReg->AVG_CFG = 0u;
872 CLR_STATE(ADC_STATUS_OVERSAMPLING_EN);
883 nFactor = (uint16_t)1u << (((uint16_t)eResolution * 2u) - ((uint16_t)1u));
884 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN
885 | (uint16_t)(nFactor << BITP_ADC_AVG_CFG_FACTOR);
886 SET_STATE(ADC_STATUS_OVERSAMPLING_EN);
913 uint16_t nAveragingSamples
916 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
925 if ((nAveragingSamples == 0u) || (nAveragingSamples > 256u)
927 || ((nAveragingSamples & (nAveragingSamples - 1u)) != 0u))
931 if (IS_IN_STATE(ADC_STATUS_OVERSAMPLING_EN))
938 if (nAveragingSamples == 1u)
940 pDevice->pReg->AVG_CFG &= (uint16_t)(~BITM_ADC_AVG_CFG_EN);
941 CLR_STATE(ADC_STATUS_AVGERAGING_EN);
945 nFactor = nAveragingSamples >> 1;
946 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_EN | (uint16_t)(nFactor << BITP_ADC_AVG_CFG_FACTOR);
947 SET_STATE(ADC_STATUS_AVGERAGING_EN);
976 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
977 static volatile uint16_t* pRegister[4] = {
978 pREG_ADC0_LIM0_LO, pREG_ADC0_LIM1_LO, pREG_ADC0_LIM2_LO, pREG_ADC0_LIM3_LO
980 int32_t nChannelNum = 0;
987 if ((nLowLimit > (BITM_ADC_LIM0_LO_VALUE >> BITP_ADC_LIM0_LO_VALUE)) || (nChannelNum < 0) || (nChannelNum > 3))
993 nChannelNum = nGetChannelNumber(eChannel);
995 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
996 if (bEnable ==
true) {
998 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_LIM0_LO_VALUE)) |
999 (uint16_t)(nLowLimit << BITP_ADC_LIM0_LO_VALUE);
1002 pDevice->ComparitorLo |= (1u << nChannelNum);
1005 pDevice->ComparitorLo &= ~(1u << nChannelNum);
1032 uint16_t nHighLimit)
1034 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1035 static volatile uint16_t* pRegister[4] = {
1036 pREG_ADC0_LIM0_HI, pREG_ADC0_LIM1_HI, pREG_ADC0_LIM2_HI, pREG_ADC0_LIM3_HI
1038 int32_t nChannelNum = 0;
1041 if (pDevice == NULL)
1045 if ((nHighLimit > (BITM_ADC_LIM0_HI_VALUE >> BITP_ADC_LIM0_HI_VALUE)) || (nChannelNum < 0) || (nChannelNum > 3))
1051 nChannelNum = nGetChannelNumber(eChannel);
1053 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
1054 if (bEnable ==
true) {
1056 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_LIM0_HI_VALUE))
1057 | (uint16_t)(nHighLimit << BITP_ADC_LIM0_HI_VALUE);
1060 pDevice->ComparitorHi |= (1u << nChannelNum);
1063 pDevice->ComparitorHi &= ~(1u << nChannelNum);
1089 uint16_t nHysteresis)
1091 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1092 static volatile uint16_t* pRegister[4] = {
1093 pREG_ADC0_HYS0, pREG_ADC0_HYS1, pREG_ADC0_HYS2, pREG_ADC0_HYS3
1095 int32_t nChannelNum = 0;
1098 if (pDevice == NULL)
1102 if ((nHysteresis > (BITM_ADC_HYS0_VALUE >> BITP_ADC_HYS0_VALUE)) || (nChannelNum < 0) || (nChannelNum > 3))
1108 nChannelNum = nGetChannelNumber(eChannel);
1110 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
1111 if (bEnable ==
true) {
1112 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_HYS0_VALUE))
1113 | (uint16_t)(nHysteresis << BITP_ADC_HYS0_VALUE);
1116 pDevice->ComparitorHys |= (1u << nChannelNum);
1119 pDevice->ComparitorHys &= ~(1u << nChannelNum);
1143 uint32_t nNumMonitorCycles)
1146 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1149 static volatile uint16_t* pRegister[4] = {
1150 pREG_ADC0_HYS0, pREG_ADC0_HYS1, pREG_ADC0_HYS2, pREG_ADC0_HYS3
1152 int32_t nChannelNum = 0;
1155 if (pDevice == NULL)
1159 if ((nNumMonitorCycles > (BITM_ADC_HYS0_MONCYC >> BITP_ADC_HYS0_MONCYC)) || (nChannelNum < 0) || (nChannelNum > 3))
1165 nChannelNum = nGetChannelNumber(eChannel);
1167 if((nChannelNum >= 0) && (nChannelNum <= 3)) {
1168 *pRegister[nChannelNum] = (uint16_t)(*pRegister[nChannelNum] & (uint16_t)(~BITM_ADC_HYS0_MONCYC))
1169 | (uint16_t)(nNumMonitorCycles << BITP_ADC_HYS0_MONCYC);
1194 bool bEnableComparator
1197 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1199 if (pDevice == NULL)
1204 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN))
1209 if (IS_IN_ANY_STATE(ADC_STATUS_AVGERAGING_EN | ADC_STATUS_OVERSAMPLING_EN))
1214 if (pDevice->pfCallback == NULL) {
1218 if (bEnableComparator ==
true) {
1219 if((pDevice->ComparitorHi | pDevice->ComparitorLo) == 0u) {
1225 EnableComparator(pDevice, bEnableComparator);
1252 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1253 uint32_t nNumChannels = 0u;
1255 ADC_INT_BUFFER* pIntBuffer;
1258 if (pDevice == NULL)
1262 if (pBuffer == NULL) {
1271 nNumChannels = GetNumChannels(pBuffer->
nChannels);
1273 pIntBuffer = &pDevice->s_Buffer;
1275 pIntBuffer->nConfig = ADC_BUFFER_CONFIG_BUFFER_AUTO_MODE_EN;
1276 pIntBuffer->nStatus = ADC_BUFFER_STATUS_OK;
1279 pIntBuffer->nConfig |= ADC_BUFFER_CONFIG_BUFFER_SINGLE_CONV_EN;
1281 pIntBuffer->pUserBuffer = pBuffer;
1282 pIntBuffer->pCurDataBuffer = pBuffer->
pDataBuffer;
1284 pIntBuffer->nChannels = pBuffer->
nChannels;
1286 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INIT);
1314 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1318 if (pDevice == NULL)
1322 if (ppBuffer == NULL) {
1325 if (pDevice->pfCallback != NULL) {
1328 if (IS_NOT_IN_STATE(ADC_STATUS_NON_BLOCKING_EN)) {
1333 if (pDevice->s_Buffer.pUserBuffer == NULL) {
1340 if ((uint16_t)(pDevice->s_Buffer.nStatus & ADC_BUFFER_STATUS_OVERFLOW) != 0u) {
1343 *ppBuffer = pDevice->s_Buffer.pUserBuffer;
1344 pDevice->s_Buffer.pUserBuffer = NULL;
1345 CLR_STATE(ADC_STATUS_NON_BLOCKING_EN);
1368 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1371 if (pDevice == NULL)
1376 if (IS_IN_ANY_STATE(ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN)) {
1381 if (bEnable ==
true) {
1383 SET_STATE(ADC_STATUS_NON_BLOCKING_EN);
1386 NVIC_EnableIRQ(ADC0_EVT_IRQn);
1389 InitBufferProcessing(pDevice);
1392 NVIC_DisableIRQ(ADC0_EVT_IRQn);
1395 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_ABORT);
1397 CLR_STATE(ADC_STATUS_NON_BLOCKING_EN);
1421 bool *pbIsBufferAvailable)
1423 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1425 if (pDevice == NULL)
1429 if (pbIsBufferAvailable == NULL)
1433 if (pDevice->pfCallback != NULL) {
1438 if(IS_IN_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS))
1440 *pbIsBufferAvailable =
false;
1444 *pbIsBufferAvailable =
true;
1482 uint32_t nNumConversionPasses,
1484 uint32_t nBuffLength)
1486 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1487 uint32_t nNumChannels = 0u;
1490 ADC_INT_BUFFER* pIntBuffer;
1493 if (pDevice == NULL)
1497 if ((nChannels == 0u) || (nNumConversionPasses == 0u) || (pBuffer == NULL))
1501 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
1507 nNumChannels = GetNumChannels(nChannels);
1509 if (nBuffLength < ((nNumChannels *
sizeof(uint16_t)) * nNumConversionPasses))
1515 pDevice->pReg->STAT = 0xFFFFu;
1518 SET_STATE(ADC_STATUS_BLOCKING_EN);
1521 pIntBuffer = &pDevice->s_Buffer;
1523 pIntBuffer->nConfig = ADC_BUFFER_CONFIG_BUFFER_AUTO_MODE_EN;
1524 if (nNumConversionPasses == 1u) {
1525 pIntBuffer->nConfig |= ADC_BUFFER_CONFIG_BUFFER_SINGLE_CONV_EN;
1528 pIntBuffer->nStatus = ADC_BUFFER_STATUS_OK;
1529 pIntBuffer->pUserBuffer = NULL;
1530 pIntBuffer->pCurDataBuffer = pBuffer;
1531 pIntBuffer->nNumSamplesRemaining = nNumChannels * nNumConversionPasses;
1532 pIntBuffer->nChannels = nChannels;
1534 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INIT);
1536 InitBufferProcessing(pDevice);
1541 if ((uint16_t)(pDevice->s_Buffer.nStatus & ADC_BUFFER_STATUS_OVERFLOW) != 0u) {
1546 CLR_STATE(ADC_STATUS_BLOCKING_EN);
1549 NVIC_DisableIRQ(ADC0_EVT_IRQn);
1576 uint32_t nRefVoltage,
1577 uint32_t *pnBatVoltage)
1580 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1581 uint16_t nConvTimeBackup;
1582 uint16_t nAvgCfgBackup;
1583 uint32_t nAdcValue = 0u;
1584 uint32_t nClock = 0u;
1585 uint32_t nACLKDIVCNT;
1588 if (pDevice == NULL)
1592 if (pnBatVoltage == NULL)
1597 if (IS_NOT_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN)) {
1601 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN |ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN)) {
1609 nConvTimeBackup = pDevice->pReg->CNV_TIME;
1610 nAvgCfgBackup = pDevice->pReg->AVG_CFG;
1613 nACLKDIVCNT = (*pREG_CLKG0_CLK_CTL1 & BITM_CLKG_CLK_CTL1_ACLKDIVCNT) >> BITP_CLKG_CLK_CTL1_ACLKDIVCNT;
1618 nClock = nClock/nACLKDIVCNT;
1619 pDevice->pReg->CNV_TIME = (uint16_t)((nClock/2000000u) + ((uint16_t)1u));
1620 pDevice->pReg->AVG_CFG = 0u;
1623 pDevice->pReg->STAT = BITM_ADC_STAT_BATDONE;
1626 CLR_STATE(ADC_STATUS_BATTERY_DONE);
1629 pDevice->pReg->CNV_CFG = (BITM_ADC_CNV_CFG_SINGLE | BITM_ADC_CNV_CFG_BAT);
1632 while (IS_NOT_IN_STATE(ADC_STATUS_BATTERY_DONE)) { ; }
1635 pDevice->pReg->CNV_CFG = 0u;
1638 pDevice->pReg->CNV_TIME = nConvTimeBackup;
1639 pDevice->pReg->AVG_CFG = nAvgCfgBackup;
1645 nAdcValue = pDevice->pReg->BAT_OUT;
1646 *pnBatVoltage = (4u * nAdcValue * nRefVoltage) / ADI_ADC_SAMPLE_MAX;
1671 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1674 if (pDevice == NULL)
1680 if (bEnable ==
true)
1682 pDevice->pReg->CFG |= (uint16_t)BITM_ADC_CFG_TMPEN;
1683 SET_STATE(ADC_STATUS_TEMP_SENSOR_EN);
1687 pDevice->pReg->CFG &= (uint16_t)(~BITM_ADC_CFG_TMPEN);
1688 CLR_STATE(ADC_STATUS_TEMP_SENSOR_EN);
1720 uint32_t nRefVoltage,
1721 int32_t* pnTemperature
1725 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *)hDevice;
1726 uint16_t nConvTimeBackup;
1727 uint16_t nAvgCfgBackup;
1728 uint32_t nAdcTmpValue = 0u;
1729 uint32_t nAdcTmp2Value = 0u;
1730 uint32_t nClock = 0u;
1731 uint32_t nACLKDIVCNT;
1735 if (pDevice == NULL)
1739 if (pnTemperature == NULL)
1744 if (IS_NOT_IN_STATE(ADC_STATUS_SUB_SYSTEM_EN | ADC_STATUS_TEMP_SENSOR_EN))
1749 if (IS_IN_ANY_STATE(ADC_STATUS_NON_BLOCKING_EN | ADC_STATUS_BLOCKING_EN | ADC_STATUS_COMPARATOR_EN))
1759 nACLKDIVCNT = (*pREG_CLKG0_CLK_CTL1 & BITM_CLKG_CLK_CTL1_ACLKDIVCNT) >> BITP_CLKG_CLK_CTL1_ACLKDIVCNT;
1760 nCnvTime = ((nClock / nACLKDIVCNT) / (uint16_t)15385u) + 1u;
1763 if (nCnvTime >= 256u) {
1768 nConvTimeBackup = pDevice->pReg->CNV_TIME;
1769 nAvgCfgBackup = pDevice->pReg->AVG_CFG;
1773 pDevice->pReg->CNV_TIME = (uint16_t)((nCnvTime << BITP_ADC_CNV_TIME_SAMPTIME) & BITM_ADC_CNV_TIME_SAMPTIME);
1774 pDevice->pReg->AVG_CFG = 0u;
1777 pDevice->pReg->STAT = BITM_ADC_STAT_TMPDONE | BITM_ADC_STAT_TMP2DONE;
1780 CLR_STATE(ADC_STATUS_TMP_DONE | ADC_STATUS_TMP2_DONE);
1783 pDevice->pReg->CNV_CFG = (BITM_ADC_CNV_CFG_SINGLE | BITM_ADC_CNV_CFG_TMP);
1784 while (IS_NOT_IN_STATE(ADC_STATUS_TMP_DONE)) { ; }
1785 nAdcTmpValue = pDevice->pReg->TMP_OUT;
1786 pDevice->pReg->CNV_CFG = 0u;
1790 pDevice->pReg->CNV_CFG = (BITM_ADC_CNV_CFG_SINGLE | BITM_ADC_CNV_CFG_TMP2);
1791 while (IS_NOT_IN_STATE(ADC_STATUS_TMP2_DONE)) { ; }
1792 pDevice->pReg->CNV_CFG = 0u;
1793 nAdcTmp2Value = pDevice->pReg->TMP2_OUT;
1796 pDevice->pReg->CNV_TIME = nConvTimeBackup;
1797 pDevice->pReg->AVG_CFG = nAvgCfgBackup;
1809 uint32_t nRVirRefByIdealSensitivity = 2070960834u;
1811 uint32_t nTempRG = 19380u;
1812 uint32_t nTmp2 = ((nAdcTmp2Value << 14u) + (nTempRG * nAdcTmpValue));
1814 uint32_t nOffsetPart = (335544320u/nRefVoltage);
1815 uint32_t nOffset = (161u * nOffsetPart);
1817 uint32_t nTmp3 = ((nAdcTmpValue << 12) - nOffset) << 8u;
1818 uint32_t nRatio = (nTmp3/(nTmp2 >> 10u));
1819 uint32_t nTemp = (nRatio * (nRVirRefByIdealSensitivity >> 16u)) >> 5u;
1821 int32_t iTemp = (int32_t)nTemp - ((int32_t)17901158);
1822 *pnTemperature = iTemp;
1838 static uint16_t ReadOutReg(uint32_t nChannelNum)
1840 const volatile uint16_t* pOutRegister = pREG_ADC0_CH0_OUT;
1841 pOutRegister += nChannelNum*2u;
1842 return *pOutRegister;
1846 static bool InitBufferProcessing(ADI_ADC_DEVICE *pDevice)
1848 uint32_t nCnvReg = ((uint32_t)(pDevice->pReg->CNV_CFG) & BITM_ADC_CNV_CFG_DMAEN);
1849 ADC_INT_BUFFER* pIntBuffer = &pDevice->s_Buffer;
1851 if (IS_NOT_IN_ANY_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS))
1854 pDevice->pReg->STAT = 0xFFFFu;
1857 pDevice->pReg->OVF = 0xFFFFu;
1861 nCnvReg |= pIntBuffer->nChannels;
1862 if ((uint16_t)(pIntBuffer->nConfig & ADC_BUFFER_CONFIG_BUFFER_AUTO_MODE_EN) != 0u) {
1863 nCnvReg |= BITM_ADC_CNV_CFG_AUTOMODE;
1865 if ((pIntBuffer->nConfig & ADC_BUFFER_CONFIG_BUFFER_SINGLE_CONV_EN) != 0u) {
1866 nCnvReg |= BITM_ADC_CNV_CFG_SINGLE;
1868 nCnvReg |= BITM_ADC_CNV_CFG_MULTI;
1871 SET_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
1873 pDevice->pReg->CNV_CFG |= (uint16_t)nCnvReg;
1875 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_ENABLED);
1881 #if ADI_ADC_ENABLE_MULTI_ACQUIRE == 1 1883 void DMA_ADC0_Int_Handler (
void)
1886 ADI_ADC_DEVICE *pDevice = (ADI_ADC_DEVICE *) AdcDevInfo[0].hDevice;
1888 DmaFIFOManage(pDevice, ADC_FIFO_MODE_DMA_BUFFER_PROCESS);
1893 static ADI_ADC_RESULT DmaFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode)
1895 uint16_t nCount = 0u;
1896 uint16_t chanNum = ADC0_CHANn;
1897 uint16_t IRQ_Backup;
1899 ADC_INT_BUFFER* pIntBuffer = &pDevice->s_Buffer;
1901 if(pDevice->s_Buffer.pCurDataBuffer == NULL) {
1903 if (eFifoMode == ADC_FIFO_MODE_INTERRUPT_PROCESS) {
1905 uint16_t nStat = pDevice->pReg->STAT & 0x00FFu;
1906 FlushFifo(pDevice, (uint32_t)nStat);
1907 pDevice->pReg->STAT = nStat;
1913 case ADC_FIFO_MODE_INIT:
1916 NVIC_EnableIRQ(DMA0_CH24_DONE_IRQn);
1918 pADI_DMA0->SRCADDR_CLR = 1U << chanNum;
1921 pADI_DMA0->EN_SET = 1U << chanNum;
1924 pADI_DMA0->RMSK_CLR = 1U << chanNum;
1927 pADI_DMA0->ALT_CLR = 1U << chanNum;
1930 nCount = (uint16_t)pIntBuffer->nNumSamplesRemaining;
1933 pPrimaryCCD[chanNum].DMASRCEND = (uint32_t)(&(pDevice->pReg->DMA_OUT));
1936 pPrimaryCCD[chanNum].DMADSTEND = (uint32_t)((
void*)pIntBuffer->pCurDataBuffer) + ((nCount * 2u) - 1u);
1942 ((nCount - (uint32_t)1U)<< DMA_BITP_CTL_N_MINUS_1) |
1943 (DMA_ENUM_CTL_CYCLE_CTL_BASIC << DMA_BITP_CTL_CYCLE_CTL) |
1947 pDevice->pReg->CNV_CFG |= BITM_ADC_CNV_CFG_DMAEN;
1950 case ADC_FIFO_MODE_ENABLED:
1953 case ADC_FIFO_MODE_INTERRUPT_PROCESS:
1955 pDevice->pReg->STAT = (pDevice->pReg->STAT & 0x00FFu);
1958 case ADC_FIFO_MODE_INTERRUPT_OVERFLOW:
1959 pIntBuffer->nStatus |= ADC_BUFFER_STATUS_OVERFLOW;
1962 case ADC_FIFO_MODE_DMA_BUFFER_PROCESS:
1963 pIntBuffer->nNumSamplesRemaining = 0u;
1964 ManageFifoCompletion(pDevice);
1967 case ADC_FIFO_MODE_ABORT:
1970 IRQ_Backup = pDevice->pReg->IRQ_EN;
1973 pDevice->pReg->IRQ_EN = 0u;
1976 pDevice->pReg->CNV_CFG = 0u;
1979 pADI_DMA0->EN_CLR = 1U << chanNum;
1982 pDevice->pReg->STAT = pDevice->pReg->STAT;
1985 CLR_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
1988 FlushFifo(pDevice, 0x00FFu);
1991 pDevice->pReg->IRQ_EN = IRQ_Backup;
2004 static ADI_ADC_RESULT InterruptFIFOManage (ADI_ADC_DEVICE *pDevice, ADC_FIFO_MODE eFifoMode)
2006 ADC_INT_BUFFER* pIntBuffer = &pDevice->s_Buffer;
2008 if(pDevice->s_Buffer.pCurDataBuffer == NULL) {
2009 if (eFifoMode == ADC_FIFO_MODE_INTERRUPT_PROCESS) {
2010 uint16_t nStat = pDevice->pReg->STAT & 0x00FFu;
2011 FlushFifo(pDevice, (uint32_t)nStat);
2012 pDevice->pReg->STAT = nStat;
2019 case ADC_FIFO_MODE_INIT:
2022 pDevice->ActData.nCurChannel = 0u;
2026 case ADC_FIFO_MODE_ENABLED:
2029 case ADC_FIFO_MODE_INTERRUPT_PROCESS:
2031 while (pIntBuffer->nNumSamplesRemaining > 0u) {
2032 uint32_t nConvStatus = ((uint32_t)pDevice->pReg->STAT & (uint32_t)0x00FFu);
2033 if ((nConvStatus & 0x00FFu) == 0u)
2038 uint32_t nCurChannelBitM = ((uint32_t)1u << pDevice->ActData.nCurChannel);
2039 while ((nCurChannelBitM & nConvStatus) == 0u) {
2040 pDevice->ActData.nCurChannel++;
2041 if (pDevice->ActData.nCurChannel >= NUM_ADC_CHANNELS) {
2042 pDevice->ActData.nCurChannel = 0u;
2044 nCurChannelBitM = ((uint32_t)1u << pDevice->ActData.nCurChannel);
2047 assert ((pIntBuffer->nChannels & ((uint32_t)1u << pDevice->ActData.nCurChannel)) != 0u);
2049 *pIntBuffer->pCurDataBuffer = ReadOutReg( pDevice->ActData.nCurChannel);
2050 pIntBuffer->pCurDataBuffer++;
2053 pDevice->pReg->STAT = (uint16_t)nCurChannelBitM;
2054 pIntBuffer->nNumSamplesRemaining -= 1u;
2056 pDevice->ActData.nCurChannel += 1u;
2057 if ( pDevice->ActData.nCurChannel >= NUM_ADC_CHANNELS) {
2058 pDevice->ActData.nCurChannel = 0u;
2062 if (pIntBuffer->nNumSamplesRemaining == 0u) {
2063 ManageFifoCompletion(pDevice);
2068 case ADC_FIFO_MODE_INTERRUPT_OVERFLOW:
2070 pIntBuffer->nStatus |= ADC_BUFFER_STATUS_OVERFLOW;
2074 case ADC_FIFO_MODE_ABORT:
2076 uint16_t IRQ_Backup;
2079 IRQ_Backup = pDevice->pReg->IRQ_EN;
2082 pDevice->pReg->IRQ_EN = 0u;
2085 pDevice->pReg->CNV_CFG = 0u;
2088 pDevice->pReg->STAT = pDevice->pReg->STAT;
2091 CLR_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
2094 FlushFifo(pDevice, 0x00FFu);
2097 pDevice->pReg->IRQ_EN = IRQ_Backup;
2109 static void FlushFifo(ADI_ADC_DEVICE *pDevice, uint32_t nChannels)
2112 for (x = 0u; x < 8u; x++) {
2113 if ((nChannels & ((uint32_t)1u << x)) != 0u) {
2121 static void ManageFifoCompletion(ADI_ADC_DEVICE *pDevice)
2124 pDevice->pReg->CNV_CFG = 0u;
2125 CLR_STATE(ADC_STATUS_SAMPLING_IN_PROGRESS);
2133 static uint32_t GetNumChannels(uint32_t nChannels)
2135 uint32_t n = nChannels & 0x000000FFu;
2137 n = (n & 0x00000055u) + ((n >> 1u) & 0x00000055u);
2138 n = (n & 0x00000033u) + ((n >> 2u) & 0x00000033u);
2139 n = (n + (n >> 4u)) & (0x0000000Fu);
2149 uint32_t nChannel = (uint32_t)eChannel & 0x000000FFu;
2151 if ((nChannel & (nChannel - (uint32_t)1u)) != 0u) {
2154 if ((nChannel & 0x000000AAu) != 0u) { retVal += 1; }
2155 if ((nChannel & 0x000000CCu) != 0u) { retVal += 2; }
2156 if ((nChannel & 0x000000F0u) != 0u) { retVal += 4; }
2162 static void StaticConfiguration(ADI_ADC_DEVICE *pDevice)
2164 uint16_t nCfgReg = 0u;
2167 #if ADI_ADC_CFG_RESOLUTION == 12 2168 pDevice->pReg->AVG_CFG = 0u;
2171 #if ADI_ADC_CFG_RESOLUTION == 13 2172 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0002u << BITP_ADC_AVG_CFG_FACTOR);
2173 #elif ADI_ADC_CFG_RESOLUTION == 14 2174 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0008u << BITP_ADC_AVG_CFG_FACTOR);
2175 #elif ADI_ADC_CFG_RESOLUTION == 15 2176 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0020u << BITP_ADC_AVG_CFG_FACTOR);
2177 #elif ADI_ADC_CFG_RESOLUTION == 16 2178 pDevice->pReg->AVG_CFG = BITM_ADC_AVG_CFG_OS | BITM_ADC_AVG_CFG_EN | (0x0080u << BITP_ADC_AVG_CFG_FACTOR);
2180 #error "Invalid Resolution" 2183 SET_STATE(ADC_STATUS_OVERSAMPLING_EN);
2187 #if ADI_ADC_CFG_VREF == 0 2188 nCfgReg |= BITM_ADC_CFG_REFBUFEN | BITM_ADC_CFG_VREFSEL;
2189 #elif ADI_ADC_CFG_VREF == 1 2190 nCfgReg |= BITM_ADC_CFG_REFBUFEN;
2191 #elif ADI_ADC_CFG_VREF == 2 2192 nCfgReg |= BITM_ADC_CFG_VREFVBAT;
2195 pDevice->pReg->CFG = nCfgReg;
2197 #if ADI_ADC_ENABLE_STATIC_COMPARATOR == 1 2199 #if ADI_ADC_COMPARATOR_AIN0_HI_EN == 1 2203 #if ADI_ADC_COMPARATOR_AIN1_HI_EN == 1 2207 #if ADI_ADC_COMPARATOR_AIN2_HI_EN == 1 2211 #if ADI_ADC_COMPARATOR_AIN3_HI_EN == 1 2216 #if ADI_ADC_COMPARATOR_AIN0_LO_EN == 1 2220 #if ADI_ADC_COMPARATOR_AIN1_LO_EN == 1 2224 #if ADI_ADC_COMPARATOR_AIN2_LO_EN == 1 2228 #if ADI_ADC_COMPARATOR_AIN3_LO_EN == 1 2234 #if ADI_ADC_COMPARATOR_AIN0_HYS_EN == 1 2238 #if ADI_ADC_COMPARATOR_AIN1_HYS_EN == 1 2242 #if ADI_ADC_COMPARATOR_AIN2_HYS_EN == 1 2246 #if ADI_ADC_COMPARATOR_AIN3_HYS_EN == 1 2257 static void EnableComparator(ADI_ADC_DEVICE *pDevice,
bool bEnable)
2260 uint16_t nCnvCfg = 0u;
2261 volatile uint16_t* pLO_Register[4] = {pREG_ADC0_LIM0_LO, pREG_ADC0_LIM1_LO, pREG_ADC0_LIM2_LO, pREG_ADC0_LIM3_LO};
2262 volatile uint16_t* pHI_Register[4] = {pREG_ADC0_LIM0_HI, pREG_ADC0_LIM1_HI, pREG_ADC0_LIM2_HI, pREG_ADC0_LIM3_HI};
2263 volatile uint16_t* pHYS_Register[4] = {pREG_ADC0_HYS0, pREG_ADC0_HYS1, pREG_ADC0_HYS2, pREG_ADC0_HYS3};
2265 if (bEnable ==
true)
2268 for (x = 0u; x < NUM_ADC_COMPARATOR_CHANNELS; x++) {
2269 if((pDevice->ComparitorHi & (1u << x)) > 0u) {
2270 *pHI_Register[x] |= BITM_ADC_LIM0_HI_EN;
2272 if((pDevice->ComparitorLo & (1u << x)) > 0u) {
2273 *pLO_Register[x] |= BITM_ADC_LIM0_LO_EN;
2275 if((pDevice->ComparitorHys & (1u << x)) > 0u) {
2276 *pHYS_Register[x] |= BITM_ADC_HYS0_EN;
2279 nCnvCfg = (uint16_t)((uint16_t)pDevice->ComparitorHi | (uint16_t)pDevice->ComparitorLo);
2281 pDevice->pReg->IRQ_EN &= (uint16_t)(~BITM_ADC_IRQ_EN_CNVDONE);
2282 pDevice->pReg->CNV_CFG = (uint16_t)nCnvCfg | (uint16_t)(BITM_ADC_CNV_CFG_MULTI | BITM_ADC_CNV_CFG_AUTOMODE);
2283 SET_STATE(ADC_STATUS_COMPARATOR_EN);
2287 for (x = 0u; x < NUM_ADC_COMPARATOR_CHANNELS; x++) {
2288 *pHI_Register[x] &= (uint16_t)(~(BITM_ADC_LIM0_HI_EN));
2289 *pLO_Register[x] &= (uint16_t)(~(BITM_ADC_LIM0_LO_EN));
2290 *pHYS_Register[x] &= (uint16_t)(~(BITM_ADC_HYS0_EN));
2292 pDevice->pReg->CNV_CFG = 0u;
2293 pDevice->pReg->STAT = pDevice->pReg->STAT & 0x00FFu;
2294 CLR_STATE(ADC_STATUS_COMPARATOR_EN);
2295 pDevice->pReg->IRQ_EN |= BITM_ADC_IRQ_EN_CNVDONE;
2309 #if defined(__ADUCM302x__) 2310 void ADC_Int_Handler(
void)
2312 void ADC0_Int_Handler(
void)
2315 ADI_ADC_DEVICE *pDevice;
2318 pDevice = (ADI_ADC_DEVICE *) AdcDevInfo[0].hDevice;
2320 if ((pDevice->pReg->STAT & 0x00FFu) != 0u) {
2321 if (IS_NOT_IN_STATE(ADC_STATUS_COMPARATOR_EN)) {
2322 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INTERRUPT_PROCESS);
2324 pDevice->pReg->STAT = pDevice->pReg->STAT & (0x00FFu);
2327 if ((uint16_t)(pDevice->pReg->STAT & 0xFF00u) != 0u) {
2328 if ((pDevice->pReg->STAT & BITM_ADC_STAT_RDY) != 0u) {
2329 SET_STATE(ADC_STATUS_SUB_SYSTEM_READY);
2330 pDevice->pReg->STAT = BITM_ADC_STAT_RDY;
2331 if (pDevice->pfCallback != NULL) {
2335 if ((pDevice->pReg->STAT & BITM_ADC_STAT_CALDONE) != 0u) {
2336 SET_STATE(ADC_STATUS_CALIBRATION_DONE);
2337 pDevice->pReg->STAT = BITM_ADC_STAT_CALDONE;
2338 if (pDevice->pfCallback != NULL) {
2342 if ((pDevice->pReg->STAT & BITM_ADC_STAT_BATDONE) != 0u) {
2343 SET_STATE(ADC_STATUS_BATTERY_DONE);
2344 pDevice->pReg->STAT = BITM_ADC_STAT_BATDONE;
2347 if ((pDevice->pReg->STAT & BITM_ADC_STAT_TMPDONE) != 0u) {
2348 SET_STATE(ADC_STATUS_TMP_DONE);
2349 pDevice->pReg->STAT = BITM_ADC_STAT_TMPDONE;
2352 if ((pDevice->pReg->STAT & BITM_ADC_STAT_TMP2DONE) != 0u) {
2353 SET_STATE(ADC_STATUS_TMP2_DONE);
2354 pDevice->pReg->STAT = BITM_ADC_STAT_TMP2DONE;
2357 if (pDevice->pReg->OVF) {
2358 uint16_t nOvrFlowValue = pDevice->pReg->OVF;
2359 if (IS_NOT_IN_STATE(ADC_STATUS_COMPARATOR_EN)) {
2360 pDevice->pfManageFifo(pDevice, ADC_FIFO_MODE_INTERRUPT_OVERFLOW);
2362 pDevice->pReg->OVF = nOvrFlowValue;
2364 if (pDevice->pReg->ALERT) {
2365 uint32_t nAlertValue = pDevice->pReg->ALERT;
2367 if (IS_IN_STATE(ADC_STATUS_COMPARATOR_EN) && (pDevice->pfCallback != NULL)) {
2368 for (channel = 0u; channel < (NUM_ADC_COMPARATOR_CHANNELS); channel++) {
2372 if((nAlertValue & (1u << (2u * channel))) > 0u) {
2375 if((nAlertValue & (1u << ((2u * channel) + ((uint32_t)1u)))) > 0u)
2381 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_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. If this function return true, then a call to adi_adc_GetBuffer will not block.
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.