ATMega644P Analog to Digital Converter (ADC) Example

Overview

The Analog to Digital Converter (ADC) convert analog voltage value to a digital representation that the micro-processor could understand. Most of modern micro-controller has at least one built-in ADC module that can be use by software configuration. The most common ADC resolution is between 8-bit and 12-bit with an acceptable conversion rate.

 

The resolution give more precise digital data for the micro-controller. However its reference voltage and lower clock also effect the precision of the analog input value. Some 32-bit micro-controller especially the STM32 micro-controller series has an ADC module with the resolution of 12-bit with the conversion rate up to 2MSPS. Some 16-bit dsPIC micro-controller series has an ADC module with the resolution of 10-bit and 1~2MSPS conversion rate.

Commonly we use the ADC to read temperature value, flex sensor and strain gauge etc.

ATMega644P ADC Programming Example

The ADC of the ATMega644P has a 10-bit analog to digital converter with the maximum conversion rate up to 15kSPS. It has up to 8 analog input channel (ADC7:ADC0) via PortA. The conversion triggers by user software (set ADC to start) or by any interrupt sources.

Analog-to-digital Converter Block Schematic

 

The software configuration of the ADC module of AVR micro-controller is simpler than other micro-controllers. It has a few registers to configure. 

I don't write its detail here since the ADC process of the ATMega644P is very similar to the ATMega32. 

ADC and LED Example 1

In this introductory example the ATMega644P read the analog input from ADC0(PA0). The 10-bit ADC result will converts to 8-bit by shifting right that will display on PORTB.

C Source Code:

1. /*
2. * 9-ADC_LED.c
3. *
4. * Created: 1/30/2026 3:28:06 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. 
   
10. int main(void)
11. {
13. DDRB=0xFF;
14. //PA0 or ADC0 as an analog input
15. DDRA=0;
16. //Turn on the ADC module
17. ADCSRA=(1<<ADEN);
18. uint16_t temp;
19. while (1)
20. {
21. //Start the conversion
22. ADCSRA|=(1<<ADSC);
23. //Wait for the completion
24. while((ADCSRA&(1<<ADSC))==1);
25. //Read the result
26. temp=ADCL+(ADCH<<8);
27. PORTB=temp>>2;
28. }
29. }
30.  

Proteus Simulation:

Proteus Simulation #1

AVR Prototype Board Test:

 

ADC and LED Example 2

I use this prototype board's LED and POT to make a LED shifting using the ADC voltage level. It's very similar to a ring counter. However I need to convert between ADC value counter value.

Source Code:

1. /*
2. * 9-ADC_BarGraph.c
3. *
4. * Created: 1/30/2026 4:21:13 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. 
   
10. int main(void)
11. {
13. DDRB=0xFF;
14. //PA0 or ADC0 as an analog input
15. DDRA=0;
16. //Turn on the ADC module
17. ADCSRA=(1<<ADEN);
18. long temp,div;
19. while (1)
20. {
21. //Start the conversion
22. ADCSRA|=(1<<ADSC);
23. //Wait for the completion
24. while((ADCSRA&(1<<ADSC))==1);
25. //Read the result
26. temp=ADCL+(ADCH<<8);
27. div=(temp*8)/1024;
28. PORTB=(1<<div);
29. }
30. }
31. 
    

Proteus Schematic and Simulation:

Proteus Schematic and Simulation

AVR Prototype Board Test: 

 

ADC and LED Example 2

There are two on-board ADC inputs, POT and LM35 temperature sensor. The LCD will display the analog input from POT(ADC0) and LM35(ADC1). The LM35 temperature (in degree Celsius) is equivalent to 10mV that's 2 in digital value (+5.0VDC voltage reference).

LM35DZ in TO-92 Package

 

Source Code:

1. /*
2. * 9-ADC_LCD.c
3. *
4. * Created: 1/30/2026 4:47:25 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <stdio.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. void adc_init(void){
14. /*Set PA0 and PA1 to input*/
15. DDRA&=~(1<<0);
16. DDRA&=~(1<<1);
17. ADCSRA=(1<<ADEN);
18. /*Select AD0*/
19. ADMUX=0x03;
20. }
21. 
    
22. unsigned int read_adc(char channel){
23. //Select Channel
24. ADMUX=channel;
25. //Start Convsersion
26. ADCSRA|=(1<<ADSC);
27. //Wait for Completion
28. while(ADCSRA&(1<<ADSC));
29. //Get the 10-bit values
30. return (ADCL+(ADCH<<8));
31. }
32. int main(void)
33. {
34. /* Replace with your application code */
35. lcd_init();
36. lcd_text("ATMega644P ADC");
37. lcd_xy(1,2);
38. lcd_text("POT AND LM35");
39. adc_init();
40. _delay_ms(1000);
41. lcd_clear();
42. unsigned int temp;
43. float voltage;
44. char msg[16];
45. lcd_command(0x0C);
47. while (1)
48. {
49. //Read POT
50. temp=read_adc(0);
51. //Convert To Voltage
52. voltage=temp*5.0/1023;
53. sprintf(msg,"ADC0: %4d %.2fV",temp,voltage);
54. lcd_xy(1,1); lcd_text(msg);
55. //Read LM35
56. temp=read_adc(1);
57. voltage=temp*5.0/1023;
58. voltage*=100;
59. sprintf(msg,"Temp: %0.1f%cC",voltage,223);
60. lcd_xy(1,2); lcd_text(msg);
61. _delay_ms(1000);
62. }
63. }
64. 
    

