adc.h

Go to the documentation of this file.

/******************************************************************************
 *  Filename:       adc.h
 *
 *  Description:    Prototypes and defines for the ADC API.
 *
 *  Copyright (c) 2024-2025 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1) Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *  2) Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *
 *  3) Neither the name of the copyright holder nor the names of its
 *     contributors may be used to endorse or promote products derived from this
 *     software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************/

#ifndef __ADC_H__
#define __ADC_H__

//*****************************************************************************
//
//
//*****************************************************************************

#include <stdint.h>
#include "../inc/hw_adc.h"
#include "../inc/hw_memmap.h"
#include "../inc/hw_types.h"

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif

//*****************************************************************************
//
// Values
//
//*****************************************************************************

#define ADC_CLOCK_DIVIDER_1 ADC_CTL0_SCLKDIV_DIV_BY_1

#define ADC_CLOCK_DIVIDER_2 ADC_CTL0_SCLKDIV_DIV_BY_2

#define ADC_CLOCK_DIVIDER_4 ADC_CTL0_SCLKDIV_DIV_BY_4

#define ADC_CLOCK_DIVIDER_8 ADC_CTL0_SCLKDIV_DIV_BY_8

#define ADC_CLOCK_DIVIDER_16 ADC_CTL0_SCLKDIV_DIV_BY_16

#define ADC_CLOCK_DIVIDER_24 ADC_CTL0_SCLKDIV_DIV_BY_24

#define ADC_CLOCK_DIVIDER_32 ADC_CTL0_SCLKDIV_DIV_BY_32

#define ADC_CLOCK_DIVIDER_48 ADC_CTL0_SCLKDIV_DIV_BY_48

#define ADC_MODE_SINGLE (0 << ADC_MEMCTL_0_MOD_S)

#define ADC_MODE_DIFFERENTIAL (1 << ADC_MEMCTL_0_MOD_S)

#define ADC_INTERNAL_REFERENCE 0

#define ADC_EXTERNAL_REFERENCE 1

#define ADC_VDDA_REFERENCE 2

#define ADC_FULL_SCALE_RANGE_0V0_3V3 0

#define ADC_FULL_SCALE_RANGE_0V1_3V3 1

#define ADC_FULL_SCALE_RANGE_0V0_3V2 2

#define ADC_FULL_SCALE_RANGE_0V0_1V8 3

#define ADC_POWER_DOWN_POLICY_AUTO ADC_CTL0_PWRDN_AUTO

#define ADC_POWER_DOWN_POLICY_MANUAL ADC_CTL0_PWRDN_MANUAL

#define ADC_SEQUENCE_REPEATSEQUENCE ADC_CTL1_CONSEQ_REPEATSEQUENCE

#define ADC_SEQUENCE_REPEATSINGLE ADC_CTL1_CONSEQ_REPEATSINGLE

#define ADC_SEQUENCE_SEQUENCE ADC_CTL1_CONSEQ_SEQUENCE

#define ADC_SEQUENCE_SINGLE ADC_CTL1_CONSEQ_SINGLE

#define ADC_SAMPLE_MODE_AUTO ADC_CTL1_SAMPMODE_AUTO

#define ADC_SAMPLE_MODE_MANUAL ADC_CTL1_SAMPMODE_MANUAL

#define ADC_TRIGGER_SOURCE_EVENT ADC_CTL1_TRIGSRC_EVENT

#define ADC_TRIGGER_SOURCE_SOFTWARE ADC_CTL1_TRIGSRC_SOFTWARE

#define ADC_TRIGGER_POLICY_AUTO_NEXT ADC_MEMCTL_0_TRIG_AUTO_NEXT

#define ADC_TRIGGER_POLICY_TRIGGER_NEXT ADC_MEMCTL_0_TRIG_TRIGGER_NEXT

#define ADC_INT_MEMRES_15 ADC_INTEVT0BM_MEMRESIFG15

#define ADC_INT_MEMRES_14 ADC_INTEVT0BM_MEMRESIFG14

#define ADC_INT_MEMRES_13 ADC_INTEVT0BM_MEMRESIFG13

#define ADC_INT_MEMRES_12 ADC_INTEVT0BM_MEMRESIFG12

#define ADC_INT_MEMRES_11 ADC_INTEVT0BM_MEMRESIFG11

#define ADC_INT_MEMRES_10 ADC_INTEVT0BM_MEMRESIFG10

#define ADC_INT_MEMRES_09 ADC_INTEVT0BM_MEMRESIFG9

#define ADC_INT_MEMRES_08 ADC_INTEVT0BM_MEMRESIFG8

#define ADC_INT_MEMRES_07 ADC_INTEVT0BM_MEMRESIFG7

#define ADC_INT_MEMRES_06 ADC_INTEVT0BM_MEMRESIFG6

#define ADC_INT_MEMRES_05 ADC_INTEVT0BM_MEMRESIFG5

#define ADC_INT_MEMRES_04 ADC_INTEVT0BM_MEMRESIFG4

#define ADC_INT_MEMRES_03 ADC_INTEVT0BM_MEMRESIFG3

#define ADC_INT_MEMRES_02 ADC_INTEVT0BM_MEMRESIFG2

#define ADC_INT_MEMRES_01 ADC_INTEVT0BM_MEMRESIFG1

