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

 

 

 

 

ATMega644P Graphical LCD Interfacing

Interfacing a graphical LCD to a micro-controller is an interesting stuff beyond a character LCD or a LED matrix display. Most of graphical LCD has a built-in controller for example a well known KS0108 controller chip had been widely used for many years. A monochrome graphical LCD has various size and resolutions, 128x32, 128x64, 128x128, 128x160 and 240x128 etc.

TG12864A-04A 128x32 Dot-matrix and ATMega644P Interfacing 

 

TG12864A-04A and ATMega644P Interfacing 

I bought an old graphical LCD TG12864A-04A that is a 128x32 dot-matrix display with its controller chips  SBN0064G (64-row x 64-column). So this 128x32 dot-matrix LCD needs two SBN0064G chip that will selecting via CS pin.

TG12864A-04A LCM Module Spec

 

It controlling method is very similar to the KS0108 controller chip. I will not explain it here.

 I bought this LCD module nearly 20 years now since I was at high school writing code for the 8051 micro-controller.

This LCM  module use a parallel port interface, 8-bit data bus and a few control lines as shown in the picture above. It allow data read and write via R/W pin. Command and data is set by the D/I (Data/Instruction) pin. However for most text displaying application we just need to write data to this display.

The example below the ATMega644P send some texts to this LCM display.

main.c

1. /*
2. * 8-TG12832A-04A _Text.c
3. *
4. * Created: 1/29/2026 5:51:25 PM
5. * Author : Admin
6. */
7. #include <avr/io.h>
8. #include <avr/pgmspace.h>
9. #include "font5x8.h"
10. 
    
11. #include <util/delay.h>
12. #define F_CPU 16000000UL
13. 
    
14. #define LCD_DATA PORTB
15. #define LCD_CONT PORTD
16. 
    
17. #define LCD_EN 0
18. #define LCD_DI 1
19. #define LCD_CS 2
20. #define LCD_RET 3
21. 
    
22. 
    
23. unsigned char dotCount=0;
24. 
    
25. /*
26. cs = 1 left screen area is selected
27. cs = 0 right screen area is selected
28. */
29. void lcdCommand(unsigned char cmd,char cs){
30. if(cs==1) LCD_CONT|=(1<<LCD_CS);
31. else LCD_CONT&=~(1<<LCD_CS);
32. LCD_CONT&=~(1<<LCD_DI);
34. LCD_DATA=cmd;
35. LCD_CONT|=(1<<LCD_EN);
36. _delay_us(10);
37. LCD_CONT&=~(1<<LCD_EN);
39. //if(cs==1) LCD_CONT&=~(1<<LCD_CS);
40. //else LCD_CONT&=~(1<<LCD_CS);
41. }
42. 
    
43. void lcdData(char data,char cs){
44. if(cs==1) LCD_CONT|=(1<<LCD_CS);
45. else LCD_CONT&=~(1<<LCD_CS);
46. LCD_CONT|=(1<<LCD_DI);
48. LCD_DATA=data;
49. LCD_CONT|=(1<<LCD_EN);
50. _delay_us(10);
51. LCD_CONT&=~(1<<LCD_EN);
53. //if(cs==1) LCD_CONT&=~(1<<LCD_CS1);
54. //else if (cs==2) LCD_CONT&=~(1<<LCD_CS2);
55. }
56. 
    
57. void lcdHorizontal(unsigned char horizontal){
58. lcdCommand(0x40+horizontal,1);
59. lcdCommand(0x40+horizontal,0);
60. }
61. 
    
62. void lcdVerticalLine(unsigned char line){
63. lcdCommand(0xB8+line,1);
64. lcdCommand(0xB8+line,0);
65. dotCount=0;
66. }
67. 
    
68. void lcdSetZ(unsigned char zAxis){
69. lcdCommand(0xC0+zAxis,1);
70. lcdCommand(0xC0+zAxis,0);
71. }
72. 
    
73. void lcdXy(unsigned char x,unsigned char y){
74. if(x<64){
75. lcdCommand(0x40+x,1);
76. lcdCommand(0x40+0,0);
77. }
78. else{
79. lcdCommand(0x40+0,1);
80. lcdCommand(0x40+x-63,0);
81. }
83. lcdCommand(0xB8+y,1);
84. lcdCommand(0xB8+y,0);
85. dotCount=x;
86. }
87. 
    