Proteus Schematic:

Proteus Schematic

AVR Prototype Board: 

Program Tested on my AVR Prototype Board

Unfortunately I bough some fake LM35DZ due to their local availability and low cost, around 0.50USD. The original LM35DZ(TO92) temperature chip costs around 1USD. However some online store also sell this chip in bulk price at very low cost.

I have been using PCBWay for many years now. PCBWay fabricate PCBs at low cost, fast processing time for only 24 hours, and fast delivery time using any carrier options. This double side 10cmx10cm can be fabricate at only 5USD for 5 to 10pcs by PCBWay. It's a standard PCB with silk screen and solder mask.

10 PCBs for only 5USD

 

For different size of PCB we can instantly quote on PCBWay website using a zip PCB Gerber file without account.

PCBWay Instant Quote

 

 

 

 

ATMega32 Interfaces To LM35 And 16x2 Character LCD

Overview

In some previous post, I have wrote some posts about analog to digital convert. This peripheral converts any analog output devices and converter them to digital value. Some analog output sensor like LM35 creates an analog voltage output linear to its 10 mV step temperature value.

A display device show the information or status of the MCU and other input output devices. I posted some examples on using the industrial standard HD44780 LCD controller.

Example Program

In this example post, ATMega32 reads the analog temperature value and just display this information to the display. The temperature is in both degree Celsius and degree Fahrenheit.

Interfacing And Programming

LM35 connects to the analog input pin ADC7 - the user could select any analog pin within its 8 analog inputs. The MCU clocks at 16 MHz due to a pre-soldered crystal on the learning board. However, I set the ADC conversion clock rate to 1:128.

LM35DZ in TO-92 Package

The display operates in 4-bit interfacing mode. A single PORTD of the MCU is sufficient to do this task.

Schematic Diagram

C source code of this example lists below, click here to download a zip archive.

Note: Without configuring the sprintf() function in the project property, it can't convert the float data type to string value. We must the project properties as follow.

1. Open the project properties by pressing ALT+F7. 

Tick the required tick box as shown in the picture

1. Fill the required link flag

Fill the text box with this string "-lprintf_flt"

Then we can use the sprintf() function with float data type properly. If you still have the problem with sprintf(), see this link because I got it work from there.

Temperature reading from LM35 with ADC module of ATMega32

In this ADC module, we have an easy example of interfacing with device ADC. LM35 is analog temperature sensor capable of measuring the temperature between -55 to 150 degree Celsius. It outputs an analog voltage value that is 10 mV per degree Celsius proportionally. For more information please see this post.

A sample picture and pin diagram of LM35

In this example the system could only read the positive temperature value. Because I have some difficulty of working with negative voltage reading at this time.

LM35 connects to ADC0. There is no negative temperature reading here.

Source code:

#include <avr/io.h>
#define  F_CPU 4000000UL
#include <util/delay.h>
int main(void)
{ float voltage;
 float temperature;
 int _temperature;
 char ssd[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,
 0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
 //PortC as output
 DDRC=0xFF;
 //PortD as output
 DDRD=0xFF;
 //PA0 or ADC0 as an analog input
 DDRA=0;
 //Turn on the ADC module
 ADCSRA|=(1<<ADEN);
 while (1)
 {
  //Start the conversion
  ADCSRA|=(1<<ADSC);
  //Wait for the completion
  while((ADCSRA&(1<<ADSC))==1);
  /*Convert ADC to voltage*/
  voltage=(ADCL+(ADCH<<8))*5.0/1024;
  /*Convert to temperature*/
  temperature=voltage*100;
  /*make dot point*/
  temperature*=10;
  _temperature=(int)temperature;
  /*Displaying the Data*/
  PORTD=0x00;
  PORTC=ssd[_temperature/1000];
  if(_temperature>=1000) PORTD=0x01;
  _delay_ms(10);
  PORTD=0x00;
  PORTC=ssd[(_temperature%1000)/100];
  PORTD=0x02;
  _delay_ms(10);
  PORTD=0x00;
  PORTC=ssd[(_temperature%100)/10]|0x80;
  PORTD=0x04;
  _delay_ms(10);
  PORTD=0x00;
  PORTC=ssd[_temperature%10];
  PORTD=0x08;
  _delay_ms(10);
   }
}

Back to main tutorial page ATMega32 tutorials in C with Atmel Studio 7.

Click here to download its source file.