Implements an 8-bit sample and hold ADC on the MSP430

How to write a C Program to Implements an 8-bit sample and hold ADC on the MSP430 using its onboard comparator and transmission gate in C Programming Language ?

This C Program Implements an 8-bit sample and hold ADC on the MSP430 using its onboard comparator and transmission gate.

I/O Ports:
  P1.0 <-> CA0  (sampling capacitor)
  P1.1 <-  CA1  (Vin)
  P1.2 <-  CA2  (resistor network ramp)
  P1.4 ->  /CS  (DAC)
  P1.5 ->  SCLK (DAC)
  P1.7 ->  SD1  (DAC)
  P2.0 ->  BIT0 (resistor network)
  P2.1 ->  BIT1 (resistor network)
  P2.2 ->  BIT2 (resistor network)
  P2.3 ->  BIT3 (resistor network)
  P2.4 ->  BIT4 (resistor network)
  P2.5 ->  BIT5 (resistor network)
  P2.6 ->  BIT6 (resistor network)
  P2.7 ->  BIT7 (resistor network)


Solution:

1. #include <msp430.h>
3. /*
4.  * main.c
5.  *
6.  * Title: Project 3 ADC Fun!
7.  *
8.  * Authors: Daniel Hodges & Omar Arriaga
9.  *
10.  * Description: Implements an 8-bit sample and hold ADC on the MSP430 using its onboard comparator
11.  *              and transmission gate.
12.  *
13.  * I/O Ports:
14.  *
15.  *  P1.0 <-> CA0  (sampling capacitor)
16.  *  P1.1 <-  CA1  (Vin)
17.  *  P1.2 <-  CA2  (resistor network ramp)
18.  *  P1.4 ->  /CS  (DAC)
19.  *  P1.5 ->  SCLK (DAC)
20.  *  P1.7 ->  SD1  (DAC)
21.  *
22.  *  P2.0 ->  BIT0 (resistor network)
23.  *  P2.1 ->  BIT1 (resistor network)
24.  *  P2.2 ->  BIT2 (resistor network)
25.  *  P2.3 ->  BIT3 (resistor network)
26.  *  P2.4 ->  BIT4 (resistor network)
27.  *  P2.5 ->  BIT5 (resistor network)
28.  *  P2.6 ->  BIT6 (resistor network)
29.  *  P2.7 ->  BIT7 (resistor network)
30.  *
31.  */
33. void CLK16MHz();
34. void portsSetup();
35. void sampleInput();
36. void compareInput();
37. void Drive_DAC(unsigned int level);
39. int ramp_Value = 0;
40. int DAC_Value = 0;
42. int main(void) {
44.     WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
46.     CLK16MHz();               // set clock to 16MHz
48.     portsSetup();             // setup and initialize ports
50.     _enable_interrupts();     // enable interrupts
52.     // samples input, determines input, sends sample to DAC
53.     while(1){
55.         sampleInput();        // sample Vin and hold for cap to charge
57.         compareInput();       // compare sampled Vin to a 0 to Vcc ramp
58.                               // interrupt will trigger once CAOUT goes low
60.         Drive_DAC(DAC_Value); // send new sample to DAC
62.     }
64. }
66. // set SMCLK to 16MHZ
67. void CLK16MHz(){
69.     // 16Mhz SMCLK
70.     if (CALBC1_16MHZ==0xFF)             // If calibration constant erased
71.     {
72.       while(1);                         // do not load, trap CPU!!
73.     }
74.     DCOCTL = 0;                         // Select lowest DCOx and MODx settings
75.     BCSCTL1 = CALBC1_16MHZ;             // Set range
76.     DCOCTL = CALDCO_16MHZ;              // Set DCO step + modulation
78. }
80. // initialize and setup ports
81. void portsSetup(){
83.     /*****************************
84.      * Resistor Network Setup    *
85.      ****************************/
86.     // Set P2.6,7 as GPIO ports
87.     P2SEL &= ~(BIT7 + BIT6);
88.     P2SEL2 &= ~(BIT7 + BIT6);
90.     P2DIR |= 0xFF;                      // Set Port2.0-7 as outputs for resistor network
92.     /*****************************
93.      * Comparator A Setup        *
94.      ****************************/
95.     CAPD |= CAPD0 + CAPD1 + CAPD2;      // Disable input buffer for CA0, CA1, CA2
97.     CACTL1 |= CAIES + CAIE;             // Comparator interrupt enable, falling edge
99.     // select CA0 for first mux
100.     CACTL2 |= P2CA0;
101.     CACTL2 &= ~(P2CA4);
103.     /*****************************
104.      * DAC and SPI Setup         *
105.      ****************************/
106.     P1SEL  = BIT7 + BIT5;               // These two lines dedicate P1.7 and P1.5
107.     P1SEL2 = BIT7 + BIT5;               // for UCB0SIMO and UCB0CLK respectively
109.     P1DIR |= BIT4; // P1.4 used to activate /CE on DAC
111.     // SPI Setup
112.     // clock inactive state = low,
113.     // MSB first, 8-bit SPI master,
114.     // 4-pin active Low STE, synchronous
115.     //
116.     // 4-bit mode disabled for now
117.     UCB0CTL0 |= UCCKPL + UCMSB + UCMST + /* UCMODE_2 */ + UCSYNC;
119.     UCB0CTL1 |= UCSSEL_2;               // UCB0 will use SMCLK as the basis for
120.                                         // the SPI bit clock
122.     UCB0CTL1 &= ~UCSWRST;               // **Initialize USCI state machine**
123.                                         // SPI now Waiting for something to
124.                                         // be placed in TXBUF.
126. }
128. // samples Vin on sampling capacitor
129. void sampleInput(){
131.     // select CA1 (Vin) for second mux
132.     CACTL2 |= P2CA1;
133.     CACTL2 &= ~(P2CA2 + P2CA3);
135.     CACTL2 |= CASHORT;    // turn on transmission gate to start sampling
137.     _delay_cycles(1500);  // delay for sampling cap to charge
139.     CACTL2 &= ~CASHORT;   // turn off transmission gate to end sampling
141. }
143. // compares sample on sampling capacitor to 0 to Vcc ramp
144. void compareInput(){
146.     // select CA2 (ramp) for second mux
147.     CACTL2 |= P2CA2;
148.     CACTL2 &= ~(P2CA1 + P2CA3);
150.     CACTL1 |= CAON;       // turn comparator on
152.     // start ramp from 0 to Vcc using resistor network
153.     for(ramp_Value = 0; ramp_Value < 256; ramp_Value++){
154.         P2OUT = ramp_Value;
155.     }
157.     CACTL1 &= ~CAON;      // turn comparator off
159.     P2OUT = 0;            // set ramp back to 0
161. }
163. // Drives DAC through SPI; takes value from 0 to 4096
164. void Drive_DAC(unsigned int level){
166.       unsigned int DAC_Word = 0;
168.       DAC_Word = (0x3000) | (level & 0x0FFF);   // 0x1000 sets DAC for Write
169.                                                 // to DAC, Gain = 1, /SHDN = 1
170.                                                 // and put 12-bit level value
171.                                                 // in low 12 bits.
173.       P1OUT &= ~BIT4;                           // Clear P1.4 (drive /CS low on DAC)
174.                                                 // Using a port output to do this for now
176.       UCB0TXBUF = (DAC_Word >> 8);              // Shift upper byte of DAC_Word
177.                                                 // 8-bits to right
179.       while (!(IFG2 & UCB0TXIFG));              // USCI_A0 TX buffer ready?
181.       UCB0TXBUF = (unsigned char)
182.                    (DAC_Word & 0x00FF);         // Transmit lower byte to DAC
184.       while (!(IFG2 & UCB0TXIFG));              // USCI_A0 TX buffer ready?
186.       P1OUT |= BIT4;                            // Set P1.4   (drive /CS high on DAC)
187.       return;
189. }
191. // Comparator A interrupt service routine
192. #pragma vector=COMPARATORA_VECTOR
193. __interrupt void Comparator_A (void)
194. {
196.     DAC_Value = (ramp_Value * 12);              // convert and store current ramp_Value in DAC_Value
198. }

Learn More :

Share this

Share on FacebookPlus on Google+