88. void writeChar(unsigned char aph){
89. for (int i=0;i<5;i++)
90. {
91. char font = pgm_read_byte(&font5x8[((aph-32)*5)+i]);
92. if(dotCount<64) lcdData(font,1);
93. else lcdData(font,0);
94. dotCount++;
95. }
96. lcdData(0,(dotCount<64)?1:0);
97. dotCount++;
98. if (dotCount>127)
99. {
100. dotCount=0;
101. }
102. }
103. 
     
104. void writeCharDelay(unsigned char aph,unsigned int dT){
105. for (int i=0;i<5;i++)
106. {
107. char RomReader = pgm_read_byte(&font5x8[((aph-32)*5)+i]);
108. if(dotCount<64) lcdData(RomReader,1);
109. else lcdData(RomReader,0);
110. if(dT!=0) for(int i=0;i<dT;i++) _delay_us(1000);
111. dotCount++;
112. }
113. lcdData(0,(dotCount<64)?1:0);
114. dotCount++;
115. if (dotCount>127)
116. {
117. dotCount=0;
118. }
119. }
120. 
     
121. void lcdString(char *str){
122. while(*str)
123. writeChar(*str++);
124. if (dotCount>=127)
125. {
126. dotCount=0;
127. }
128. }
129. 
     
130. void writeStringDelay(char *str,unsigned int dT){
131. while(*str){
132. if(dT!=0) writeCharDelay(*str++,dT);
133. else writeChar(*str++);
134. }
135. }
136. 
     
137. void lcdInit(void){
138. DDRB=0xFF;
139. DDRD=0xFF;
140. /*Display On*/
141. lcdCommand(0x3F,1);
142. lcdCommand(0x3F,0);
143. dotCount = 0;
144. }
145. 
     
146. void lcdClearScreen(){
148. for (int i=0;i<4;i++)
149. {
150. lcdXy(0,i);
151. for(int j=0;j<127;j++){
152. lcdData(0,1);
153. lcdData(0,0);
154. }
155. }
156. dotCount=0;
157. lcdXy(0,0);
158. }
159. 
     
160. void lcdClearSection(unsigned char x,unsigned char y,unsigned char dot){
161. lcdXy(x,y);
162. dotCount=x;
163. for (int i=0;i<dot;i++)
164. {
165. if(dotCount<64) lcdData(0,1);
166. else lcdData(0,0);
167. dotCount++;
168. }
169. 
     
170. if (dotCount>128)
171. {
172. dotCount=0;
173. }
174. }
175. 
     
176. 
     
177. 
     
178. int main(void)
179. {
180. //_delay_ms(500);
181. lcdInit();
182. lcdClearScreen();
184. lcdString("ATMega644P AVR GLCD");
185. lcdXy(0,1);
186. lcdString("TG12864A-04A 128x32");
187. lcdXy(0,2);
188. lcdString("Programming With C in");
190. lcdXy(0,3);
191. lcdString("Microchip Studio IDE");
192. while (1)
193. {
195. }
196. }
197. 
     

font5x8.h

