ATMega644P SPI Nokia 5510 Graphical LCD

Overview 

Nokia 5510 LCD Module is 84x48 monochrome graphical LCD that use a Philip PCD8544 pixel matrix LCD controller/driver. It is very easy to use since it uses only three wires SPI interface with some additional control pin. It configuration setting is simple that is very similar to the KS0108 LCD controller except the three wires SPI interface. Using this interface is easy to connect and maintenance with a master MCU. 

DS1307 Real Time Clock Reading

For a tutorial of using this LCD module with PIC16887 see this post since I don't show any more detail.  For a simple text displaying on this graphical LCD see this post.

Nokia 5110 LCD Module

Nokia 5110 LCD Module Back Side

 A master MCU just need to transmit LCD data or command to this LCD. It only contains a dozen of LCD commands for instance LCD contrast setting and LCD position. Each SPI transmissions contains only one byte of data/command with its active low chip select pin.

Text and Graphic Displaying 

Schematic and Simulation

This simple example the ATMega644p send some text and graphic data to an SPI slave Nokia 5510 graphical LCD.  This PCD8544 controller chip offers a high speed SPI data reception even in serial data mode.

Source Code "main.c":

1. /*
2. * spi_nokia_5510_3.c
3. *
4. * Created: 2/20/2026 11:05:25 AM
5. * Author : Admin
6. */
7. 
   
8. #include <stdio.h>
9. #include <avr/io.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. #define DDR_SPI DDRB
14. #define PRT_SPI PORTB
15. #define DD_MOSI 5
16. #define DD_MISO 6
17. #define DD_SCK 7
18. #define DD_SS 4
19. #define DD_DC 3
20. 
    
21. #include "fonts.h"
22. #include "graphic_84x48.h"
23. 
    
24. const unsigned char lcdX = 48;
25. const unsigned char lcdY = 84;
26. 
    
27. #define selectCommand() PORTB&=~(1<<DD_DC)
28. #define selectData() PORTB|=(1<<DD_DC)
29. 
    
30. void SPI_MasterInit(void)
31. {
32. /* Set MOSI and SCK output, all others input */
33. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
34. /* Enable SPI, Master, set clock rate fck/16 */
35. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
36. }
37. 
    
38. void SPI_MasterTransmit(char cData)
39. {
40. /* Start transmission */
41. SPDR = cData;
42. /* Wait for transmission complete */
43. while(!(SPSR & (1<<SPIF)))
44. ;
45. }
46. 
    
47. void SPI_SlaveInit(void)
48. {
49. /* Set MISO output, all others input */
50. DDR_SPI = (1<<DD_MISO);
51. /* Enable SPI */
52. SPCR = (1<<SPE);
53. }
54. 
    
55. char SPI_SlaveReceive(void)
56. {
57. /* Wait for reception complete */
58. while(!(SPSR & (1<<SPIF)))
59. ;
60. /* Return Data Register */
61. return SPDR;
62. }
63. 
    
64. // Nokia 5510 LCD Command
65. 
    
66. void masterTransmit(char spiData){
67. PRT_SPI&=~(1<<DD_SS);
68. SPI_MasterTransmit(spiData);
69. PRT_SPI|=(1<<DD_SS);
70. }
71. 
    
72. void nokia5510Command(char cmd){
73. selectCommand();
74. masterTransmit(cmd);
75. }
76. 
    
77. void nokia5510Data(char data){
78. selectData();
79. masterTransmit(data);
80. }
81. 
    
82. void nokia5510Char(char _char){
83. selectData();
84. for(char i=0;i<5;i++) {
85. masterTransmit(ASCII[_char-0x20][i]);
86. }
87. masterTransmit(0x00);
88. selectData();
89. }
90. 
    
91. void writeText(char *txt){
92. while(*txt) nokia5510Char(*txt++);
93. }
94. 
    
