adc.h

Go to the documentation of this file.

/******************************************************************************
 *  Filename:       adc.h
 *
 *  Description:    Prototypes and defines for the ADC API.
 *
 *  Copyright (c) 2022-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_fcfg.h"
#include "../inc/hw_memmap.h"
#include "../inc/hw_sys0.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_RESOLUTION_12_BIT ADC_CTL2_RES_BIT_12

#define ADC_RESOLUTION_10_BIT ADC_CTL2_RES_BIT_10

#define ADC_RESOLUTION_8_BIT ADC_CTL2_RES_BIT_8

#define ADC_FIXED_REFERENCE_1V4 0

#define ADC_FIXED_REFERENCE_2V5 1

#define ADC_EXTERNAL_REFERENCE 2

#define ADC_VDDS_REFERENCE 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_MEMCTL0_TRG_AUTO_NEXT

#define ADC_TRIGGER_POLICY_TRIGGER_NEXT ADC_MEMCTL0_TRG_TRIGGER_NEXT

#define ADC_INT_MEMRES_23 ADC_IMASK0_MEMRESIFG23

#define ADC_INT_MEMRES_22 ADC_IMASK0_MEMRESIFG22

#define ADC_INT_MEMRES_21 ADC_IMASK0_MEMRESIFG21

#define ADC_INT_MEMRES_20 ADC_IMASK0_MEMRESIFG20

#define ADC_INT_MEMRES_19 ADC_IMASK0_MEMRESIFG19

#define ADC_INT_MEMRES_18 ADC_IMASK0_MEMRESIFG18

#define ADC_INT_MEMRES_17 ADC_IMASK0_MEMRESIFG17

#define ADC_INT_MEMRES_16 ADC_IMASK0_MEMRESIFG16

#define ADC_INT_MEMRES_15 ADC_IMASK0_MEMRESIFG15

#define ADC_INT_MEMRES_14 ADC_IMASK0_MEMRESIFG14

#define ADC_INT_MEMRES_13 ADC_IMASK0_MEMRESIFG13

#define ADC_INT_MEMRES_12 ADC_IMASK0_MEMRESIFG12

#define ADC_INT_MEMRES_11 ADC_IMASK0_MEMRESIFG11

#define ADC_INT_MEMRES_10 ADC_IMASK0_MEMRESIFG10

#define ADC_INT_MEMRES_09 ADC_IMASK0_MEMRESIFG9

#define ADC_INT_MEMRES_08 ADC_IMASK0_MEMRESIFG8

#define ADC_INT_MEMRES_07 ADC_IMASK0_MEMRESIFG7

#define ADC_INT_MEMRES_06 ADC_IMASK0_MEMRESIFG6

#define ADC_INT_MEMRES_05 ADC_IMASK0_MEMRESIFG5

#define ADC_INT_MEMRES_04 ADC_IMASK0_MEMRESIFG4

#define ADC_INT_MEMRES_03 ADC_IMASK0_MEMRESIFG3

#define ADC_INT_MEMRES_02 ADC_IMASK0_MEMRESIFG2

#define ADC_INT_MEMRES_01 ADC_IMASK0_MEMRESIFG1

#define ADC_INT_MEMRES_00 ADC_IMASK0_MEMRESIFG0

#define ADC_INT_ASCDONE ADC_IMASK0_ASCDONE

#define ADC_INT_UVIFG ADC_IMASK0_UVIFG

#define ADC_INT_DMADONE ADC_IMASK0_DMADONE

#define ADC_INT_INIFG ADC_IMASK0_INIFG

#define ADC_INT_LOWIFG ADC_IMASK0_LOWIFG

#define ADC_INT_HIGHIFG ADC_IMASK0_HIGHIFG

#define ADC_INT_TOVIFG ADC_IMASK0_TOVIFG

#define ADC_INT_OVIFG ADC_IMASK0_OVIFG

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

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

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetResolution(uint32_t resolution);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetInput(uint32_t reference, uint8_t channel, 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 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_EN;
}

//*****************************************************************************
//
//
//*****************************************************************************
__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_MEMRES0 + (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_MEMRES0 + (4 * index));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t ADCValueToMicrovolts(uint32_t adcCode, uint32_t bitResolution, uint32_t referenceVoltageMicroVolt);

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

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

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

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

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

//*****************************************************************************
//
//
//*****************************************************************************
extern uint16_t ADCGetAdjustmentGain(uint32_t reference);

//*****************************************************************************
//
//
//*****************************************************************************
extern void ADCSetAdjustmentOffset(uint32_t reference);

//*****************************************************************************
//
//
//*****************************************************************************
extern uint32_t ADCAdjustValueForGain(uint32_t adcValue, uint32_t bitResolution, uint16_t gain);

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

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

#endif //  __ADC_H__