1. //#ifdef __AVR__
2. //#include <avr/pgmspace.h>
3. //static const char PROGMEM font5x8[] = {
4. //#else
5. const char font5x8[] PROGMEM= {
6. //#endif
7. 0x00, 0x00, 0x00, 0x00, 0x00,// (spacja)
8. 0x00, 0x00, 0x5F, 0x00, 0x00,// !
9. 0x00, 0x07, 0x00, 0x07, 0x00,// "
10. 0x14, 0x7F, 0x14, 0x7F, 0x14,// #
11. 0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
12. 0x23, 0x13, 0x08, 0x64, 0x62,// %
13. 0x36, 0x49, 0x55, 0x22, 0x50,// &
14. 0x00, 0x05, 0x03, 0x00, 0x00,// '
15. 0x00, 0x1C, 0x22, 0x41, 0x00,// (
16. 0x00, 0x41, 0x22, 0x1C, 0x00,// )
17. 0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
18. 0x08, 0x08, 0x3E, 0x08, 0x08,// +
19. 0x00, 0x50, 0x30, 0x00, 0x00,// ,
20. 0x08, 0x08, 0x08, 0x08, 0x08,// -
21. 0x00, 0x30, 0x30, 0x00, 0x00,// .
22. 0x20, 0x10, 0x08, 0x04, 0x02,// /
23. 0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
24. 0x00, 0x42, 0x7F, 0x40, 0x00,// 1
25. 0x42, 0x61, 0x51, 0x49, 0x46,// 2
26. 0x21, 0x41, 0x45, 0x4B, 0x31,// 3
27. 0x18, 0x14, 0x12, 0x7F, 0x10,// 4
28. 0x27, 0x45, 0x45, 0x45, 0x39,// 5
29. 0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
30. 0x01, 0x71, 0x09, 0x05, 0x03,// 7
31. 0x36, 0x49, 0x49, 0x49, 0x36,// 8
32. 0x06, 0x49, 0x49, 0x29, 0x1E,// 9
33. 0x00, 0x36, 0x36, 0x00, 0x00,// :
34. 0x00, 0x56, 0x36, 0x00, 0x00,// ;
35. 0x00, 0x08, 0x14, 0x22, 0x41,// <
36. 0x14, 0x14, 0x14, 0x14, 0x14,// =
37. 0x41, 0x22, 0x14, 0x08, 0x00,// >
38. 0x02, 0x01, 0x51, 0x09, 0x06,// ?
39. 0x32, 0x49, 0x79, 0x41, 0x3E,// @
40. 0x7E, 0x11, 0x11, 0x11, 0x7E,// A
41. 0x7F, 0x49, 0x49, 0x49, 0x36,// B
42. 0x3E, 0x41, 0x41, 0x41, 0x22,// C
43. 0x7F, 0x41, 0x41, 0x22, 0x1C,// D
44. 0x7F, 0x49, 0x49, 0x49, 0x41,// E
45. 0x7F, 0x09, 0x09, 0x01, 0x01,// F
46. 0x3E, 0x41, 0x41, 0x51, 0x32,// G
47. 0x7F, 0x08, 0x08, 0x08, 0x7F,// H
48. 0x00, 0x41, 0x7F, 0x41, 0x00,// I
49. 0x20, 0x40, 0x41, 0x3F, 0x01,// J
50. 0x7F, 0x08, 0x14, 0x22, 0x41,// K
51. 0x7F, 0x40, 0x40, 0x40, 0x40,// L
52. 0x7F, 0x02, 0x04, 0x02, 0x7F,// M
53. 0x7F, 0x04, 0x08, 0x10, 0x7F,// N
54. 0x3E, 0x41, 0x41, 0x41, 0x3E,// O
55. 0x7F, 0x09, 0x09, 0x09, 0x06,// P
56. 0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
57. 0x7F, 0x09, 0x19, 0x29, 0x46,// R
58. 0x46, 0x49, 0x49, 0x49, 0x31,// S
59. 0x01, 0x01, 0x7F, 0x01, 0x01,// T
60. 0x3F, 0x40, 0x40, 0x40, 0x3F,// U
61. 0x1F, 0x20, 0x40, 0x20, 0x1F,// V
62. 0x7F, 0x20, 0x18, 0x20, 0x7F,// W
63. 0x63, 0x14, 0x08, 0x14, 0x63,// X
64. 0x03, 0x04, 0x78, 0x04, 0x03,// Y
65. 0x61, 0x51, 0x49, 0x45, 0x43,// Z
66. 0x00, 0x00, 0x7F, 0x41, 0x41,// [
67. 0x02, 0x04, 0x08, 0x10, 0x20,// "\"
68. 0x41, 0x41, 0x7F, 0x00, 0x00,// ]
69. 0x04, 0x02, 0x01, 0x02, 0x04,// ^
70. 0x40, 0x40, 0x40, 0x40, 0x40,// _
71. 0x00, 0x01, 0x02, 0x04, 0x00,// `
72. 0x20, 0x54, 0x54, 0x54, 0x78,// a
73. 0x7F, 0x48, 0x44, 0x44, 0x38,// b
74. 0x38, 0x44, 0x44, 0x44, 0x20,// c
75. 0x38, 0x44, 0x44, 0x48, 0x7F,// d
76. 0x38, 0x54, 0x54, 0x54, 0x18,// e
77. 0x08, 0x7E, 0x09, 0x01, 0x02,// f
78. 0x08, 0x14, 0x54, 0x54, 0x3C,// g
79. 0x7F, 0x08, 0x04, 0x04, 0x78,// h
80. 0x00, 0x44, 0x7D, 0x40, 0x00,// i
81. 0x20, 0x40, 0x44, 0x3D, 0x00,// j
82. 0x00, 0x7F, 0x10, 0x28, 0x44,// k
83. 0x00, 0x41, 0x7F, 0x40, 0x00,// l
84. 0x7C, 0x04, 0x18, 0x04, 0x78,// m
85. 0x7C, 0x08, 0x04, 0x04, 0x78,// n
86. 0x38, 0x44, 0x44, 0x44, 0x38,// o
87. 0x7C, 0x14, 0x14, 0x14, 0x08,// p
88. 0x08, 0x14, 0x14, 0x18, 0x7C,// q
89. 0x7C, 0x08, 0x04, 0x04, 0x08,// r
90. 0x48, 0x54, 0x54, 0x54, 0x20,// s
91. 0x04, 0x3F, 0x44, 0x40, 0x20,// t
92. 0x3C, 0x40, 0x40, 0x20, 0x7C,// u
93. 0x1C, 0x20, 0x40, 0x20, 0x1C,// v
94. 0x3C, 0x40, 0x30, 0x40, 0x3C,// w
95. 0x44, 0x28, 0x10, 0x28, 0x44,// x
96. 0x0C, 0x50, 0x50, 0x50, 0x3C,// y
97. 0x44, 0x64, 0x54, 0x4C, 0x44,// z
98. 0x00, 0x08, 0x36, 0x41, 0x00,// {
99. 0x00, 0x00, 0x7F, 0x00, 0x00,// |
100. 0x00, 0x41, 0x36, 0x08, 0x00,// }
101. 0x08, 0x08, 0x2A, 0x1C, 0x08,// ->
102. 0x08, 0x1C, 0x2A, 0x08, 0x08 // <-
103. };
104. //

