Embedded Lab

ADC12 Sampling Multiple Input

Till now, we have seen only one ADC channel in action. We have seen examples of single internal and external channels only. However, in real-life and in many occasions, we may need the use of more than one ADC channel. For example, we will need multiple ADC channels when crafting an Uninterrupted Power Supply (UPS). In an UPS, we will be needing to measure battery voltage, battery charging and discharging current, AC output voltage and current, internal temperature and so on. In such cases, multiple ADC channels are musts. This example demonstrates how to use multiple ADC channels of a MSP430F5529 microcontroller. 

Code Example

#include "driverlib.h"
#include "delay.h"
#include "lcd.h"
#include "lcd_print.h"

unsigned long res[2] = {0, 0};

void clock_init(void);
void GPIO_init(void);
void ADC12_init(void);

#pragma vector = ADC12_VECTOR
__interrupt void ADC12ISR (void)
{
    switch (__even_in_range(ADC12IV, 34))
    {
        case  0: break;   //Vector  0:  No interrupt
        case  2: break;   //Vector  2:  ADC overflow
        case  4: break;   //Vector  4:  ADC timing overflow
        case  6: break;   
  {
		res[0] = ADC12_A_getResults(ADC12_A_BASE,
                                        ADC12_A_MEMORY_0);
            break;
  }		 	 //Vector  6:  ADC12IFG0
        case  8:
        {
            res[1] = ADC12_A_getResults(ADC12_A_BASE,
                                        ADC12_A_MEMORY_1);
            break;
        }                 //Vector  8:  ADC12IFG1
        case 10: break;   //Vector 10:  ADC12IFG2
        case 12: break;   //Vector 12:  ADC12IFG3
        case 14: break;   //Vector 14:  ADC12IFG4
        case 16: break;   //Vector 16:  ADC12IFG5
        case 18: break;   //Vector 18:  ADC12IFG6
        case 20: break;   //Vector 20:  ADC12IFG7
        case 22: break;   //Vector 22:  ADC12IFG8
        case 24: break;   //Vector 24:  ADC12IFG9
        case 26: break;   //Vector 26:  ADC12IFG10
        case 28: break;   //Vector 28:  ADC12IFG11
        case 30: break;   //Vector 30:  ADC12IFG12
        case 32: break;   //Vector 32:  ADC12IFG13
        case 34: break;   //Vector 34:  ADC12IFG14
        default: break;
    }
}

void main(void)
{
    WDT_A_hold(WDT_A_BASE);

    clock_init();
    GPIO_init();
    ADC12_init();

    LCD_init();
    LCD_clear_home();

    LCD_goto(0, 0);
    LCD_putstr("CH0:");

    LCD_goto(0, 1);
    LCD_putstr("CH1:");

    while(1)
    {

        print_I(11, 0, res[0]);
        print_I(11, 1, res[1]);
        delay_ms(100);
    };
}

void clock_init(void)
{
    PMM_setVCore(PMM_CORE_LEVEL_3);

    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P5,
                                               (GPIO_PIN4 | GPIO_PIN2));

    GPIO_setAsPeripheralModuleFunctionOutputPin(GPIO_PORT_P5,
                                                (GPIO_PIN5 | GPIO_PIN3));

    UCS_setExternalClockSource(XT1_FREQ,
                               XT2_FREQ);

    UCS_turnOnXT2(UCS_XT2_DRIVE_4MHZ_8MHZ);

    UCS_turnOnLFXT1(UCS_XT1_DRIVE_0,
                    UCS_XCAP_3);

    UCS_initClockSignal(UCS_FLLREF,
                        UCS_XT2CLK_SELECT,
                        UCS_CLOCK_DIVIDER_4);

    UCS_initFLLSettle(MCLK_KHZ,
                      MCLK_FLLREF_RATIO);

    UCS_initClockSignal(UCS_SMCLK,
                        UCS_XT2CLK_SELECT,
                        UCS_CLOCK_DIVIDER_2);

    UCS_initClockSignal(UCS_ACLK,
                        UCS_XT1CLK_SELECT,
                        UCS_CLOCK_DIVIDER_1);
}

void GPIO_init(void)
{
    GPIO_setAsOutputPin(GPIO_PORT_P4,
                        GPIO_PIN7);

    GPIO_setAsPeripheralModuleFunctionInputPin(GPIO_PORT_P6,
                                               (GPIO_PIN0 | GPIO_PIN1));
}

void ADC12_init(void)
{
    ADC12_A_configureMemoryParam CH0_configureMemoryParam = {0};
    ADC12_A_configureMemoryParam CH1_configureMemoryParam = {0};

    CH0_configureMemoryParam.memoryBufferControlIndex = ADC12_A_MEMORY_0;
    CH0_configureMemoryParam.inputSourceSelect = ADC12_A_INPUT_A0;
    CH0_configureMemoryParam.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
    CH0_configureMemoryParam.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
    CH0_configureMemoryParam.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;

    CH1_configureMemoryParam.memoryBufferControlIndex = ADC12_A_MEMORY_1;
    CH1_configureMemoryParam.inputSourceSelect = ADC12_A_INPUT_A1;
    CH1_configureMemoryParam.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
    CH1_configureMemoryParam.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
    CH1_configureMemoryParam.endOfSequence = ADC12_A_ENDOFSEQUENCE;

    ADC12_A_init(ADC12_A_BASE,
                 ADC12_A_SAMPLEHOLDSOURCE_SC,
                 ADC12_A_CLOCKSOURCE_ACLK,
                 ADC12_A_CLOCKDIVIDER_1);

    ADC12_A_setupSamplingTimer(ADC12_A_BASE,
                               ADC12_A_CYCLEHOLD_256_CYCLES,
                               ADC12_A_CYCLEHOLD_4_CYCLES,
                               ADC12_A_MULTIPLESAMPLESENABLE);

    ADC12_A_setResolution(ADC12_A_BASE,
                          ADC12_A_RESOLUTION_12BIT);

    ADC12_A_configureMemory(ADC12_A_BASE,
                            &CH0_configureMemoryParam);

    ADC12_A_configureMemory(ADC12_A_BASE,
                            &CH1_configureMemoryParam);

    ADC12_A_clearInterrupt(ADC12_A_BASE,
                           ADC12IFG0);

    ADC12_A_enableInterrupt(ADC12_A_BASE,
                            ADC12IE0);	

    ADC12_A_clearInterrupt(ADC12_A_BASE,
                           ADC12IFG1);

    ADC12_A_enableInterrupt(ADC12_A_BASE,
                            ADC12IE1);

    __enable_interrupt();

    ADC12_A_enable(ADC12_A_BASE);

    ADC12_A_startConversion(ADC12_A_BASE,
                            ADC12_A_MEMORY_0,
                            ADC12_A_REPEATED_SEQOFCHANNELS);
}