95. /*Set the cursor*/
96. void setXy(char x,char y){
97. selectCommand();
98. /*x ranges from 0 to 83*/
99. masterTransmit(0x80+(6*x));
100. /*y ranges from 0 to 5*/
101. masterTransmit(0x40+y);
102. selectCommand();
103. }
104. 
     
105. void lcdClear(void){
106. for (int i=0;i<lcdX*lcdY/8;i++)
107. {
108. selectData();
109. masterTransmit(0x00);
110. }
111. selectData();
112. }
113. 
     
114. void nokia5510Init(void){
115. SPI_MasterInit();
116. DDR_SPI|=(1<<DD_DC);
117. nokia5510Command(0x21); // LCD Extended Commands
118. nokia5510Command(0xB5); // SET LCD CONTRAST
119. nokia5510Command(0x04); // set temp coefficient 0x04
120. nokia5510Command(0x14); // LCD bias
121. nokia5510Command(0x20);
122. nokia5510Command(0x0C); // LCD normal Mode
123. }
124. 
     
125. int main(void)
126. {
127. /* Replace with your application code */
128. unsigned long secontCnt=0;
129. char cntString[]="";
130. nokia5510Init();
131. lcdClear();
132. setXy(0,1);
133. writeText("ATMega644P SPI");
134. setXy(0,2);
135. writeText("NOKIA 5510 LCD");
136. setXy(0,3);
137. writeText("Microchip");
138. setXy(0,4);
139. writeText("Studio IDE");
140. _delay_ms(10000);
141. lcdClear();
143. setXy(0,0);
144. for(uint16_t i=0;i<sizeof(graphic_84x48);i++)
145. nokia5510Data(graphic_84x48[i]);
146. _delay_ms(10000);
147. lcdClear();
149. setXy(0,0);
150. writeText("Started Time:");
151. while (1)
152. {
153. sprintf(cntString,"%u",secontCnt);
154. setXy(1,2);
155. writeText(cntString);
156. for(char i=0;i<14;i++) writeText(" ");
157. setXy(1,3);
158. writeText("Seconds");
159. secontCnt++;
160. if(secontCnt>=102) secontCnt=0;
161. _delay_ms(1000);
162. }
163. }
164. 
     

Click here to download this example. 

Tested with ATMega644P

 

Tested with ATMega644P

 

Tested with ATMega644P

 Font Table Creation and ADC Reading

We can create a C font table using Mikroelectrokia GLCD Font Creator that's free to use. It just use the OS installed system font. The user just need to import those font with preferred settings, font name, size, range etc.

Tahoma Font Extracting

 Then we need to export these data with any programming languages data type.

Program C data table export

In this example I use a big tahoma font table for text displaying. The MCU read an analog input value from ADC0 pin.

ADC Reading

 C Source Code "main.c":

/*
 * 12-spi_nokia_5510_ADC.c
 *
 * Created: 2/20/2026 9:51:04 PM
 * Author : Admin
 */ 

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

#define DDR_SPI DDRB
#define PRT_SPI PORTB
#define DD_MOSI 5
#define DD_MISO 6
#define DD_SCK 7
#define DD_SS 4
#define DD_DC 3

#include "fonts.h"
#include "graphic_84x48.h"
#include "tahoma_15x16.h"

const unsigned char lcdX = 48;
const unsigned char lcdY = 84;

#define selectCommand() PORTB&=~(1<<DD_DC)
#define selectData()	PORTB|=(1<<DD_DC)

void SPI_MasterInit(void)
{
	/* Set MOSI and SCK output, all others input */
	DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
	/* Enable SPI, Master, set clock rate fck/16 */
	SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
}

void SPI_MasterTransmit(char cData)
{
	/* Start transmission */
	SPDR = cData;
	/* Wait for transmission complete */
	while(!(SPSR & (1<<SPIF)))
	;
}

void SPI_SlaveInit(void)
{
	/* Set MISO output, all others input */
	DDR_SPI = (1<<DD_MISO);
	/* Enable SPI */
	SPCR = (1<<SPE);
}

char SPI_SlaveReceive(void)
{
	/* Wait for reception complete */
	while(!(SPSR & (1<<SPIF)))
	;
	/* Return Data Register */
	return SPDR;
}

