ADC program for LPC2138

void init_adc0(unsigned char ch,unsigned char clk_div)

{
chn=1<<ch;
PINSEL1= (PINSEL1 & (~(3<<28)))|(1<<28); /*Select the AD0.3
of P0.30*/
PCONP |= 0x00001000; /*Power
on the A/D converter 0 */
AD0CR =(1<<ch) | ( ((clk_div-1))<<8 ) | pdn_bit ; /*configuer the A/D
control register of A/D 0*/
}

Configuring the ADC (ADCR)

Looking at the code above, you can see that before we can read any results from the ADC we
need to configure it (using "init_adc0" func). In this particular case, we're using AD0.3, which
means we are using A/D Converter 0, and channel 3 (out of a possible 8 channels).

1. Select the pin function (PINSEL)

One of the interesting features of ARM microcontrollers is that each pin can perform up to 4
different 'functions' ... though only one at a time! If you're not sure how this works, or what the
advantages of this are, this can be done by PINSEL (a set of registers that we can use to indicate
exactly which would like each pin to perform). In the case of AD0.3 (located on pin 15 of the
lpc2138), the pin can be configure to perform any of the following functions (see page 71 of the
LPC21XX User's Manual):

1. P0.30 - General Purpose Input/Output 0.30

2. AD0.3 - Analog/Digital Converter 0, Input 3
3. EINT3 - External Interrupt 3
4. CAP0.0- Capture input for Timer 0, Channel 0

This 'pin selection' is accomplished with the following line of code.

PINSEL1= (PINSEL1 & (~(3<<28)))|(1<<28);

2. Make sure ADC0 is powered-on (PCONP)

It's always good practice to make sure that a peripheral is powered on (using the PCONP
register) before trying to use it. This can be accomplished for ADC0 with the following line of
code:

// Enable power for ADC0

PCONP |= 0x00001000;

3. Configure ADC0 (ADCR)

Configuring the A/D Converter is probably the most complicated part, since you need to know
certain things about the way your microcontroller is currently set up (primarilly, the value of
PCLK, which determines the 'speed' at which your microcontroller is running). You also need to
do a little bit of math to set everything up properly. It isn't complicated once you understand it,
but it can be intimidating at first to know what all these values mean, and which ones you should
be using in your specific situation.

To configure the A/D Converter, we need to pass a specific 32-bit value to the appropriate
ADCR, or "Analog/Digital Control Register" (see p.270-272 of the LPC21XX User Manual
for more details). This 'control register' manages the configuration of our A/D converter, and
determines a variety of things, including:

1. SEL - Which channel should be used (0..7)

2. CLKDIV - A value to divide PCLK by to determine which speed the A/D Converter
should operate at (up to a maximum of 4.5MHz)
3. CLKS - How precise the conversion results should be (between 3 and 10 bits)
4. PDN - Whether the A/D Converter is currently active (1) or sleeping (0)

The 32-bit Analog/Digital Control Register has the following format:

Unfortunately, that may not make very much sense to you, but without going into every little
detail of every possible configuration option (see p.270-272 for the User's Manual for full
details), we'll try to explain the register values that are being used in the example at the
beginning of this tutorial: SEL, CLKDIV, CLKS and PDN.

SEL

This set of 8 bits corresponds to the 8 different 'channels' available on either A/D converter. You
can indicate which channel you wish to use by setting it's appropriate bit to '1'. For example,
since we are using AD0.3 in this case (channel 3), we would pass the following value to
AD0CR:

CLKDIV

The A/D Converters on the LPC2138 are able to run at a maximum speed of 4.5MHz. The
conversion speed is selectable by the user, but the only catch is that to arrive at a number equal to
or less than 4.5MHz, we need to 'divide' our PCLK (the speed at which our microprocessor is
running) by a fixed number, which we provide (in binary format) using the 8 CLKDIV bits.

The default PCLK for your microcontroller is 12MHz (since the Olimex LPC-P2138 has a
12.0MHz crystal installed on it), but this can be 'multiplied' up to 60MHz, so you need to know
what 'speed' you have set your mcu to before providing a value in CLKDIV.

We are going to assume that we are running at 12.0MHz (since we haven't covered how to adjust
the mcu speed yet!). In order to stay below the ADC's maximum speed of 4.5MHz, we would
need to divide our PCLK (12MHz) by 3, which will give us 4MHz (the closest value we can
have with a 12MHz clock since we need to divide by a whole number). In order to avoid a
'divide by 0' error, though, the A/D control register will add one to whatever value you
supply. This means that if we want to divide the PCLK by 3, we actually need to provide '2',
which will be adjusted up one to '3' by the control register. (This is one of the little details that
can cause your software to malfunction if you don't read the user manual and pay close attention
to how to configure your peripherals.)