Schematic:

Schematic 

AVR Prototype Board Test:

  

AVR Prototype Board Test

This PCB was offered from PCBWay. 

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

RT12864J-1 KS0108 128x64 Dot-matrix and ATMega644P Interfacing 

The KS0108 is a popular dot matrix display driver many years now. Currently there are a lot of low power, low cost display driver controllers that are equivalent to this chip. They have many interfaces beyond the parallel port such as SPI and I2C that implements only a few wires.

RT12864J-1 KS0108 128x64 Dot-matrix - TOP

RT12864J-1 KS0108 128x64 Dot-matrix - BOTTOM

 

I have an RT12864J-1 128x64 Graphical Display I bought I from Ebay many years now. But it has some defect due to aging.

A Tested Program Using ATMega32

A Tested Program Using ATMega32

 

 

However this large display use an 8-bit parallel port with some control pins that is very boring for newer electronic hobbyists. There are some wiring issue when installing this display on breadboard that needed to make sure all wires connection. 

To display a graphic we need to create a 128x64 monochrome bitmap image using a PC software for example Adobe Photoshop. Then save it a a monochrome bitmap file. 

LCD Assistance

 

The LCDAssistant.exe tool convert any monochrome bitmap image to a C graphical data that works with any C compilers.

Source Code:

/*
 * 8-RT12864J-1.c
 *
 * Created: 1/30/2026 9:13:54 AM
 * Author : Admin
 */ 

#include <avr/io.h>
#include "font5x8.h"
#include "diy-logo.h"

#include <util/delay.h>
#define F_CPU 16000000UL

#define LCD_DATA PORTB
#define LCD_CONT PORTD

#define LCD_EN		0
#define LCD_RS		1
#define LCD_CS1		3
#define LCD_CS2		2
#define LCD_RST		4

unsigned char dotCount=0;

void lcdCommand(unsigned char cmd,char cs){
	if(cs==1) LCD_CONT|=(1<<LCD_CS1);
	else if(cs==2) LCD_CONT|=(1<<LCD_CS2);
	LCD_CONT&=~(1<<LCD_RS);
	LCD_CONT|=(1<<LCD_EN);
	LCD_DATA=cmd;
	LCD_CONT&=~(1<<LCD_EN);
	_delay_us(10);
	if(cs==1) LCD_CONT&=~(1<<LCD_CS1);
	else if(cs==2) LCD_CONT&=~(1<<LCD_CS2);
}

void lcdData(char  data,char cs){
	if(cs==1) LCD_CONT|=(1<<LCD_CS1);
	else if(cs==2) LCD_CONT|=(1<<LCD_CS2);
	LCD_CONT|=(1<<LCD_RS);
	LCD_CONT|=(1<<LCD_EN);
	LCD_DATA=data;
	LCD_CONT&=~(1<<LCD_EN);
	_delay_us(10);
	if(cs==1) LCD_CONT&=~(1<<LCD_CS1);
	else if (cs==2) LCD_CONT&=~(1<<LCD_CS2);
}

void lcdHorizontal(unsigned char horizontal){
	lcdCommand(0x40+horizontal,1);
	lcdCommand(0x40+horizontal,2);
	
}