// Nokia 5510 LCD Command

void masterTransmit(char spiData){
	PRT_SPI&=~(1<<DD_SS);
	SPI_MasterTransmit(spiData);
	PRT_SPI|=(1<<DD_SS);	
}

void nokia5510Command(char cmd){
	selectCommand();
	masterTransmit(cmd);
}

void nokia5510Data(char data){
	selectData();
	masterTransmit(data);
}

void nokia5510Char(char _char){
	selectData();
	for(char i=0;i<5;i++) {
		masterTransmit(ASCII[_char-0x20][i]);
	}
	masterTransmit(0x00);
	selectData();
}

void writeText(char *txt){
	while(*txt) nokia5510Char(*txt++);
}

/*Set the cursor*/
void setXy(char x,char y){
	selectCommand();
	/*x ranges from 0 to 83*/
	masterTransmit(0x80+(6*x));
	/*y ranges from 0 to 5*/
	masterTransmit(0x40+y);
	selectCommand();
}

void lcdClear(void){
	for (int i=0;i<lcdX*lcdY/8;i++)
	{
		selectData();
		masterTransmit(0x00);
	}
	selectData();
}

void nokia5510Init(void){
	SPI_MasterInit();
	DDR_SPI|=(1<<DD_DC);
	nokia5510Command(0x21); // LCD Extended Commands
	nokia5510Command(0xB5); // SET LCD CONTRAST
	nokia5510Command(0x04); // set temp coefficient 0x04
	nokia5510Command(0x14); // LCD bias
	nokia5510Command(0x20);
	nokia5510Command(0x0C); // LCD normal Mode
}

void lcd_xy(int8_t x, int8_t y){
	if(x<84)    nokia5510Command(0x80+x);
	if(y<6)     nokia5510Command(0x40+y);
}

void lcd_char_tahoma_15x16(int8_t x, int8_t y, uint8_t ch){
	uint16_t c=x*2;
	for(uint8_t i=0;i<30;i++){
		if(i%2) {lcd_xy(c/2,y+1); nokia5510Data(Tahoma15x16[ch-0x20][i]);}
		else {lcd_xy(c/2,y); nokia5510Data(Tahoma15x16[ch-0x20][i]);}
		c++;
	}
}

void lcd_text_tahoma(int8_t x, int8_t y, uint8_t *text){
	//char x_count=0;
	while(*text) { 
		lcd_char_tahoma_15x16(x, y, *text++);
		x+=15;
	}
}

int main(void)
{
    /* Replace with your application code */
	nokia5510Init();
	lcdClear();
	
	//setXy(0,0);
	lcd_text_tahoma(0,0,"Nokia");
	lcd_text_tahoma(0,2,"5510");
	lcd_text_tahoma(0,4,"GLCD");
	DDRB&=~(1<<0);
	ADCSRA=(1<<ADEN);
	ADMUX=0;
	char msg[4];
	_delay_ms(10000);
	lcdClear();
    while (1) 
    {
	//Start the conversion
	ADCSRA|=(1<<ADSC);
	//Wait for the completion
	while((ADCSRA&(1<<ADSC))==1);
	//Read the result
	unsigned int temp =ADCL+(ADCH<<8);
	float voltage = (temp*5.0)/1023;
	lcd_text_tahoma(0,0,"ADC0:");
	sprintf(msg,"%04d",temp);
	lcd_text_tahoma(0,2,msg);
	sprintf(msg,"%0.2fV",voltage);
	lcd_text_tahoma(0,4,msg);
	_delay_ms(100);
    }
}

AVR ATMega644P Experiment Board:

AVR ATMega644P Experiment Board

 

AVR ATMega644P Experiment Board

 Click here to download this example.

DS1307 Real Time Clock Reading

This small display can show some readable text. So I tested it with a ds1307 real time clock chip. I use a software TWI instead of a dedicated hardware TWI. 

Real Time Clock Reading

 Source Code "main.c":

 

