/* --COPYRIGHT--,BSD * Copyright (c) 2014, Texas Instruments Incorporated * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * * 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. * * * Neither the name of Texas Instruments Incorporated 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 OWNER 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. * --/COPYRIGHT--*/ //***************************************************************************** // // adc12_b.h - Driver for the ADC12_B Module. // //***************************************************************************** #ifndef __MSP430WARE_ADC12_B_H__ #define __MSP430WARE_ADC12_B_H__ #include "inc/hw_memmap.h" #ifdef __MSP430_HAS_ADC12_B__ //***************************************************************************** // // If building with a C++ compiler, make all of the definitions in this header // have a C binding. // //***************************************************************************** #ifdef __cplusplus extern "C" { #endif #include "inc/hw_regaccess.h" //***************************************************************************** // //! \brief Used in the ADC12_B_init() function as the param parameter. // //***************************************************************************** typedef struct ADC12_B_initParam { //! Is the signal that will trigger a sample-and-hold for an input signal //! to be converted. //! \n Valid values are: //! - \b ADC12_B_SAMPLEHOLDSOURCE_SC [Default] //! - \b ADC12_B_SAMPLEHOLDSOURCE_1 //! - \b ADC12_B_SAMPLEHOLDSOURCE_2 //! - \b ADC12_B_SAMPLEHOLDSOURCE_3 //! - \b ADC12_B_SAMPLEHOLDSOURCE_4 //! - \b ADC12_B_SAMPLEHOLDSOURCE_5 //! - \b ADC12_B_SAMPLEHOLDSOURCE_6 //! - \b ADC12_B_SAMPLEHOLDSOURCE_7 uint16_t sampleHoldSignalSourceSelect; //! Selects the clock that will be used by the ADC12B core, and the //! sampling timer if a sampling pulse mode is enabled. //! \n Valid values are: //! - \b ADC12_B_CLOCKSOURCE_ADC12OSC [Default] //! - \b ADC12_B_CLOCKSOURCE_ACLK //! - \b ADC12_B_CLOCKSOURCE_MCLK //! - \b ADC12_B_CLOCKSOURCE_SMCLK uint8_t clockSourceSelect; //! Selects the amount that the clock will be divided. //! \n Valid values are: //! - \b ADC12_B_CLOCKDIVIDER_1 [Default] //! - \b ADC12_B_CLOCKDIVIDER_2 //! - \b ADC12_B_CLOCKDIVIDER_3 //! - \b ADC12_B_CLOCKDIVIDER_4 //! - \b ADC12_B_CLOCKDIVIDER_5 //! - \b ADC12_B_CLOCKDIVIDER_6 //! - \b ADC12_B_CLOCKDIVIDER_7 //! - \b ADC12_B_CLOCKDIVIDER_8 uint16_t clockSourceDivider; //! Selects the amount that the clock will be predivided. //! \n Valid values are: //! - \b ADC12_B_CLOCKPREDIVIDER__1 [Default] //! - \b ADC12_B_CLOCKPREDIVIDER__4 //! - \b ADC12_B_CLOCKPREDIVIDER__32 //! - \b ADC12_B_CLOCKPREDIVIDER__64 uint16_t clockSourcePredivider; //! Selects what internal channel to map for ADC input channels //! \n Valid values are: //! - \b ADC12_B_MAPINTCH3 //! - \b ADC12_B_MAPINTCH2 //! - \b ADC12_B_MAPINTCH1 //! - \b ADC12_B_MAPINTCH0 //! - \b ADC12_B_TEMPSENSEMAP //! - \b ADC12_B_BATTMAP //! - \b ADC12_B_NOINTCH uint16_t internalChannelMap; } ADC12_B_initParam; //***************************************************************************** // //! \brief Used in the ADC12_B_configureMemory() function as the param //! parameter. // //***************************************************************************** typedef struct ADC12_B_configureMemoryParam { //! Is the selected memory buffer to set the configuration for. //! \n Valid values are: //! - \b ADC12_B_MEMORY_0 //! - \b ADC12_B_MEMORY_1 //! - \b ADC12_B_MEMORY_2 //! - \b ADC12_B_MEMORY_3 //! - \b ADC12_B_MEMORY_4 //! - \b ADC12_B_MEMORY_5 //! - \b ADC12_B_MEMORY_6 //! - \b ADC12_B_MEMORY_7 //! - \b ADC12_B_MEMORY_8 //! - \b ADC12_B_MEMORY_9 //! - \b ADC12_B_MEMORY_10 //! - \b ADC12_B_MEMORY_11 //! - \b ADC12_B_MEMORY_12 //! - \b ADC12_B_MEMORY_13 //! - \b ADC12_B_MEMORY_14 //! - \b ADC12_B_MEMORY_15 //! - \b ADC12_B_MEMORY_16 //! - \b ADC12_B_MEMORY_17 //! - \b ADC12_B_MEMORY_18 //! - \b ADC12_B_MEMORY_19 //! - \b ADC12_B_MEMORY_20 //! - \b ADC12_B_MEMORY_21 //! - \b ADC12_B_MEMORY_22 //! - \b ADC12_B_MEMORY_23 //! - \b ADC12_B_MEMORY_24 //! - \b ADC12_B_MEMORY_25 //! - \b ADC12_B_MEMORY_26 //! - \b ADC12_B_MEMORY_27 //! - \b ADC12_B_MEMORY_28 //! - \b ADC12_B_MEMORY_29 //! - \b ADC12_B_MEMORY_30 //! - \b ADC12_B_MEMORY_31 uint8_t memoryBufferControlIndex; //! Is the input that will store the converted data into the specified //! memory buffer. //! \n Valid values are: //! - \b ADC12_B_INPUT_A0 [Default] //! - \b ADC12_B_INPUT_A1 //! - \b ADC12_B_INPUT_A2 //! - \b ADC12_B_INPUT_A3 //! - \b ADC12_B_INPUT_A4 //! - \b ADC12_B_INPUT_A5 //! - \b ADC12_B_INPUT_A6 //! - \b ADC12_B_INPUT_A7 //! - \b ADC12_B_INPUT_A8 //! - \b ADC12_B_INPUT_A9 //! - \b ADC12_B_INPUT_A10 //! - \b ADC12_B_INPUT_A11 //! - \b ADC12_B_INPUT_A12 //! - \b ADC12_B_INPUT_A13 //! - \b ADC12_B_INPUT_A14 //! - \b ADC12_B_INPUT_A15 //! - \b ADC12_B_INPUT_A16 //! - \b ADC12_B_INPUT_A17 //! - \b ADC12_B_INPUT_A18 //! - \b ADC12_B_INPUT_A19 //! - \b ADC12_B_INPUT_A20 //! - \b ADC12_B_INPUT_A21 //! - \b ADC12_B_INPUT_A22 //! - \b ADC12_B_INPUT_A23 //! - \b ADC12_B_INPUT_A24 //! - \b ADC12_B_INPUT_A25 //! - \b ADC12_B_INPUT_A26 //! - \b ADC12_B_INPUT_A27 //! - \b ADC12_B_INPUT_A28 //! - \b ADC12_B_INPUT_A29 //! - \b ADC12_B_INPUT_TCMAP //! - \b ADC12_B_INPUT_BATMAP uint8_t inputSourceSelect; //! Is the reference voltage source to set as the upper/lower limits for //! the conversion stored in the specified memory. //! \n Valid values are: //! - \b ADC12_B_VREFPOS_AVCC_VREFNEG_VSS [Default] //! - \b ADC12_B_VREFPOS_INTBUF_VREFNEG_VSS //! - \b ADC12_B_VREFPOS_EXTNEG_VREFNEG_VSS //! - \b ADC12_B_VREFPOS_EXTBUF_VREFNEG_VSS //! - \b ADC12_B_VREFPOS_EXTPOS_VREFNEG_VSS //! - \b ADC12_B_VREFPOS_AVCC_VREFNEG_EXTBUF //! - \b ADC12_B_VREFPOS_AVCC_VREFNEG_EXTPOS //! - \b ADC12_B_VREFPOS_INTBUF_VREFNEG_EXTPOS //! - \b ADC12_B_VREFPOS_AVCC_VREFNEG_INTBUF //! - \b ADC12_B_VREFPOS_EXTPOS_VREFNEG_INTBUF //! - \b ADC12_B_VREFPOS_AVCC_VREFNEG_EXTNEG //! - \b ADC12_B_VREFPOS_INTBUF_VREFNEG_EXTNEG //! - \b ADC12_B_VREFPOS_EXTPOS_VREFNEG_EXTNEG //! - \b ADC12_B_VREFPOS_EXTBUF_VREFNEG_EXTNEG uint16_t refVoltageSourceSelect; //! Indicates that the specified memory buffer will be the end of the //! sequence if a sequenced conversion mode is selected //! \n Valid values are: //! - \b ADC12_B_NOTENDOFSEQUENCE [Default] //! - \b ADC12_B_ENDOFSEQUENCE uint16_t endOfSequence; //! Sets the window comparator mode //! \n Valid values are: //! - \b ADC12_B_WINDOW_COMPARATOR_DISABLE [Default] //! - \b ADC12_B_WINDOW_COMPARATOR_ENABLE uint16_t windowComparatorSelect; //! Sets the differential mode //! \n Valid values are: //! - \b ADC12_B_DIFFERENTIAL_MODE_DISABLE [Default] //! - \b ADC12_B_DIFFERENTIAL_MODE_ENABLE uint16_t differentialModeSelect; } ADC12_B_configureMemoryParam; //***************************************************************************** // // The following are values that can be passed to the clockSourceDivider // parameter for functions: ADC12_B_init(); the param parameter for functions: // ADC12_B_init(). // //***************************************************************************** #define ADC12_B_CLOCKDIVIDER_1 (ADC12DIV_0) #define ADC12_B_CLOCKDIVIDER_2 (ADC12DIV_1) #define ADC12_B_CLOCKDIVIDER_3 (ADC12DIV_2) #define ADC12_B_CLOCKDIVIDER_4 (ADC12DIV_3) #define ADC12_B_CLOCKDIVIDER_5 (ADC12DIV_4) #define ADC12_B_CLOCKDIVIDER_6 (ADC12DIV_5) #define ADC12_B_CLOCKDIVIDER_7 (ADC12DIV_6) #define ADC12_B_CLOCKDIVIDER_8 (ADC12DIV_7) //***************************************************************************** // // The following are values that can be passed to the clockSourceSelect // parameter for functions: ADC12_B_init(); the param parameter for functions: // ADC12_B_init(). // //***************************************************************************** #define ADC12_B_CLOCKSOURCE_ADC12OSC (ADC12SSEL_0) #define ADC12_B_CLOCKSOURCE_ACLK (ADC12SSEL_1) #define ADC12_B_CLOCKSOURCE_MCLK (ADC12SSEL_2) #define ADC12_B_CLOCKSOURCE_SMCLK (ADC12SSEL_3) //***************************************************************************** // // The following are values that can be passed to the clockSourcePredivider // parameter for functions: ADC12_B_init(); the param parameter for functions: // ADC12_B_init(). // //***************************************************************************** #define ADC12_B_CLOCKPREDIVIDER__1 (ADC12PDIV__1) #define ADC12_B_CLOCKPREDIVIDER__4 (ADC12PDIV__4) #define ADC12_B_CLOCKPREDIVIDER__32 (ADC12PDIV__32) #define ADC12_B_CLOCKPREDIVIDER__64 (ADC12PDIV__64) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: ADC12_B_init(); the sampleHoldSignalSourceSelect parameter for // functions: ADC12_B_init(). // //***************************************************************************** #define ADC12_B_SAMPLEHOLDSOURCE_SC (ADC12SHS_0) #define ADC12_B_SAMPLEHOLDSOURCE_1 (ADC12SHS_1) #define ADC12_B_SAMPLEHOLDSOURCE_2 (ADC12SHS_2) #define ADC12_B_SAMPLEHOLDSOURCE_3 (ADC12SHS_3) #define ADC12_B_SAMPLEHOLDSOURCE_4 (ADC12SHS_4) #define ADC12_B_SAMPLEHOLDSOURCE_5 (ADC12SHS_5) #define ADC12_B_SAMPLEHOLDSOURCE_6 (ADC12SHS_6) #define ADC12_B_SAMPLEHOLDSOURCE_7 (ADC12SHS_7) //***************************************************************************** // // The following are values that can be passed to the internalChannelMap // parameter for functions: ADC12_B_init(); the param parameter for functions: // ADC12_B_init(). // //***************************************************************************** #define ADC12_B_MAPINTCH3 (ADC12ICH3MAP) #define ADC12_B_MAPINTCH2 (ADC12ICH2MAP) #define ADC12_B_MAPINTCH1 (ADC12ICH1MAP) #define ADC12_B_MAPINTCH0 (ADC12ICH0MAP) #define ADC12_B_TEMPSENSEMAP (ADC12TCMAP) #define ADC12_B_BATTMAP (ADC12BATMAP) #define ADC12_B_NOINTCH (0x00) //***************************************************************************** // // The following are values that can be passed to the clockCycleHoldCountLowMem // parameter for functions: ADC12_B_setupSamplingTimer(); the // clockCycleHoldCountHighMem parameter for functions: // ADC12_B_setupSamplingTimer(). // //***************************************************************************** #define ADC12_B_CYCLEHOLD_4_CYCLES (ADC12SHT0_0) #define ADC12_B_CYCLEHOLD_8_CYCLES (ADC12SHT0_1) #define ADC12_B_CYCLEHOLD_16_CYCLES (ADC12SHT0_2) #define ADC12_B_CYCLEHOLD_32_CYCLES (ADC12SHT0_3) #define ADC12_B_CYCLEHOLD_64_CYCLES (ADC12SHT0_4) #define ADC12_B_CYCLEHOLD_96_CYCLES (ADC12SHT0_5) #define ADC12_B_CYCLEHOLD_128_CYCLES (ADC12SHT0_6) #define ADC12_B_CYCLEHOLD_192_CYCLES (ADC12SHT0_7) #define ADC12_B_CYCLEHOLD_256_CYCLES (ADC12SHT0_8) #define ADC12_B_CYCLEHOLD_384_CYCLES (ADC12SHT0_9) #define ADC12_B_CYCLEHOLD_512_CYCLES (ADC12SHT0_10) #define ADC12_B_CYCLEHOLD_768_CYCLES (ADC12SHT0_11) #define ADC12_B_CYCLEHOLD_1024_CYCLES (ADC12SHT0_12) //***************************************************************************** // // The following are values that can be passed to the multipleSamplesEnabled // parameter for functions: ADC12_B_setupSamplingTimer(). // //***************************************************************************** #define ADC12_B_MULTIPLESAMPLESDISABLE (!(ADC12MSC)) #define ADC12_B_MULTIPLESAMPLESENABLE (ADC12MSC) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: ADC12_B_configureMemory(). // //***************************************************************************** #define ADC12_B_DIFFERENTIAL_MODE_DISABLE (0x00) #define ADC12_B_DIFFERENTIAL_MODE_ENABLE (ADC12DIF) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: ADC12_B_configureMemory(). // //***************************************************************************** #define ADC12_B_NOTENDOFSEQUENCE (!(ADC12EOS)) #define ADC12_B_ENDOFSEQUENCE (ADC12EOS) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: ADC12_B_configureMemory(). // //***************************************************************************** #define ADC12_B_VREFPOS_AVCC_VREFNEG_VSS (ADC12VRSEL_0) #define ADC12_B_VREFPOS_INTBUF_VREFNEG_VSS (ADC12VRSEL_1) #define ADC12_B_VREFPOS_EXTNEG_VREFNEG_VSS (ADC12VRSEL_2) #define ADC12_B_VREFPOS_EXTBUF_VREFNEG_VSS (ADC12VRSEL_3) #define ADC12_B_VREFPOS_EXTPOS_VREFNEG_VSS (ADC12VRSEL_4) #define ADC12_B_VREFPOS_AVCC_VREFNEG_EXTBUF (ADC12VRSEL_5) #define ADC12_B_VREFPOS_AVCC_VREFNEG_EXTPOS (ADC12VRSEL_6) #define ADC12_B_VREFPOS_INTBUF_VREFNEG_EXTPOS (ADC12VRSEL_7) #define ADC12_B_VREFPOS_AVCC_VREFNEG_INTBUF (ADC12VRSEL_9) #define ADC12_B_VREFPOS_EXTPOS_VREFNEG_INTBUF (ADC12VRSEL_11) #define ADC12_B_VREFPOS_AVCC_VREFNEG_EXTNEG (ADC12VRSEL_12) #define ADC12_B_VREFPOS_INTBUF_VREFNEG_EXTNEG (ADC12VRSEL_13) #define ADC12_B_VREFPOS_EXTPOS_VREFNEG_EXTNEG (ADC12VRSEL_14) #define ADC12_B_VREFPOS_EXTBUF_VREFNEG_EXTNEG (ADC12VRSEL_15) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: ADC12_B_configureMemory(). // //***************************************************************************** #define ADC12_B_INPUT_A0 (ADC12INCH_0) #define ADC12_B_INPUT_A1 (ADC12INCH_1) #define ADC12_B_INPUT_A2 (ADC12INCH_2) #define ADC12_B_INPUT_A3 (ADC12INCH_3) #define ADC12_B_INPUT_A4 (ADC12INCH_4) #define ADC12_B_INPUT_A5 (ADC12INCH_5) #define ADC12_B_INPUT_A6 (ADC12INCH_6) #define ADC12_B_INPUT_A7 (ADC12INCH_7) #define ADC12_B_INPUT_A8 (ADC12INCH_8) #define ADC12_B_INPUT_A9 (ADC12INCH_9) #define ADC12_B_INPUT_A10 (ADC12INCH_10) #define ADC12_B_INPUT_A11 (ADC12INCH_11) #define ADC12_B_INPUT_A12 (ADC12INCH_12) #define ADC12_B_INPUT_A13 (ADC12INCH_13) #define ADC12_B_INPUT_A14 (ADC12INCH_14) #define ADC12_B_INPUT_A15 (ADC12INCH_15) #define ADC12_B_INPUT_A16 (ADC12INCH_16) #define ADC12_B_INPUT_A17 (ADC12INCH_17) #define ADC12_B_INPUT_A18 (ADC12INCH_18) #define ADC12_B_INPUT_A19 (ADC12INCH_19) #define ADC12_B_INPUT_A20 (ADC12INCH_20) #define ADC12_B_INPUT_A21 (ADC12INCH_21) #define ADC12_B_INPUT_A22 (ADC12INCH_22) #define ADC12_B_INPUT_A23 (ADC12INCH_23) #define ADC12_B_INPUT_A24 (ADC12INCH_24) #define ADC12_B_INPUT_A25 (ADC12INCH_25) #define ADC12_B_INPUT_A26 (ADC12INCH_26) #define ADC12_B_INPUT_A27 (ADC12INCH_27) #define ADC12_B_INPUT_A28 (ADC12INCH_28) #define ADC12_B_INPUT_A29 (ADC12INCH_29) #define ADC12_B_INPUT_TCMAP (ADC12INCH_30) #define ADC12_B_INPUT_BATMAP (ADC12INCH_31) //***************************************************************************** // // The following are values that can be passed to the param parameter for // functions: ADC12_B_configureMemory(). // //***************************************************************************** #define ADC12_B_WINDOW_COMPARATOR_DISABLE (0x00) #define ADC12_B_WINDOW_COMPARATOR_ENABLE (ADC12WINC) //***************************************************************************** // // The following are values that can be passed to the memoryIndex parameter for // functions: ADC12_B_getMemoryAddressForDMA(); the memoryBufferIndex parameter // for functions: ADC12_B_getResults(); the param parameter for functions: // ADC12_B_configureMemory(). // //***************************************************************************** #define ADC12_B_MEMORY_0 (0x00) #define ADC12_B_MEMORY_1 (0x02) #define ADC12_B_MEMORY_2 (0x04) #define ADC12_B_MEMORY_3 (0x06) #define ADC12_B_MEMORY_4 (0x08) #define ADC12_B_MEMORY_5 (0x0A) #define ADC12_B_MEMORY_6 (0x0C) #define ADC12_B_MEMORY_7 (0x0E) #define ADC12_B_MEMORY_8 (0x10) #define ADC12_B_MEMORY_9 (0x12) #define ADC12_B_MEMORY_10 (0x14) #define ADC12_B_MEMORY_11 (0x16) #define ADC12_B_MEMORY_12 (0x18) #define ADC12_B_MEMORY_13 (0x1A) #define ADC12_B_MEMORY_14 (0x1C) #define ADC12_B_MEMORY_15 (0x1E) #define ADC12_B_MEMORY_16 (0x20) #define ADC12_B_MEMORY_17 (0x22) #define ADC12_B_MEMORY_18 (0x24) #define ADC12_B_MEMORY_19 (0x26) #define ADC12_B_MEMORY_20 (0x28) #define ADC12_B_MEMORY_21 (0x2A) #define ADC12_B_MEMORY_22 (0x2C) #define ADC12_B_MEMORY_23 (0x2E) #define ADC12_B_MEMORY_24 (0x30) #define ADC12_B_MEMORY_25 (0x32) #define ADC12_B_MEMORY_26 (0x34) #define ADC12_B_MEMORY_27 (0x36) #define ADC12_B_MEMORY_28 (0x38) #define ADC12_B_MEMORY_29 (0x3A) #define ADC12_B_MEMORY_30 (0x3C) #define ADC12_B_MEMORY_31 (0x3E) //***************************************************************************** // // The following are values that can be passed to the interruptMask0 parameter // for functions: ADC12_B_enableInterrupt(), and ADC12_B_disableInterrupt(). // //***************************************************************************** #define ADC12_B_IE0 (ADC12IE0) #define ADC12_B_IE1 (ADC12IE1) #define ADC12_B_IE2 (ADC12IE2) #define ADC12_B_IE3 (ADC12IE3) #define ADC12_B_IE4 (ADC12IE4) #define ADC12_B_IE5 (ADC12IE5) #define ADC12_B_IE6 (ADC12IE6) #define ADC12_B_IE7 (ADC12IE7) #define ADC12_B_IE8 (ADC12IE8) #define ADC12_B_IE9 (ADC12IE9) #define ADC12_B_IE10 (ADC12IE10) #define ADC12_B_IE11 (ADC12IE11) #define ADC12_B_IE12 (ADC12IE12) #define ADC12_B_IE13 (ADC12IE13) #define ADC12_B_IE14 (ADC12IE14) #define ADC12_B_IE15 (ADC12IE15) //***************************************************************************** // // The following are values that can be passed to the interruptMask1 parameter // for functions: ADC12_B_enableInterrupt(), and ADC12_B_disableInterrupt(). // //***************************************************************************** #define ADC12_B_IE16 (ADC12IE16) #define ADC12_B_IE17 (ADC12IE17) #define ADC12_B_IE18 (ADC12IE18) #define ADC12_B_IE19 (ADC12IE19) #define ADC12_B_IE20 (ADC12IE20) #define ADC12_B_IE21 (ADC12IE21) #define ADC12_B_IE22 (ADC12IE22) #define ADC12_B_IE23 (ADC12IE23) #define ADC12_B_IE24 (ADC12IE24) #define ADC12_B_IE25 (ADC12IE25) #define ADC12_B_IE26 (ADC12IE26) #define ADC12_B_IE27 (ADC12IE27) #define ADC12_B_IE28 (ADC12IE28) #define ADC12_B_IE29 (ADC12IE29) #define ADC12_B_IE30 (ADC12IE30) #define ADC12_B_IE31 (ADC12IE31) //***************************************************************************** // // The following are values that can be passed to the interruptMask2 parameter // for functions: ADC12_B_enableInterrupt(), and ADC12_B_disableInterrupt(). // //***************************************************************************** #define ADC12_B_INIE (ADC12INIE) #define ADC12_B_LOIE (ADC12LOIE) #define ADC12_B_HIIE (ADC12HIIE) #define ADC12_B_OVIE (ADC12OVIE) #define ADC12_B_TOVIE (ADC12TOVIE) #define ADC12_B_RDYIE (ADC12RDYIE) //***************************************************************************** // // The following are values that can be passed to the memoryInterruptFlagMask // parameter for functions: ADC12_B_clearInterrupt(), and // ADC12_B_getInterruptStatus(). // //***************************************************************************** #define ADC12_B_IFG0 (ADC12IFG0) #define ADC12_B_IFG1 (ADC12IFG1) #define ADC12_B_IFG2 (ADC12IFG2) #define ADC12_B_IFG3 (ADC12IFG3) #define ADC12_B_IFG4 (ADC12IFG4) #define ADC12_B_IFG5 (ADC12IFG5) #define ADC12_B_IFG6 (ADC12IFG6) #define ADC12_B_IFG7 (ADC12IFG7) #define ADC12_B_IFG8 (ADC12IFG8) #define ADC12_B_IFG9 (ADC12IFG9) #define ADC12_B_IFG10 (ADC12IFG10) #define ADC12_B_IFG11 (ADC12IFG11) #define ADC12_B_IFG12 (ADC12IFG12) #define ADC12_B_IFG13 (ADC12IFG13) #define ADC12_B_IFG14 (ADC12IFG14) #define ADC12_B_IFG15 (ADC12IFG15) #define ADC12_B_IFG16 (ADC12IFG16) #define ADC12_B_IFG17 (ADC12IFG17) #define ADC12_B_IFG18 (ADC12IFG18) #define ADC12_B_IFG19 (ADC12IFG19) #define ADC12_B_IFG20 (ADC12IFG20) #define ADC12_B_IFG21 (ADC12IFG21) #define ADC12_B_IFG22 (ADC12IFG22) #define ADC12_B_IFG23 (ADC12IFG23) #define ADC12_B_IFG24 (ADC12IFG24) #define ADC12_B_IFG25 (ADC12IFG25) #define ADC12_B_IFG26 (ADC12IFG26) #define ADC12_B_IFG27 (ADC12IFG27) #define ADC12_B_IFG28 (ADC12IFG28) #define ADC12_B_IFG29 (ADC12IFG29) #define ADC12_B_IFG30 (ADC12IFG30) #define ADC12_B_IFG31 (ADC12IFG31) #define ADC12_B_INIFG (ADC12INIFG) #define ADC12_B_LOIFG (ADC12LOIFG) #define ADC12_B_HIIFG (ADC12HIIFG) #define ADC12_B_OVIFG (ADC12OVIFG) #define ADC12_B_TOVIFG (ADC12TOVIFG) #define ADC12_B_RDYIFG (ADC12RDYIFG) //***************************************************************************** // // The following are values that can be passed to the startingMemoryBufferIndex // parameter for functions: ADC12_B_startConversion(). // //***************************************************************************** #define ADC12_B_START_AT_ADC12MEM0 (ADC12CSTARTADD_0) #define ADC12_B_START_AT_ADC12MEM1 (ADC12CSTARTADD_1) #define ADC12_B_START_AT_ADC12MEM2 (ADC12CSTARTADD_2) #define ADC12_B_START_AT_ADC12MEM3 (ADC12CSTARTADD_3) #define ADC12_B_START_AT_ADC12MEM4 (ADC12CSTARTADD_4) #define ADC12_B_START_AT_ADC12MEM5 (ADC12CSTARTADD_5) #define ADC12_B_START_AT_ADC12MEM6 (ADC12CSTARTADD_6) #define ADC12_B_START_AT_ADC12MEM7 (ADC12CSTARTADD_7) #define ADC12_B_START_AT_ADC12MEM8 (ADC12CSTARTADD_8) #define ADC12_B_START_AT_ADC12MEM9 (ADC12CSTARTADD_9) #define ADC12_B_START_AT_ADC12MEM10 (ADC12CSTARTADD_10) #define ADC12_B_START_AT_ADC12MEM11 (ADC12CSTARTADD_11) #define ADC12_B_START_AT_ADC12MEM12 (ADC12CSTARTADD_12) #define ADC12_B_START_AT_ADC12MEM13 (ADC12CSTARTADD_13) #define ADC12_B_START_AT_ADC12MEM14 (ADC12CSTARTADD_14) #define ADC12_B_START_AT_ADC12MEM15 (ADC12CSTARTADD_15) #define ADC12_B_START_AT_ADC12MEM16 (ADC12CSTARTADD_16) #define ADC12_B_START_AT_ADC12MEM17 (ADC12CSTARTADD_17) #define ADC12_B_START_AT_ADC12MEM18 (ADC12CSTARTADD_18) #define ADC12_B_START_AT_ADC12MEM19 (ADC12CSTARTADD_19) #define ADC12_B_START_AT_ADC12MEM20 (ADC12CSTARTADD_20) #define ADC12_B_START_AT_ADC12MEM21 (ADC12CSTARTADD_21) #define ADC12_B_START_AT_ADC12MEM22 (ADC12CSTARTADD_22) #define ADC12_B_START_AT_ADC12MEM23 (ADC12CSTARTADD_23) #define ADC12_B_START_AT_ADC12MEM24 (ADC12CSTARTADD_24) #define ADC12_B_START_AT_ADC12MEM25 (ADC12CSTARTADD_25) #define ADC12_B_START_AT_ADC12MEM26 (ADC12CSTARTADD_26) #define ADC12_B_START_AT_ADC12MEM27 (ADC12CSTARTADD_27) #define ADC12_B_START_AT_ADC12MEM28 (ADC12CSTARTADD_28) #define ADC12_B_START_AT_ADC12MEM29 (ADC12CSTARTADD_29) #define ADC12_B_START_AT_ADC12MEM30 (ADC12CSTARTADD_30) #define ADC12_B_START_AT_ADC12MEM31 (ADC12CSTARTADD_31) //***************************************************************************** // // The following are values that can be passed to the // conversionSequenceModeSelect parameter for functions: // ADC12_B_startConversion(). // //***************************************************************************** #define ADC12_B_SINGLECHANNEL (ADC12CONSEQ_0) #define ADC12_B_SEQOFCHANNELS (ADC12CONSEQ_1) #define ADC12_B_REPEATED_SINGLECHANNEL (ADC12CONSEQ_2) #define ADC12_B_REPEATED_SEQOFCHANNELS (ADC12CONSEQ_3) //***************************************************************************** // // The following are values that can be passed to the preempt parameter for // functions: ADC12_B_disableConversions(). // //***************************************************************************** #define ADC12_B_COMPLETECONVERSION false #define ADC12_B_PREEMPTCONVERSION true //***************************************************************************** // // The following are values that can be passed to the resolutionSelect // parameter for functions: ADC12_B_setResolution(). // //***************************************************************************** #define ADC12_B_RESOLUTION_8BIT (ADC12RES__8BIT) #define ADC12_B_RESOLUTION_10BIT (ADC12RES__10BIT) #define ADC12_B_RESOLUTION_12BIT (ADC12RES__12BIT) //***************************************************************************** // // The following are values that can be passed to the invertedSignal parameter // for functions: ADC12_B_setSampleHoldSignalInversion(). // //***************************************************************************** #define ADC12_B_NONINVERTEDSIGNAL (!(ADC12ISSH)) #define ADC12_B_INVERTEDSIGNAL (ADC12ISSH) //***************************************************************************** // // The following are values that can be passed to the readBackFormat parameter // for functions: ADC12_B_setDataReadBackFormat(). // //***************************************************************************** #define ADC12_B_UNSIGNED_BINARY (!(ADC12DF)) #define ADC12_B_SIGNED_2SCOMPLEMENT (ADC12DF) //***************************************************************************** // // The following are values that can be passed to the powerMode parameter for // functions: ADC12_B_setAdcPowerMode(). // //***************************************************************************** #define ADC12_B_REGULARPOWERMODE (!(ADC12PWRMD)) #define ADC12_B_LOWPOWERMODE (ADC12PWRMD) //***************************************************************************** // // The following are values that can be passed toThe following are values that // can be returned by the ADC12_B_isBusy() function. // //***************************************************************************** #define ADC12_B_NOTBUSY 0x00 #define ADC12_B_BUSY ADC12BUSY //***************************************************************************** // // Prototypes for the APIs. // //***************************************************************************** //***************************************************************************** // //! \brief Initializes the ADC12B Module. //! //! This function initializes the ADC module to allow for analog-to-digital //! conversions. Specifically this function sets up the sample-and-hold signal //! and clock sources for the ADC core to use for conversions. Upon successful //! completion of the initialization all of the ADC control registers will be //! reset, excluding the memory controls and reference module bits, the given //! parameters will be set, and the ADC core will be turned on (Note, that the //! ADC core only draws power during conversions and remains off when not //! converting).Note that sample/hold signal sources are device dependent. Note //! that if re-initializing the ADC after starting a conversion with the //! startConversion() function, the disableConversion() must be called BEFORE //! this function can be called. //! //! \param baseAddress is the base address of the ADC12B module. //! \param param is the pointer to struct for initialization. //! //! \return STATUS_SUCCESS or STATUS_FAILURE of the initialization process. // //***************************************************************************** extern bool ADC12_B_init(uint16_t baseAddress, ADC12_B_initParam *param); //***************************************************************************** // //! \brief Enables the ADC12B block. //! //! This will enable operation of the ADC12B block. //! //! \param baseAddress is the base address of the ADC12B module. //! //! Modified bits are \b ADC12ON of \b ADC12CTL0 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_enable(uint16_t baseAddress); //***************************************************************************** // //! \brief Disables the ADC12B block. //! //! This will disable operation of the ADC12B block. //! //! \param baseAddress is the base address of the ADC12B module. //! //! Modified bits are \b ADC12ON of \b ADC12CTL0 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_disable(uint16_t baseAddress); //***************************************************************************** // //! \brief Sets up and enables the Sampling Timer Pulse Mode. //! //! This function sets up the sampling timer pulse mode which allows the //! sample/hold signal to trigger a sampling timer to sample-and-hold an input //! signal for a specified number of clock cycles without having to hold the //! sample/hold signal for the entire period of sampling. Note that if a //! conversion has been started with the startConversion() function, then a //! call to disableConversions() is required before this function may be //! called. //! //! \param baseAddress is the base address of the ADC12B module. //! \param clockCycleHoldCountLowMem sets the amount of clock cycles to sample- //! and-hold for the higher memory buffers 0-7. //! Valid values are: //! - \b ADC12_B_CYCLEHOLD_4_CYCLES [Default] //! - \b ADC12_B_CYCLEHOLD_8_CYCLES //! - \b ADC12_B_CYCLEHOLD_16_CYCLES //! - \b ADC12_B_CYCLEHOLD_32_CYCLES //! - \b ADC12_B_CYCLEHOLD_64_CYCLES //! - \b ADC12_B_CYCLEHOLD_96_CYCLES //! - \b ADC12_B_CYCLEHOLD_128_CYCLES //! - \b ADC12_B_CYCLEHOLD_192_CYCLES //! - \b ADC12_B_CYCLEHOLD_256_CYCLES //! - \b ADC12_B_CYCLEHOLD_384_CYCLES //! - \b ADC12_B_CYCLEHOLD_512_CYCLES //! - \b ADC12_B_CYCLEHOLD_768_CYCLES //! - \b ADC12_B_CYCLEHOLD_1024_CYCLES //! \n Modified bits are \b ADC12SHT0x of \b ADC12CTL0 register. //! \param clockCycleHoldCountHighMem sets the amount of clock cycles to //! sample-and-hold for the higher memory buffers 8-15. //! Valid values are: //! - \b ADC12_B_CYCLEHOLD_4_CYCLES [Default] //! - \b ADC12_B_CYCLEHOLD_8_CYCLES //! - \b ADC12_B_CYCLEHOLD_16_CYCLES //! - \b ADC12_B_CYCLEHOLD_32_CYCLES //! - \b ADC12_B_CYCLEHOLD_64_CYCLES //! - \b ADC12_B_CYCLEHOLD_96_CYCLES //! - \b ADC12_B_CYCLEHOLD_128_CYCLES //! - \b ADC12_B_CYCLEHOLD_192_CYCLES //! - \b ADC12_B_CYCLEHOLD_256_CYCLES //! - \b ADC12_B_CYCLEHOLD_384_CYCLES //! - \b ADC12_B_CYCLEHOLD_512_CYCLES //! - \b ADC12_B_CYCLEHOLD_768_CYCLES //! - \b ADC12_B_CYCLEHOLD_1024_CYCLES //! \n Modified bits are \b ADC12SHT1x of \b ADC12CTL0 register. //! \param multipleSamplesEnabled allows multiple conversions to start without //! a trigger signal from the sample/hold signal //! Valid values are: //! - \b ADC12_B_MULTIPLESAMPLESDISABLE [Default] - a timer trigger will //! be needed to start every ADC conversion. //! - \b ADC12_B_MULTIPLESAMPLESENABLE - during a sequenced and/or //! repeated conversion mode, after the first conversion, no //! sample/hold signal is necessary to start subsequent sample/hold //! and convert processes. //! \n Modified bits are \b ADC12MSC of \b ADC12CTL0 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_setupSamplingTimer(uint16_t baseAddress, uint16_t clockCycleHoldCountLowMem, uint16_t clockCycleHoldCountHighMem, uint16_t multipleSamplesEnabled); //***************************************************************************** // //! \brief Disables Sampling Timer Pulse Mode. //! //! Disables the Sampling Timer Pulse Mode. Note that if a conversion has been //! started with the startConversion() function, then a call to //! disableConversions() is required before this function may be called. //! //! \param baseAddress is the base address of the ADC12B module. //! //! \return None // //***************************************************************************** extern void ADC12_B_disableSamplingTimer(uint16_t baseAddress); //***************************************************************************** // //! \brief Configures the controls of the selected memory buffer. //! //! Maps an input signal conversion into the selected memory buffer, as well as //! the positive and negative reference voltages for each conversion being //! stored into this memory buffer. If the internal reference is used for the //! positive reference voltage, the internal REF module must be used to control //! the voltage level. Note that if a conversion has been started with the //! startConversion() function, then a call to disableConversions() is required //! before this function may be called. //! //! \param baseAddress is the base address of the ADC12B module. //! \param param is the pointer to struct for ADC12B memory configuration. //! //! \return None // //***************************************************************************** extern void ADC12_B_configureMemory(uint16_t baseAddress, ADC12_B_configureMemoryParam *param); //***************************************************************************** // //! \brief Sets the high and low threshold for the window comparator feature. //! //! Sets the high and low threshold for the window comparator feature. Use the //! ADC12HIIE, ADC12INIE, ADC12LOIE interrupts to utilize this feature. //! //! \param baseAddress is the base address of the ADC12B module. //! \param highThreshold is the upper bound that could trip an interrupt for //! the window comparator. //! \param lowThreshold is the lower bound that could trip on interrupt for the //! window comparator. //! //! \return None // //***************************************************************************** extern void ADC12_B_setWindowCompAdvanced(uint16_t baseAddress, uint16_t highThreshold, uint16_t lowThreshold); //***************************************************************************** // //! \brief Enables selected ADC12B interrupt sources. //! //! Enables the indicated ADC12B interrupt sources. Only the sources that are //! enabled can be reflected to the processor interrupt; disabled sources have //! no effect on the processor. Does not clear interrupt flags. //! //! \param baseAddress is the base address of the ADC12B module. //! \param interruptMask0 is the bit mask of the memory buffer and overflow //! interrupt sources to be enabled. If the desired interrupt is not //! available in the selection for interruptMask0, then simply pass in a //! '0' for this value. //! Valid values are: //! - \b ADC12_B_IE0 //! - \b ADC12_B_IE1 //! - \b ADC12_B_IE2 //! - \b ADC12_B_IE3 //! - \b ADC12_B_IE4 //! - \b ADC12_B_IE5 //! - \b ADC12_B_IE6 //! - \b ADC12_B_IE7 //! - \b ADC12_B_IE8 //! - \b ADC12_B_IE9 //! - \b ADC12_B_IE10 //! - \b ADC12_B_IE11 //! - \b ADC12_B_IE12 //! - \b ADC12_B_IE13 //! - \b ADC12_B_IE14 //! - \b ADC12_B_IE15 //! \param interruptMask1 is the bit mask of the memory buffer and overflow //! interrupt sources to be enabled. If the desired interrupt is not //! available in the selection for interruptMask1, then simply pass in a //! '0' for this value. //! Valid values are: //! - \b ADC12_B_IE16 //! - \b ADC12_B_IE17 //! - \b ADC12_B_IE18 //! - \b ADC12_B_IE19 //! - \b ADC12_B_IE20 //! - \b ADC12_B_IE21 //! - \b ADC12_B_IE22 //! - \b ADC12_B_IE23 //! - \b ADC12_B_IE24 //! - \b ADC12_B_IE25 //! - \b ADC12_B_IE26 //! - \b ADC12_B_IE27 //! - \b ADC12_B_IE28 //! - \b ADC12_B_IE29 //! - \b ADC12_B_IE30 //! - \b ADC12_B_IE31 //! \param interruptMask2 is the bit mask of the memory buffer and overflow //! interrupt sources to be enabled. If the desired interrupt is not //! available in the selection for interruptMask2, then simply pass in a //! '0' for this value. //! Valid values are: //! - \b ADC12_B_INIE - Interrupt enable for a conversion in the result //! register is either greater than the ADC12LO or lower than the //! ADC12HI threshold. GIE bit must be set to enable the interrupt. //! - \b ADC12_B_LOIE - Interrupt enable for the falling short of the //! lower limit interrupt of the window comparator for the result //! register. GIE bit must be set to enable the interrupt. //! - \b ADC12_B_HIIE - Interrupt enable for the exceeding the upper //! limit of the window comparator for the result register. GIE bit //! must be set to enable the interrupt. //! - \b ADC12_B_OVIE - Interrupt enable for a conversion that is about //! to save to a memory buffer that has not been read out yet. GIE //! bit must be set to enable the interrupt. //! - \b ADC12_B_TOVIE - enable for a conversion that is about to start //! before the previous conversion has been completed. GIE bit must //! be set to enable the interrupt. //! - \b ADC12_B_RDYIE - enable for the local buffered reference ready //! signal. GIE bit must be set to enable the interrupt. //! //! Modified bits of \b ADC12IERx register. //! //! \return None // //***************************************************************************** extern void ADC12_B_enableInterrupt(uint16_t baseAddress, uint16_t interruptMask0, uint16_t interruptMask1, uint16_t interruptMask2); //***************************************************************************** // //! \brief Disables selected ADC12B interrupt sources. //! //! Disables the indicated ADC12B interrupt sources. Only the sources that are //! enabled can be reflected to the processor interrupt; disabled sources have //! no effect on the processor. //! //! \param baseAddress is the base address of the ADC12B module. //! \param interruptMask0 is the bit mask of the memory buffer and overflow //! interrupt sources to be disabled. If the desired interrupt is not //! available in the selection for interruptMask0, then simply pass in a //! '0' for this value. //! Valid values are: //! - \b ADC12_B_IE0 //! - \b ADC12_B_IE1 //! - \b ADC12_B_IE2 //! - \b ADC12_B_IE3 //! - \b ADC12_B_IE4 //! - \b ADC12_B_IE5 //! - \b ADC12_B_IE6 //! - \b ADC12_B_IE7 //! - \b ADC12_B_IE8 //! - \b ADC12_B_IE9 //! - \b ADC12_B_IE10 //! - \b ADC12_B_IE11 //! - \b ADC12_B_IE12 //! - \b ADC12_B_IE13 //! - \b ADC12_B_IE14 //! - \b ADC12_B_IE15 //! \param interruptMask1 is the bit mask of the memory buffer and overflow //! interrupt sources to be disabled. If the desired interrupt is not //! available in the selection for interruptMask1, then simply pass in a //! '0' for this value. //! Valid values are: //! - \b ADC12_B_IE16 //! - \b ADC12_B_IE17 //! - \b ADC12_B_IE18 //! - \b ADC12_B_IE19 //! - \b ADC12_B_IE20 //! - \b ADC12_B_IE21 //! - \b ADC12_B_IE22 //! - \b ADC12_B_IE23 //! - \b ADC12_B_IE24 //! - \b ADC12_B_IE25 //! - \b ADC12_B_IE26 //! - \b ADC12_B_IE27 //! - \b ADC12_B_IE28 //! - \b ADC12_B_IE29 //! - \b ADC12_B_IE30 //! - \b ADC12_B_IE31 //! \param interruptMask2 is the bit mask of the memory buffer and overflow //! interrupt sources to be disabled. If the desired interrupt is not //! available in the selection for interruptMask2, then simply pass in a //! '0' for this value. //! Valid values are: //! - \b ADC12_B_INIE - Interrupt enable for a conversion in the result //! register is either greater than the ADC12LO or lower than the //! ADC12HI threshold. GIE bit must be set to enable the interrupt. //! - \b ADC12_B_LOIE - Interrupt enable for the falling short of the //! lower limit interrupt of the window comparator for the result //! register. GIE bit must be set to enable the interrupt. //! - \b ADC12_B_HIIE - Interrupt enable for the exceeding the upper //! limit of the window comparator for the result register. GIE bit //! must be set to enable the interrupt. //! - \b ADC12_B_OVIE - Interrupt enable for a conversion that is about //! to save to a memory buffer that has not been read out yet. GIE //! bit must be set to enable the interrupt. //! - \b ADC12_B_TOVIE - enable for a conversion that is about to start //! before the previous conversion has been completed. GIE bit must //! be set to enable the interrupt. //! - \b ADC12_B_RDYIE - enable for the local buffered reference ready //! signal. GIE bit must be set to enable the interrupt. //! //! Modified bits of \b ADC12IERx register. //! //! \return None // //***************************************************************************** extern void ADC12_B_disableInterrupt(uint16_t baseAddress, uint16_t interruptMask0, uint16_t interruptMask1, uint16_t interruptMask2); //***************************************************************************** // //! \brief Clears ADC12B selected interrupt flags. //! //! Modified registers are ADC12IFG . //! //! \param baseAddress is the base address of the ADC12B module. //! \param interruptRegisterChoice is either 0, 1, or 2, to choose the correct //! interrupt register to update //! \param memoryInterruptFlagMask is the bit mask of the memory buffer and //! overflow interrupt flags to be cleared. //! Valid values are: //! - \b ADC12_B_IFG0 - interruptRegisterChoice = 0 //! - \b ADC12_B_IFG1 //! - \b ADC12_B_IFG2 //! - \b ADC12_B_IFG3 //! - \b ADC12_B_IFG4 //! - \b ADC12_B_IFG5 //! - \b ADC12_B_IFG6 //! - \b ADC12_B_IFG7 //! - \b ADC12_B_IFG8 //! - \b ADC12_B_IFG9 //! - \b ADC12_B_IFG10 //! - \b ADC12_B_IFG11 //! - \b ADC12_B_IFG12 //! - \b ADC12_B_IFG13 //! - \b ADC12_B_IFG14 //! - \b ADC12_B_IFG15 //! - \b ADC12_B_IFG16 - interruptRegisterChoice = 1 //! - \b ADC12_B_IFG17 //! - \b ADC12_B_IFG18 //! - \b ADC12_B_IFG19 //! - \b ADC12_B_IFG20 //! - \b ADC12_B_IFG21 //! - \b ADC12_B_IFG22 //! - \b ADC12_B_IFG23 //! - \b ADC12_B_IFG24 //! - \b ADC12_B_IFG25 //! - \b ADC12_B_IFG26 //! - \b ADC12_B_IFG27 //! - \b ADC12_B_IFG28 //! - \b ADC12_B_IFG29 //! - \b ADC12_B_IFG30 //! - \b ADC12_B_IFG31 //! - \b ADC12_B_INIFG - interruptRegisterChoice = 2 //! - \b ADC12_B_LOIFG //! - \b ADC12_B_HIIFG //! - \b ADC12_B_OVIFG //! - \b ADC12_B_TOVIFG //! - \b ADC12_B_RDYIFG - The selected ADC12B interrupt flags are //! cleared, so that it no longer asserts. The memory buffer //! interrupt flags are only cleared when the memory buffer is //! accessed. Note that the overflow interrupts do not have an //! interrupt flag to clear; they must be accessed directly from the //! interrupt vector. //! //! \return None // //***************************************************************************** extern void ADC12_B_clearInterrupt(uint16_t baseAddress, uint8_t interruptRegisterChoice, uint16_t memoryInterruptFlagMask); //***************************************************************************** // //! \brief Returns the status of the selected memory interrupt flags. //! //! Returns the status of the selected memory interrupt flags. Note that the //! overflow interrupts do not have an interrupt flag to clear; they must be //! accessed directly from the interrupt vector. //! //! \param baseAddress is the base address of the ADC12B module. //! \param interruptRegisterChoice is either 0, 1, or 2, to choose the correct //! interrupt register to update //! \param memoryInterruptFlagMask is the bit mask of the memory buffer and //! overflow interrupt flags to be cleared. //! Valid values are: //! - \b ADC12_B_IFG0 - interruptRegisterChoice = 0 //! - \b ADC12_B_IFG1 //! - \b ADC12_B_IFG2 //! - \b ADC12_B_IFG3 //! - \b ADC12_B_IFG4 //! - \b ADC12_B_IFG5 //! - \b ADC12_B_IFG6 //! - \b ADC12_B_IFG7 //! - \b ADC12_B_IFG8 //! - \b ADC12_B_IFG9 //! - \b ADC12_B_IFG10 //! - \b ADC12_B_IFG11 //! - \b ADC12_B_IFG12 //! - \b ADC12_B_IFG13 //! - \b ADC12_B_IFG14 //! - \b ADC12_B_IFG15 //! - \b ADC12_B_IFG16 - interruptRegisterChoice = 1 //! - \b ADC12_B_IFG17 //! - \b ADC12_B_IFG18 //! - \b ADC12_B_IFG19 //! - \b ADC12_B_IFG20 //! - \b ADC12_B_IFG21 //! - \b ADC12_B_IFG22 //! - \b ADC12_B_IFG23 //! - \b ADC12_B_IFG24 //! - \b ADC12_B_IFG25 //! - \b ADC12_B_IFG26 //! - \b ADC12_B_IFG27 //! - \b ADC12_B_IFG28 //! - \b ADC12_B_IFG29 //! - \b ADC12_B_IFG30 //! - \b ADC12_B_IFG31 //! - \b ADC12_B_INIFG - interruptRegisterChoice = 2 //! - \b ADC12_B_LOIFG //! - \b ADC12_B_HIIFG //! - \b ADC12_B_OVIFG //! - \b ADC12_B_TOVIFG //! - \b ADC12_B_RDYIFG - The selected ADC12B interrupt flags are //! cleared, so that it no longer asserts. The memory buffer //! interrupt flags are only cleared when the memory buffer is //! accessed. Note that the overflow interrupts do not have an //! interrupt flag to clear; they must be accessed directly from the //! interrupt vector. //! //! \return The current interrupt flag status for the corresponding mask. // //***************************************************************************** extern uint16_t ADC12_B_getInterruptStatus(uint16_t baseAddress, uint8_t interruptRegisterChoice, uint16_t memoryInterruptFlagMask); //***************************************************************************** // //! \brief Enables/Starts an Analog-to-Digital Conversion. //! //! Enables/starts the conversion process of the ADC. If the sample/hold signal //! source chosen during initialization was ADC12OSC, then the conversion is //! started immediately, otherwise the chosen sample/hold signal source starts //! the conversion by a rising edge of the signal. Keep in mind when selecting //! conversion modes, that for sequenced and/or repeated modes, to keep the //! sample/hold-and-convert process continuing without a trigger from the //! sample/hold signal source, the multiple samples must be enabled using the //! ADC12_B_setupSamplingTimer() function. Note that after this function is //! called, the ADC12_B_stopConversions() has to be called to re-initialize the //! ADC, reconfigure a memory buffer control, enable/disable the sampling //! timer, or to change the internal reference voltage. //! //! \param baseAddress is the base address of the ADC12B module. //! \param startingMemoryBufferIndex is the memory buffer that will hold the //! first or only conversion. //! Valid values are: //! - \b ADC12_B_START_AT_ADC12MEM0 [Default] //! - \b ADC12_B_START_AT_ADC12MEM1 //! - \b ADC12_B_START_AT_ADC12MEM2 //! - \b ADC12_B_START_AT_ADC12MEM3 //! - \b ADC12_B_START_AT_ADC12MEM4 //! - \b ADC12_B_START_AT_ADC12MEM5 //! - \b ADC12_B_START_AT_ADC12MEM6 //! - \b ADC12_B_START_AT_ADC12MEM7 //! - \b ADC12_B_START_AT_ADC12MEM8 //! - \b ADC12_B_START_AT_ADC12MEM9 //! - \b ADC12_B_START_AT_ADC12MEM10 //! - \b ADC12_B_START_AT_ADC12MEM11 //! - \b ADC12_B_START_AT_ADC12MEM12 //! - \b ADC12_B_START_AT_ADC12MEM13 //! - \b ADC12_B_START_AT_ADC12MEM14 //! - \b ADC12_B_START_AT_ADC12MEM15 //! - \b ADC12_B_START_AT_ADC12MEM16 //! - \b ADC12_B_START_AT_ADC12MEM17 //! - \b ADC12_B_START_AT_ADC12MEM18 //! - \b ADC12_B_START_AT_ADC12MEM19 //! - \b ADC12_B_START_AT_ADC12MEM20 //! - \b ADC12_B_START_AT_ADC12MEM21 //! - \b ADC12_B_START_AT_ADC12MEM22 //! - \b ADC12_B_START_AT_ADC12MEM23 //! - \b ADC12_B_START_AT_ADC12MEM24 //! - \b ADC12_B_START_AT_ADC12MEM25 //! - \b ADC12_B_START_AT_ADC12MEM26 //! - \b ADC12_B_START_AT_ADC12MEM27 //! - \b ADC12_B_START_AT_ADC12MEM28 //! - \b ADC12_B_START_AT_ADC12MEM29 //! - \b ADC12_B_START_AT_ADC12MEM30 //! - \b ADC12_B_START_AT_ADC12MEM31 //! \n Modified bits are \b ADC12CSTARTADDx of \b ADC12CTL1 register. //! \param conversionSequenceModeSelect determines the ADC operating mode. //! Valid values are: //! - \b ADC12_B_SINGLECHANNEL [Default] - one-time conversion of a //! single channel into a single memory buffer. //! - \b ADC12_B_SEQOFCHANNELS - one time conversion of multiple //! channels into the specified starting memory buffer and each //! subsequent memory buffer up until the conversion is stored in a //! memory buffer dedicated as the end-of-sequence by the memory's //! control register. //! - \b ADC12_B_REPEATED_SINGLECHANNEL - repeated conversions of one //! channel into a single memory buffer. //! - \b ADC12_B_REPEATED_SEQOFCHANNELS - repeated conversions of //! multiple channels into the specified starting memory buffer and //! each subsequent memory buffer up until the conversion is stored //! in a memory buffer dedicated as the end-of-sequence by the //! memory's control register. //! \n Modified bits are \b ADC12CONSEQx of \b ADC12CTL1 register. //! //! Modified bits of \b ADC12CTL1 register and bits of \b ADC12CTL0 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_startConversion(uint16_t baseAddress, uint16_t startingMemoryBufferIndex, uint8_t conversionSequenceModeSelect); //***************************************************************************** // //! \brief Disables the ADC from converting any more signals. //! //! Disables the ADC from converting any more signals. If there is a conversion //! in progress, this function can stop it immediately if the preempt parameter //! is set as ADC12_B_PREEMPTCONVERSION, by changing the conversion mode to //! single-channel, single-conversion and disabling conversions. If the //! conversion mode is set as single-channel, single-conversion and this //! function is called without preemption, then the ADC core conversion status //! is polled until the conversion is complete before disabling conversions to //! prevent unpredictable data. If the ADC12_B_startConversion() has been //! called, then this function has to be called to re-initialize the ADC, //! reconfigure a memory buffer control, enable/disable the sampling pulse //! mode, or change the internal reference voltage. //! //! \param baseAddress is the base address of the ADC12B module. //! \param preempt specifies if the current conversion should be preemptively //! stopped before the end of the conversion. //! Valid values are: //! - \b ADC12_B_COMPLETECONVERSION - Allows the ADC12B to end the //! current conversion before disabling conversions. //! - \b ADC12_B_PREEMPTCONVERSION - Stops the ADC12B immediately, with //! unpredictable results of the current conversion. //! //! Modified bits of \b ADC12CTL1 register and bits of \b ADC12CTL0 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_disableConversions(uint16_t baseAddress, bool preempt); //***************************************************************************** // //! \brief Returns the raw contents of the specified memory buffer. //! //! Returns the raw contents of the specified memory buffer. The format of the //! content depends on the read-back format of the data: if the data is in //! signed 2's complement format then the contents in the memory buffer will be //! left-justified with the least-significant bits as 0's, whereas if the data //! is in unsigned format then the contents in the memory buffer will be right- //! justified with the most-significant bits as 0's. //! //! \param baseAddress is the base address of the ADC12B module. //! \param memoryBufferIndex is the specified memory buffer to read. //! Valid values are: //! - \b ADC12_B_MEMORY_0 //! - \b ADC12_B_MEMORY_1 //! - \b ADC12_B_MEMORY_2 //! - \b ADC12_B_MEMORY_3 //! - \b ADC12_B_MEMORY_4 //! - \b ADC12_B_MEMORY_5 //! - \b ADC12_B_MEMORY_6 //! - \b ADC12_B_MEMORY_7 //! - \b ADC12_B_MEMORY_8 //! - \b ADC12_B_MEMORY_9 //! - \b ADC12_B_MEMORY_10 //! - \b ADC12_B_MEMORY_11 //! - \b ADC12_B_MEMORY_12 //! - \b ADC12_B_MEMORY_13 //! - \b ADC12_B_MEMORY_14 //! - \b ADC12_B_MEMORY_15 //! - \b ADC12_B_MEMORY_16 //! - \b ADC12_B_MEMORY_17 //! - \b ADC12_B_MEMORY_18 //! - \b ADC12_B_MEMORY_19 //! - \b ADC12_B_MEMORY_20 //! - \b ADC12_B_MEMORY_21 //! - \b ADC12_B_MEMORY_22 //! - \b ADC12_B_MEMORY_23 //! - \b ADC12_B_MEMORY_24 //! - \b ADC12_B_MEMORY_25 //! - \b ADC12_B_MEMORY_26 //! - \b ADC12_B_MEMORY_27 //! - \b ADC12_B_MEMORY_28 //! - \b ADC12_B_MEMORY_29 //! - \b ADC12_B_MEMORY_30 //! - \b ADC12_B_MEMORY_31 //! //! \return A signed integer of the contents of the specified memory buffer. // //***************************************************************************** extern uint16_t ADC12_B_getResults(uint16_t baseAddress, uint8_t memoryBufferIndex); //***************************************************************************** // //! \brief Use to change the resolution of the converted data. //! //! This function can be used to change the resolution of the converted data //! from the default of 12-bits. //! //! \param baseAddress is the base address of the ADC12B module. //! \param resolutionSelect determines the resolution of the converted data. //! Valid values are: //! - \b ADC12_B_RESOLUTION_8BIT //! - \b ADC12_B_RESOLUTION_10BIT //! - \b ADC12_B_RESOLUTION_12BIT [Default] //! \n Modified bits are \b ADC12RESx of \b ADC12CTL2 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_setResolution(uint16_t baseAddress, uint8_t resolutionSelect); //***************************************************************************** // //! \brief Use to invert or un-invert the sample/hold signal. //! //! This function can be used to invert or un-invert the sample/hold signal. //! Note that if a conversion has been started with the startConversion() //! function, then a call to disableConversions() is required before this //! function may be called. //! //! \param baseAddress is the base address of the ADC12B module. //! \param invertedSignal set if the sample/hold signal should be inverted //! Valid values are: //! - \b ADC12_B_NONINVERTEDSIGNAL [Default] - a sample-and-hold of an //! input signal for conversion will be started on a rising edge of //! the sample/hold signal. //! - \b ADC12_B_INVERTEDSIGNAL - a sample-and-hold of an input signal //! for conversion will be started on a falling edge of the //! sample/hold signal. //! \n Modified bits are \b ADC12ISSH of \b ADC12CTL1 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_setSampleHoldSignalInversion(uint16_t baseAddress, uint16_t invertedSignal); //***************************************************************************** // //! \brief Use to set the read-back format of the converted data. //! //! Sets the format of the converted data: how it will be stored into the //! memory buffer, and how it should be read back. The format can be set as //! right-justified (default), which indicates that the number will be //! unsigned, or left-justified, which indicates that the number will be signed //! in 2's complement format. This change affects all memory buffers for //! subsequent conversions. //! //! \param baseAddress is the base address of the ADC12B module. //! \param readBackFormat is the specified format to store the conversions in //! the memory buffer. //! Valid values are: //! - \b ADC12_B_UNSIGNED_BINARY [Default] //! - \b ADC12_B_SIGNED_2SCOMPLEMENT //! \n Modified bits are \b ADC12DF of \b ADC12CTL2 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_setDataReadBackFormat(uint16_t baseAddress, uint8_t readBackFormat); //***************************************************************************** // //! \brief Use to set the ADC's power conservation mode if the sampling rate is //! at 50-ksps or less. //! //! Sets ADC's power mode. If the user has a sampling rate greater than //! 50-ksps, then he/she can only enable ADC12_B_REGULARPOWERMODE. If the //! sampling rate is 50-ksps or less, the user can enable ADC12_B_LOWPOWERMODE //! granting additional power savings. //! //! \param baseAddress is the base address of the ADC12B module. //! \param powerMode is the specified maximum sampling rate. //! Valid values are: //! - \b ADC12_B_REGULARPOWERMODE [Default] - If sampling rate is //! greater than 50-ksps, there is no power saving feature available. //! - \b ADC12_B_LOWPOWERMODE - If sampling rate is less than or equal //! to 50-ksps, select this value to save power //! \n Modified bits are \b ADC12SR of \b ADC12CTL2 register. //! //! \return None // //***************************************************************************** extern void ADC12_B_setAdcPowerMode(uint16_t baseAddress, uint8_t powerMode); //***************************************************************************** // //! \brief Returns the address of the specified memory buffer for the DMA //! module. //! //! Returns the address of the specified memory buffer. This can be used in //! conjunction with the DMA to store the converted data directly to memory. //! //! \param baseAddress is the base address of the ADC12B module. //! \param memoryIndex is the memory buffer to return the address of. //! Valid values are: //! - \b ADC12_B_MEMORY_0 //! - \b ADC12_B_MEMORY_1 //! - \b ADC12_B_MEMORY_2 //! - \b ADC12_B_MEMORY_3 //! - \b ADC12_B_MEMORY_4 //! - \b ADC12_B_MEMORY_5 //! - \b ADC12_B_MEMORY_6 //! - \b ADC12_B_MEMORY_7 //! - \b ADC12_B_MEMORY_8 //! - \b ADC12_B_MEMORY_9 //! - \b ADC12_B_MEMORY_10 //! - \b ADC12_B_MEMORY_11 //! - \b ADC12_B_MEMORY_12 //! - \b ADC12_B_MEMORY_13 //! - \b ADC12_B_MEMORY_14 //! - \b ADC12_B_MEMORY_15 //! - \b ADC12_B_MEMORY_16 //! - \b ADC12_B_MEMORY_17 //! - \b ADC12_B_MEMORY_18 //! - \b ADC12_B_MEMORY_19 //! - \b ADC12_B_MEMORY_20 //! - \b ADC12_B_MEMORY_21 //! - \b ADC12_B_MEMORY_22 //! - \b ADC12_B_MEMORY_23 //! - \b ADC12_B_MEMORY_24 //! - \b ADC12_B_MEMORY_25 //! - \b ADC12_B_MEMORY_26 //! - \b ADC12_B_MEMORY_27 //! - \b ADC12_B_MEMORY_28 //! - \b ADC12_B_MEMORY_29 //! - \b ADC12_B_MEMORY_30 //! - \b ADC12_B_MEMORY_31 //! //! \return address of the specified memory buffer // //***************************************************************************** extern uint32_t ADC12_B_getMemoryAddressForDMA(uint16_t baseAddress, uint8_t memoryIndex); //***************************************************************************** // //! \brief Returns the busy status of the ADC12B core. //! //! Returns the status of the ADC core if there is a conversion currently //! taking place. //! //! \param baseAddress is the base address of the ADC12B module. //! //! \return ADC12_B_BUSY or ADC12_B_NOTBUSY dependent if there is a conversion //! currently taking place. //! Return one of the following: //! - \b ADC12_B_NOTBUSY //! - \b ADC12_B_BUSY //! \n indicating if a conversion is taking place // //***************************************************************************** extern uint8_t ADC12_B_isBusy(uint16_t baseAddress); //***************************************************************************** // // Mark the end of the C bindings section for C++ compilers. // //***************************************************************************** #ifdef __cplusplus } #endif #endif #endif // __MSP430WARE_ADC12_B_H__