void lcdVerticalLine(unsigned char line){
	lcdCommand(0xB8+line,1);
	lcdCommand(0xB8+line,2);
	dotCount=0;
}

void lcdSetZ(unsigned char zAxis){
	lcdCommand(0xC0+zAxis,1);
	lcdCommand(0xC0+zAxis,2);
}

void lcdXy(unsigned char x,unsigned char y){
	if(x<64){
		lcdCommand(0x40+x,1);
		lcdCommand(0x40+0,2);
	}
	else{
		lcdCommand(0x40+0,1);
		lcdCommand(0x40+x-63,2);
	}
	
	lcdCommand(0xB8+y,1);
	lcdCommand(0xB8+y,2);
	dotCount=x;
}

void writeChar(unsigned char aph){
	for (int i=0;i<5;i++)
	{
		if(dotCount<64) lcdData(font5x8[((aph-32)*5)+i],1);
		else lcdData(font5x8[((aph-32)*5)+i],2);
		dotCount++;
	}
	lcdData(0,(dotCount<64)?1:2);
	dotCount++;
	if (dotCount>127)
	{
		dotCount=0;
	}
}

void writeCharDelay(unsigned char aph,unsigned int dT){
	for (int i=0;i<5;i++)
	{
		if(dotCount<64) lcdData(font5x8[((aph-32)*5)+i],1);
		else lcdData(font5x8[((aph-32)*5)+i],2);
		if(dT!=0) for(int i=0;i<dT;i++) _delay_us(1000);
		dotCount++;
	}
	lcdData(0,(dotCount<64)?1:2);
	dotCount++;
	if (dotCount>127)
	{
		dotCount=0;
	}
}

void lcdString(char *str){
	while(*str)
	writeChar(*str++);
}

void writeStringDelay(char *str,unsigned int dT){
	while(*str){
		if(dT!=0) writeCharDelay(*str++,dT);
		else writeChar(*str++);
	}
}

void lcdInit(void){
	DDRB=0xFF;
	DDRD=0xFF;
	/*Display On*/
	lcdCommand(0x3F,1);
	lcdCommand(0x3F,2);
	dotCount = 0;
}

void lcdClearScreen(){
	
	for (int i=0;i<8;i++)
	{
		lcdXy(0,i);
		for(int j=0;j<128;j++){
			lcdData(0,1);
			lcdData(0,2);
		}
	}
	dotCount=0;
	lcdXy(0,0);
}

void lcdClearSection(unsigned char x,unsigned char y,unsigned char dot){
	lcdXy(x,y);
	dotCount=x;
	for (int i=0;i<dot;i++)
	{
		if(dotCount<64) lcdData(0,1);
		else lcdData(0,2);
		dotCount++;
	}

	if (dotCount>127)
	{
		dotCount=0;
	}
}

void showGraphic(void){
	unsigned int kCount=0;
	for (int i=0;i<8;i++)
	{
		
		dotCount=0;
		lcdXy(0,i);
		for (int j=kCount;j<kCount+128;j++)
		{
			if(dotCount<64) lcdData(logo[j],1);
			else lcdData(logo[j],2);
			dotCount++;
		}
		kCount+=128;
	}
}

int main(void)
{
	_delay_ms(100);
	lcdInit();
	lcdClearScreen();
	while (1)
	{
		lcdXy(25,0);
		lcdString("HELLO WORLD!");
		lcdXy(0,1);
		lcdString("ATMEGA644P Graphic");
		lcdXy(0,2);
		lcdString("Programming in C With");
		lcdXy(0,3);
		lcdString("Microchip Studio");
		lcdXy(0,4);
		lcdString("DIY-Instruments");
		lcdXy(0,5);
		lcdString("KS0108 LCD Controller");
		lcdXy(0,6);
		lcdString("RT12864J-1 128x64");
		lcdXy(0,7);
		lcdString("Graphical LCD Module");
		_delay_ms(5000);
		lcdClearScreen();
		
		lcdXy(0,0);
		showGraphic();
		_delay_ms(5000);
		lcdClearScreen();
	}
}

 

Schematic and Simulation: 

Simulation Using Proteus 

 

Simulation Using Proteus 

 

In software it worked fine. But in hardware experiment it has problem due to device defect. I need to fix it later.

For more detail about using this display please see this post. CCS PICC also has a C driver of this LCD. It's very easy to use. This example the PIC16F877A interfaces with a 128x64 KS0108 graphical display.

Click here to download this example.