1. /*
2. * 12-spi_nokia_5510_RTC.c
3. *
4. * Created: 2/21/2026 11:46:38 AM
5. * Author : Admin
6. */
7. 
   
8. #include <stdio.h>
9. #include <avr/io.h>
10. #include <util/delay.h>
11. #define F_CPU 16000000UL
12. 
    
13. #define DDR_SPI DDRB
14. #define PRT_SPI PORTB
15. #define DD_MOSI 5
16. #define DD_MISO 6
17. #define DD_SCK 7
18. #define DD_SS 4
19. #define DD_DC 3
20. 
    
21. #include "fonts.h"
22. #include "graphic_84x48.h"
23. #include "tahoma_15x16.h"
24. #include "twi_device.h"
25. 
    
26. const unsigned char lcdX = 48;
27. const unsigned char lcdY = 84;
28. 
    
29. #define selectCommand() PORTB&=~(1<<DD_DC)
30. #define selectData() PORTB|=(1<<DD_DC)
31. 
    
32. void SPI_MasterInit(void)
33. {
34. /* Set MOSI and SCK output, all others input */
35. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
36. /* Enable SPI, Master, set clock rate fck/16 */
37. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
38. }
39. 
    
40. void SPI_MasterTransmit(char cData)
41. {
42. /* Start transmission */
43. SPDR = cData;
44. /* Wait for transmission complete */
45. while(!(SPSR & (1<<SPIF)))
46. ;
47. }
48. 
    
49. void SPI_SlaveInit(void)
50. {
51. /* Set MISO output, all others input */
52. DDR_SPI = (1<<DD_MISO);
53. /* Enable SPI */
54. SPCR = (1<<SPE);
55. }
56. 
    
57. char SPI_SlaveReceive(void)
58. {
59. /* Wait for reception complete */
60. while(!(SPSR & (1<<SPIF)))
61. ;
62. /* Return Data Register */
63. return SPDR;
64. }
65. 
    
66. // Nokia 5510 LCD Command
67. 
    
68. void masterTransmit(char spiData){
69. PRT_SPI&=~(1<<DD_SS);
70. SPI_MasterTransmit(spiData);
71. PRT_SPI|=(1<<DD_SS);
72. }
73. 
    
74. void nokia5510Command(char cmd){
75. selectCommand();
76. masterTransmit(cmd);
77. }
78. 
    
79. void nokia5510Data(char data){
80. selectData();
81. masterTransmit(data);
82. }
83. 
    
84. void nokia5510Char(char _char){
85. selectData();
86. for(char i=0;i<5;i++) {
87. masterTransmit(ASCII[_char-0x20][i]);
88. }
89. masterTransmit(0x00);
90. selectData();
91. }
92. 
    
93. void writeText(char *txt){
94. while(*txt) nokia5510Char(*txt++);
95. }
96. 
    
97. /*Set the cursor*/
98. void setXy(char x,char y){
99. selectCommand();
100. /*x ranges from 0 to 83*/
101. masterTransmit(0x80+(6*x));
102. /*y ranges from 0 to 5*/
103. masterTransmit(0x40+y);
104. selectCommand();
105. }
106. 
     
107. void lcdClear(void){
108. for (int i=0;i<lcdX*lcdY/8;i++)
109. {
110. selectData();
111. masterTransmit(0x00);
112. }
113. selectData();
114. }
115. 
     
116. void nokia5510Init(void){
117. SPI_MasterInit();
118. DDR_SPI|=(1<<DD_DC);
119. nokia5510Command(0x21); // LCD Extended Commands
120. nokia5510Command(0xB5); // SET LCD CONTRAST
121. nokia5510Command(0x04); // set temp coefficient 0x04
122. nokia5510Command(0x14); // LCD bias
123. nokia5510Command(0x20);
124. nokia5510Command(0x0C); // LCD normal Mode
125. }
126. 
     
127. void lcd_xy(int8_t x, int8_t y){
128. if(x<84) nokia5510Command(0x80+x);
129. if(y<6) nokia5510Command(0x40+y);
130. }
131. 
     