This means that if we were running at 12.0MHz, we could achieve a 4.0MHz A/D conversion
speed by setting the following CLKDIV bits in AD0_CR ("00000010" being the binary
equivalent of 2):

And what if we were running at 48.0MHz, for example? We would be able to achieve a
maximum conversion speed of 4.36MHz by dividing 48.0MHz by 11, so we would provide '10'
to the CLKDIV (10 + 1 = 11), as follows ('00001010' being the binary equivalent of 10):

CLKS

These three bits are used to indicate the range of values used when converting analog data. You
can set the 'precision' of the results from 3-bits (values from 0-7) up to 10-bits (values from 0-
1023), depending on your requirements. You simply need to provide one of the following values
to indicate how many 'bits' to use for the conversion:

000 = 10-bits (0..1023)

001 = 9-bits (0..511)
010 = 8-bits (0..255)
011 = 7-bits (0..127)
100 = 6-bits (0..63)
101 = 5-bits (0..31)
110 = 4-bits (0..15)
111 = 3-bits (0..7)

For example, to get the maximum 10-bit 'range', we would provide the following value to the
CLKS field:

PDN

PDN (short for 'Power-Down') indicates whether the ADC should be in 'Power-Down' mode (0),
or actively converting data (1). Since we want to convert data right away, we could tell the ADC
to go out of power-down mode (it's default value) by setting this bit to 1 as follows:

Reading the Conversion Results

Each ADC channel has it's own dedicated data register (ADDR0..7) that we can use to 'read' the
results of the analog to digital conversion, as well to check whether the current conversion is
complete or not. The 32-bit value has the following format:

Function DONE OVERRUN - RESULT -

ADDR Bit(s) 31 30 29..16 15..6 5..0

DONE (Bit 31)

This bit is set to 1 when an A/D conversion is complete. For accurate results, you need to wait
until this value is 1 before reading the RESULT bits. (Please note that this value is cleared when
you read this register.)

OVERRUN (Bit 30)

While not relevant to the examples used in this tutorial, this value with be 1 if the results of one
or more conversions were lost when converting in BURST mode. See the User's Manual for
further details. (As with DONE, this bit will be cleared when you read this register.)

RESULTS (Bits 15..6)

If DONE is 1 (meaning the conversion is complete), these 10 bits will contain a binary number
representing the results of our analog to digital conversion. It works by measuring the voltage on
the analog input pin divided by the voltage on the Vref pin. Zero means that the voltage on the
analog input pin was less than, equal to or close to GND (Vssa), and 0x3FF (or 0011 1111 1111)
indicates that the voltage on the analog input pin was close to, equal to or greater than the the
voltage on the Vref pin. Anything value between these two extremes will be returned as a 10-bit
number (between 0 and 1023).

Before we can read the results from the A/D Data Register, we first need to perform the
following steps (to start the actual conversion process by re-configuring ADCR):

1. Stop any current conversions and deselect all channels

This can be accomplished by modifying the A/D Control Register (see ADCR above) as follows:

AD0CR &= ~(adcr_start_mask|adcr_sel_mask);

What you are doing here is setting the START bits in ADCR to 000 (stopping any conversions)
and disabling any channels that may have been previously selected. This essentially 'resets' our
ADC to a blank, inactive state.

2. Select the channel you wish to use in your conversion

Since we have previously deselected all channels, we need to re-enable the specific channel that
we wish to use in this conversion. In this particular case, we can enable channel 3 with the
following line of code:

AD0CR |=chn;
AD0CR |=adc0_start;

3. Manually tell the ADC to start converting

The ADC can be configured to start in two ways: Manually (as we will do here), or when some
sort of internal hardware event occurs such as an external interrupt (for example when a button
connected to an EINT pin is pressed), or some other form of interrupt. (For details on starting the
conversion when an interrupt occurs, please see chapter 17 of the LPC21XX User's Manual.
Interrupts will also be covered in a later tutorial.)

In our case, the easiest solution is to simply tell the ADC to start converting manually, which is
as simple as setting the appropriate START bits (26..24) in the ADC Control Register (see
ADCR above). To start converting now, we need to send 001 to the three-bit START block in
ADCR, which can be done with the following line of code .

AD0CR |=adc0_start;

4. Wait for the conversion to complete

Now that the analog to digital converter is properly configured and has been started (on channel
3 in this case), we can wait for the results on the appropriate AD Data Register ... ADDR3 in this
particular case. As we mentioned above, we know when a conversion is complete because bit 31
(DONE) of ADDR0..7 will be set to 1. As such, we simply need to wait until we encounter a 1
value on this bit, which can be done with the following line of code:

while(!(AD0DR & (0x80000000)));

This will cause the code to endlessly loop until the conversion is complete, and then move on to
the next line once the conversion is finished.

5. Read the 10-bit conversion results

The last step (now that we know the conversion is complete) is simply to read the 10-bit value
stored in the appropriate ADDR register, and do whatever we need to do with it. This last step
can be accomplished by reading bits 6 through 15 (15..6) of ADDR3 (since we are using Channel
3 in this example), and then 'shifting' the results to the right 6 places to give a normal 10-bit
value:

i=((AD0DR)&(0x0000FFC0))>>6 ;

That's all that's involved in manually starting an A/D conversion and reading the results. If you
wish to continually read the results of the ADC, you can simply place the appropriate code in a
method/function and continually call it, as we are doing in the example.

6.Display the result on the lcd

Since all the values are distributed in the range of 0 – 1023 and with reference to ‘Vref’(which is
3.3V), the following self explanatory code will demonstrate how its done.

val=(float) (val*1000/0x3ff)*3.3;/*Vref = 3.3V*/

Dis_Value[0]=(unsigned char)(val/1000) + 0x30;
Dis_Value[2]=(unsigned char)(val/100%10) + 0x30;
Dis_Value[3]=(unsigned char)(val/10%10) + 0x30;
Dis_Value[4]=(unsigned char)(val%10) + 0x30;

And you can use our lcd program to display the result from here : http://bit.ly/dowbTw

CODE:
#include<lpc213x.h>
#define adc_pin 1<<30
#define pdn_bit 1<<21
#define adcr_start_mask 7<<24
#define adcr_sel_mask 0x000000FF
#define adc0_start 1<<24
void init_adc0(unsigned char,unsigned char);
unsigned char chn;
unsigned int read_adc0();
void delay(int);
unsigned char Dis_Value[5];
main()
{
unsigned int val;
init_adc0(3,3); /*pass channel number and clkdiv*/
Dis_Value[1]=46; /*ascii value for '.' */
while(1)
{
val=read_adc0();
lcd_init();
lcd_clear();
lcd_gotoxy(0,0);
val=(float) (val*1000/0x3ff)*3.3; /*Vref = 3.3V*/
Dis_Value[0]=(unsigned char)(val/1000) + 0x30;
Dis_Value[2]=(unsigned char)(val/100%10) + 0x30;
Dis_Value[3]=(unsigned char)(val/10%10) + 0x30;
Dis_Value[4]=(unsigned char)(val%10) + 0x30;
lcd_print(Dis_Value); /*display the result on LCD*/
delay(1000); /*display the result for some amount of time*/
}
}

void init_adc0(unsigned char ch,unsigned char clk_div)

{
chn=1<<ch;
PINSEL1= (PINSEL1 & (~(3<<28)))|(1<<28); /*Select the
AD0.3 of P0.30*/
PCONP |= 0x00001000; /*Power
on the A/D converter 0 */
AD0CR =(1<<ch) | ( ((clk_div-1))<<8 ) | pdn_bit ; /*configuer
the A/D control register of A/D 0*/
}

unsigned int read_adc0()

{
unsigned int i=0;
AD0CR &= ~(adcr_start_mask|adcr_sel_mask); /*stop the A/D converter by
masking the start bits and channel selection bit*/
AD0CR |=chn; /*Select the A/D channel */

AD0CR |=adc0_start; /*Start the A/D conversion*/

while(!(AD0DR & (0x80000000))); /*Wait for the conversion to get over

by monitoring the 28th bit of A/D data register*/
AD0CR &= ~(adcr_start_mask|adcr_sel_mask); /*Stop the conversion by
masking the start bits*/

i=((AD0DR)&(0x0000FFC0))>>6 ; /*Capture the result by shifting the

bits to 6 places right*/
return(i);
}

/*delay routine for the display purpose*/

void delay(int cnt)
{
int i=0,j=0;
for(i=0;i<=cnt;i++)
for(j=0;j<=35;j++);
}

Download Proteus simulation from here : http://bit.ly/cXnU71