Hardware Setup

Explanation

ADC12’s settings have two sections. One is common and the other is channel dependent.

Common settings include ADC’s clock setup, resolution and sample-hold timer settings. These will be applicable for all channels.

ADC12_A_init(ADC12_A_BASE,
             ADC12_A_SAMPLEHOLDSOURCE_SC,
             ADC12_A_CLOCKSOURCE_ACLK,
             ADC12_A_CLOCKDIVIDER_1);

ADC12_A_setupSamplingTimer(ADC12_A_BASE,
                           ADC12_A_CYCLEHOLD_256_CYCLES,
                           ADC12_A_CYCLEHOLD_4_CYCLES,
                           ADC12_A_MULTIPLESAMPLESENABLE);

ADC12_A_setResolution(ADC12_A_BASE, ADC12_A_RESOLUTION_12BIT);

Channel parameters define ADC memory location, references and sequence info. Additionally, if interrupts are used, they need to applied separately.

CH0_configureMemoryParam.memoryBufferControlIndex = ADC12_A_MEMORY_0;
CH0_configureMemoryParam.inputSourceSelect = ADC12_A_INPUT_A0;
CH0_configureMemoryParam.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
CH0_configureMemoryParam.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
CH0_configureMemoryParam.endOfSequence = ADC12_A_NOTENDOFSEQUENCE;

CH1_configureMemoryParam.memoryBufferControlIndex = ADC12_A_MEMORY_1;
CH1_configureMemoryParam.inputSourceSelect = ADC12_A_INPUT_A1;
CH1_configureMemoryParam.positiveRefVoltageSourceSelect = ADC12_A_VREFPOS_AVCC;
CH1_configureMemoryParam.negativeRefVoltageSourceSelect = ADC12_A_VREFNEG_AVSS;
CH1_configureMemoryParam.endOfSequence = ADC12_A_ENDOFSEQUENCE;

....

ADC12_A_clearInterrupt(ADC12_A_BASE, ADC12IFG0);
ADC12_A_enableInterrupt(ADC12_A_BASE, ADC12IE0);

ADC12_A_configureMemory(ADC12_A_BASE, &CH0_configureMemoryParam);
	
ADC12_A_clearInterrupt(ADC12_A_BASE, ADC12IFG1);
ADC12_A_enableInterrupt(ADC12_A_BASE, ADC12IE1);

ADC12_A_configureMemory(ADC12_A_BASE, &CH1_configureMemoryParam);

At this point, I would like to highlight the concept of sequence. When multiple ADC channels are used, ADC conversions are done sequentially, i.e. one after another. In our code, we have to specify one channel as the end of sequence while denoting other channels as no end of sequence. In this way, channels are systematically queued.

ADC reading process is same as the one we saw in the ADC interrupt example. The only exception is the usage of two vectors as two channels are in different memory planes.

#pragma vector = ADC12_VECTOR
__interrupt void ADC12ISR (void)
{
    switch (__even_in_range(ADC12IV, 34))
    {
        case  0: break;   //Vector  0:  No interrupt
        case  2: break;   //Vector  2:  ADC overflow
        case  4: break;   //Vector  4:  ADC timing overflow
        case  6: break;   
  {
		res[0] = ADC12_A_getResults(ADC12_A_BASE,
                                        ADC12_A_MEMORY_0);
            break;
  }		 	 //Vector  6:  ADC12IFG0
        case  8:
        {
            res[1] = ADC12_A_getResults(ADC12_A_BASE,
                                        ADC12_A_MEMORY_1);
            break;
        }                 //Vector  8:  ADC12IFG1
        case 10: break;   //Vector 10:  ADC12IFG2
        case 12: break;   //Vector 12:  ADC12IFG3
        case 14: break;   //Vector 14:  ADC12IFG4
        case 16: break;   //Vector 16:  ADC12IFG5
        case 18: break;   //Vector 18:  ADC12IFG6
        case 20: break;   //Vector 20:  ADC12IFG7
        case 22: break;   //Vector 22:  ADC12IFG8
        case 24: break;   //Vector 24:  ADC12IFG9
        case 26: break;   //Vector 26:  ADC12IFG10
        case 28: break;   //Vector 28:  ADC12IFG11
        case 30: break;   //Vector 30:  ADC12IFG12
        case 32: break;   //Vector 32:  ADC12IFG13
        case 34: break;   //Vector 34:  ADC12IFG14
        default: break;
    }
}

Demo

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37