132. void lcd_char_tahoma_15x16(int8_t x, int8_t y, uint8_t ch){
133. uint16_t c=x*2;
134. for(uint8_t i=0;i<30;i++){
135. if(i%2) {lcd_xy(c/2,y+1); nokia5510Data(Tahoma15x16[ch-0x20][i]);}
136. else {lcd_xy(c/2,y); nokia5510Data(Tahoma15x16[ch-0x20][i]);}
137. c++;
138. }
139. }
140. 
     
141. void lcd_text_tahoma(int8_t x, int8_t y, uint8_t *text){
142. //char x_count=0;
143. while(*text) {
144. lcd_char_tahoma_15x16(x, y, *text++);
145. x+=15;
146. }
147. }
148. 
     
149. void rtc_init(void){
150. char rtc[8]={0x30,0x35,0x13,0x07,0x31,0x01,0x26,1<<4};
151. for (char i=0;i<8;i++)
152. {
153. twi_start();
154. //D0 is DS1307 Write Address
155. twi_write(DS1307_W);
156. //Select Control Register
157. twi_write(i);
158. //Enable SQWE bit blinks at 1 Hz
159. twi_write(rtc[i]);
160. twi_stop();
161. _delay_ms(10);
162. }
163. }
164. 
     
165. unsigned char rtc[50], msg[20];
166. 
     
167. void rtc_read(void){
168. for(char i=0;i<50;i++){
169. /*Second Register*/
170. twi_start();
171. twi_write(DS1307_W);
172. /*Select Second register*/
173. twi_write(i);
174. twi_stop();
175. _delay_us(100);
177. twi_start();
178. twi_write(DS1307_R);
179. rtc[i]=twi_read();
180. twi_stop();
181. _delay_us(100);
182. }
183. }
184. 
     
185. int main(void)
186. {
187. /* Replace with your application code */
188. nokia5510Init();
189. lcdClear();
190. setXy(0,0);
191. writeText("ATMega644P SPI");
192. setXy(0,1);
193. writeText("NOKIA 5510 LCD");
194. setXy(0,2);
195. writeText("DS1307 RTC");
196. setXy(0,3);
197. writeText("Software TWI");
198. _delay_ms(10000);
199. lcdClear();
200. char msg[4];
201. //rtc_init();
202. while (1)
203. {
204. rtc_read();
205. setXy(0,0); writeText("DS1307 Real");
206. setXy(0,1); writeText("Time Clock:");
207. setXy(0,2); writeText("Time:");
208. sprintf(msg,"%02X:%02X:%02X",rtc[2],rtc[1],rtc[0]);
209. setXy(0,3); writeText(msg);
210. setXy(0,4); writeText("Date:");
211. sprintf(msg,"%02X/%02X/20%02X",rtc[4],rtc[5],rtc[6]);
212. setXy(0,5); writeText(msg);
213. _delay_ms(100);
214. }
215. }
216. 
     
217. 
     
218. 
     
219. 
     
220. 
     

ATMega644P AVR  Prototype Board: 

ATMega644P AVR  Prototype Board

 

ATMega644P AVR  Prototype Board

 

Click here to download this example. 

 

ATMega644P SPI SN74HC595 and SN74HC165 4x8 Matrix KeyPad Driving

In previous post I use these two SPI chips, SN74HC595 and SN74HC165 to expand the inputs/outputs of an MCU. Here I use these two chip pair to make a matrix keypad. These two 8-bit I/O expansion chip can build up to a 8x8 matrix keypad that yield 64 different keys. But I make only a 4x8 matrix keypad since it's not important.

Simulating Program

The 8-bit output port of the SN74HC595 is a column scanner while the lower nibble input port of the SN74HC165 is a row detector (active high). Whenever any key press found the program assign a specific key in its keypad array.

Source Code "main.c":

