microBuilder.eu

Step 1: Configuring the ADC (ADCR)

Looking at the example code above, you can see that before we can read any results from the ADC we need to configure it (using "adcInit0_3"). In this particular case, we're using AD0.3, which means we are using A/D Converter 0 (the LPC2148 has two ADCs named AD0 and AD1), and channel 3 (out of a possible 8 channels). We chose this particular device and channel because the Olimex LPC-P2148 development board already has a 10K potentiometer on AD0.3 and the pin is conveniently 'broken-out' (you'll find a pin labelled AD03 towards the bottom of the prototyping area on the board).

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, we discuss this in more detail in our description of PINSEL (a set of registers that we can use to indicate exactly which function we would like each pin to perform). In the case of AD0.3 (located on pin 15 of the lpc2148), the pin can be configure to perform any of the following functions (see page 71 of the LPC2148 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 (again, feel free to consult the PINSEL page for more details):

// Force pin 0.30 to function as AD0.3
PCB_PINSEL1 = (PCB_PINSEL1 & ~PCB_PINSEL1_P030_MASK) | PCB_PINSEL1_P030_AD03;

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
SCB_PCONP |= SCB_PCONP_PCAD0;

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 LPC2148 User Manual for more details). This 'control register' (defined in lpc214x.h as 'AD0_CR' and 'AD1_CR') 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.

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)

How does all this relate to our sample code? If we take another look at the configuration values we are passing to AD0_CR we can see that we are setting all four of the fields described above as follows:

// Initialise ADC converter 
// (10-bit accuracy, ADC active, 4.0MHz clock, channel 3 selected)
AD0_CR = AD_CR_CLKS10 | AD_CR_PDN | ((3 - 1) << AD_CR_CLKDIVSHIFT) | AD_CR_SEL3;

This code is using a number of 'aliases' that are defined in lpc214x.h (take a look in the header file to see the corresponding values). We could just as easily have passed the hexadecimal equivalent of these configuration settings to AD0_CR:

AD0_CR = 0x00200208; // = 0000 0 000 00 1 0 000 0 00000010 00001000

The two lines of code would be identical when compiled. The difference is that the first line (the one used in our example) is a little bit easier to understand and to modify later if we need to do so, which is good. It's beyond the scope of this (already lengthy!) tutorial to start describing aliases and bit operators, etc., but a quick summary of the aliases we are using here might be helpful:

1. AD_CR_CLKS10: Sets the bit-accuracy of the converted values to the maximum 10-bit (values between 0 and 1023)
2. AD_CR_PDN: Exits 'powered-down' mode, activating the ADC
3. ((3 - 1) << AD_CR_CLKDIVSHIFT): Set the CLK divider (12MHz/3) and shifts it to the left to it's appropriate position
4. AD_CR_SEL3: Selects AD0 channel 3

Step 2: 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:

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):

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

AD0_CR &= ~(AD_CR_START_MASK | AD_CR_SELMASK);  

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.

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:

AD0_CR |=  (AD_CR_START_NONE | AD_CR_SEL3);

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 LPC2148 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 (AD_CR_START_NOW is defined as '001' in LPC214x.h):

AD0_CR |=   AD_CR_START_NOW;

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 mentionned 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 (!(AD0_DR3 & AD_DR_DONE))
  ;

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.

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 (AD_DR_RESULTSHIFT is defined as 6 in lpc214x.h since we need to shift the results 6 positions to the right):

unsigned int results = ((AD0_DR3 & AD_DR_RESULTMASK) >> AD_DR_RESULTSHIFT); 
return results; 

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 presented at the very beginning of this tutorial.

To make sure that this all make sense to you, try going back to the full example we gave you at the beginning of this article. Reading over the code line by line, can you understand what we're doing and why? If not, simply look at the line(s) you don't understand, and try to find the part of this article that explains that particular step, and why it's necessary or why are are using the values that we assigned. Feel free to consult the complete Crossworks Project that contains this example. It can be downloaded at the bottom of this page and also includes the lpc214x.h file used in all of our examples.