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.