1. /*
2. * 12-spi_sn74hc165_sn74hc595n_keypad.c
3. *
4. * Created: 2/18/2026 2:03:34 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #define DDR_SPI DDRB
13. #define PRT_SPI PORTB
14. 
    
15. #define DD_SH 3
16. #define DD_SS 4
17. #define DD_MOSI 5
18. #define DD_MISO 6
19. #define DD_SCK 7
20. 
    
21. 
    
22. void SPI_MasterInit(void)
23. {
24. /* Set MOSI and SCK output, all others input */
25. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
26. /* Enable SPI, Master, set clock rate fck/16 */
27. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
28. }
29. 
    
30. void SPI_MasterTransmit(char cData)
31. {
32. /* Start transmission */
33. SPDR = cData;
34. /* Wait for transmission complete */
35. while(!(SPSR & (1<<SPIF)))
36. ;
37. }
38. 
    
39. void SPI_SlaveInit(void)
40. {
41. /* Set MISO output, all others input */
42. DDR_SPI = (1<<DD_MISO);
43. /* Enable SPI */
44. SPCR = (1<<SPE);
45. }
46. char SPI_SlaveReceive(void)
47. {
48. /* Wait for reception complete */
49. while(!(SPSR & (1<<SPIF)))
50. ;
51. /* Return Data Register */
52. return SPDR;
53. }
54. 
    
55. const char key_16[4][8]={'1','2','3','4','5','6','7','8',
56. '9','0','A','B','C','D','E','F',
57. 'G','H','I','J','K','L','M','N',
58. 'O','P','Q','R','S','T','U','V'};
59. 
    
60. char key_scan(void){
61. char data=0,temp,key;
62. for(char i=0;i<8;i++){
63. SPI_MasterTransmit(1<<i);
64. PRT_SPI&=~(1<<DD_SS);
65. _delay_us(10);
66. PRT_SPI|=(1<<DD_SS);
67. _delay_ms(5);
68. PRT_SPI&=~(1<<DD_SH);
69. PRT_SPI|=(1<<DD_SH);
70. SPI_MasterTransmit(0);
71. data=SPI_SlaveReceive();
73. if(data==0x01) {temp=key_16[0][i]; break;}
74. else if(data==0x02) {temp=key_16[1][i]; break;}
75. else if(data==0x04){temp=key_16[2][i]; break;}
76. else if(data==0x08){temp=key_16[3][i]; break;}
77. else temp=0;
78. _delay_ms(10);
79. }
80. return temp;
81. }
82. 
    
83. int main(void)
84. {
85. /* Replace with your application code */
86. SPI_MasterInit();
87. lcd_init();
88. DDR_SPI|=(1<<DD_SH);
89. char data=0;
90. char temp,charCount=0,newLine=0,line=1;
91. lcd_text("ATMega644P SPI");
92. lcd_xy(1,2);
93. lcd_text("MATRIX KEYPAD");
94. _delay_ms(5000);
95. lcd_clear();
96. while (1)
97. {
98. temp=key_scan();
99. if(temp!=0){
100. lcd_data(temp);
101. charCount++;
102. _delay_ms(500);
103. }
104. if(charCount>16){
105. newLine=1;
106. charCount=0;
107. line+=1;
108. }
109. if(newLine){
110. newLine=0;
111. if(line==2) lcd_xy(1,2);
112. else{
113. lcd_xy(1,1);
114. lcd_command(0x01);
115. _delay_ms(5);
116. line=1;
118. }
119. }
120. _delay_ms(100);
122. }
123. }
124. 
     
125. 
     
126. 
     
127. 
     
128. 
     

The character LCD uses the parallel port of the ATMega644P. But we can control this LCD by adding one more SN74HC595 and one additional Slave Select (SS) pin. 

Simulating Program

I separate these two chip using different Slave Select pins. The SN74HC165 doesn't need serial data input. It only need serial clock and Slave Select pins controlled by the MCU. However I think we can cascade this two chip using a shared SPI pins. If I have more time I will test it using this method.

 

For a full tutorial page of ATMega644P Programming Using C please visit this page.