#define ADC_INT_MEMRES_00 ADC_INTEVT0BM_MEMRESIFG0

#define ADC_INT_UVIFG ADC_INTEVT0BM_UVIFG

#define ADC_INT_DMADONE ADC_INTEVT0BM_DMADONE

#define ADC_INT_INIFG ADC_INTEVT0BM_INIFG

#define ADC_INT_LOWIFG ADC_INTEVT0BM_LOFG

#define ADC_INT_HIGHIFG ADC_INTEVT0BM_HIFG

#define ADC_INT_TOVIFG ADC_INTEVT0BM_TOVIFG

#define ADC_INT_OVIFG ADC_INTEVT0BM_OVIFG

#define ADC_INT_ALL                                                                                        \
    (ADC_INT_OVIFG | ADC_INT_TOVIFG | ADC_INT_HIGHIFG | ADC_INT_LOWIFG | ADC_INT_INIFG | ADC_INT_DMADONE | \
     ADC_INT_UVIFG | ADC_INT_MEMRES_00 | ADC_INT_MEMRES_01 | ADC_INT_MEMRES_02 | ADC_INT_MEMRES_03 |       \
     ADC_INT_MEMRES_04 | ADC_INT_MEMRES_05 | ADC_INT_MEMRES_06 | ADC_INT_MEMRES_07 | ADC_INT_MEMRES_08 |   \
     ADC_INT_MEMRES_09 | ADC_INT_MEMRES_10 | ADC_INT_MEMRES_11 | ADC_INT_MEMRES_12 | ADC_INT_MEMRES_13 |   \
     ADC_INT_MEMRES_14 | ADC_INT_MEMRES_15)

//*****************************************************************************
//
//
//*****************************************************************************
#define ADC_SAMPLE_CLK_NONE            0
#define ADC_SAMPLE_CLK_SOC_CLK         1
#define ADC_SAMPLE_CLK_HFXT            2
#define ADC_SAMPLE_CLK_SOC_PLL_CLK_DIV 3

//*****************************************************************************
//
// API Functions and prototypes
//
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetSampleDuration(uint32_t clkDiv, uint16_t clkCycles);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetInput(uint32_t reference, uint8_t channel, uint8_t fullScaleRange, uint32_t index);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetMemctlRange(uint32_t start, uint32_t stop);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetPowerDownPolicy(uint32_t powerDownPolicy);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetSequence(uint32_t sequence);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetSamplingClk(uint32_t clkSrc);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetSamplingMode(uint32_t samplingMode);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetTriggerSource(uint32_t triggerSource);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetTriggerPolicy(uint32_t triggerPolicy, uint32_t index);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCStartConversion(void)
{
    HWREG(ADC_BASE + ADC_O_CTL1) |= ADC_CTL1_SC_START;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCStopConversion(void)
{
    HWREG(ADC_BASE + ADC_O_CTL1) &= ~ADC_CTL1_SC_M;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCEnableConversion(void)
{
    HWREG(ADC_BASE + ADC_O_CTL0) |= ADC_CTL0_ENC_ON;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCDisableConversion(void)
{
    HWREG(ADC_BASE + ADC_O_CTL0) &= ~ADC_CTL0_ENC_M;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCEnableDmaTrigger(void)
{
    HWREG(ADC_BASE + ADC_O_CTL2) |= ADC_CTL2_DMAEN_ENABLE;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCDisableDmaTrigger(void)
{
    HWREG(ADC_BASE + ADC_O_CTL2) &= ~ADC_CTL2_DMAEN_M;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t ADCReadResult(uint32_t index)
{

    while (HWREG(ADC_BASE + ADC_O_STA) & ADC_STA_BUSY_ACTIVE) {}

    // Return data from result register
    return HWREG(ADC_BASE + ADC_O_MEMRES_0 + (4 * index));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE bool ADCIsBusy(void)
{

    if (HWREG(ADC_BASE + ADC_O_STA) & ADC_STA_BUSY_ACTIVE)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t ADCReadResultNonBlocking(uint32_t index)
{
    // Return data from result register
    return HWREG(ADC_BASE + ADC_O_MEMRES_0 + (4 * index));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t ADCValueToMicrovolts(uint32_t adcCode, uint32_t fullScaleRange);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCEnableInterrupt(uint32_t intFlags)
{
    // Enable the specified interrupts.
    HWREG(ADC_BASE + ADC_O_INTEVT0BM) |= intFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCDisableInterrupt(uint32_t intFlags)
{
    // Disable the specified interrupts.
    HWREG(ADC_BASE + ADC_O_INTEVT0BM) &= ~(intFlags);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t ADCRawInterruptStatus(void)
{
    return (HWREG(ADC_BASE + ADC_O_INTEVT0RIS));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t ADCMaskedInterruptStatus(void)
{
    return (HWREG(ADC_BASE + ADC_O_INTEVT0MIS));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void ADCClearInterrupt(uint32_t intFlags)
{
    // Clear the requested interrupt sources
    HWREG(ADC_BASE + ADC_O_INTEVT0CLR) = intFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCStoreTrims(void);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCRestoreTrims(void);

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

//*****************************************************************************
//
//
//*****************************************************************************

#endif //  __ADC_H__