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. 

ATMega644P SPI SN74HC595N TC1604A LCD

The SN74HC595N is an output expansion chip that could drive any devices, LED, relay or even writing data to LCD. A character LCD is easily controlled by this chip in write mode. A single chip SN74HC595N can control the HD44780 using its 4-bit data transfer mode.

 

 

 

In this example the ATMega644P master SPI send HD44780 LCD data and command to the LCD via an SN74HC595N shift registers chip.

A finished Assembling. SN74HC595N is soldered on-board. A 16x4 LCD stays at the top.

 

Soldering side

 

Schematic Diagram

 The original post uses Arduino Uno to control this LCD module.

Source Code "main.c":

1. /*
2. * 12-spi_74hc595_1604.c
3. *
4. * Created: 2/17/2026 3:27:49 PM
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. 
    
20. void SPI_MasterInit(void)
21. {
22. /* Set MOSI and SCK output, all others input */
23. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
24. /* Enable SPI, Master, set clock rate fck/16
25. data is sample at the falling edge of SCK*/
26. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
27. }
28. 
    
29. void SPI_MasterTransmit(char cData)
30. {
31. /* Start transmission */
32. SPDR = cData;
33. /* Wait for transmission complete */
34. while(!(SPSR & (1<<SPIF)))
35. ;
36. }
37. 
    
38. void SPI_SlaveInit(void)
39. {
40. /* Set MISO output, all others input */
41. DDR_SPI = (1<<DD_MISO);
42. /* Enable SPI */
43. SPCR = (1<<SPE);
44. }
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. /*TWI LCD Driver*/
56. #define RS 1
57. #define RW 2
58. #define EN 3
59. #define BL 0
60. 
    
61. 
    
62. char backLight=0;
63. 
    
64. void lcd_delay(unsigned int counts){
65. for (unsigned int i=0;i<counts;i++);
66. }
67. 
    
68. void spi_lcd_command(char command){
69. char data;
70. data=command&0xF0;
71. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN));
72. PRT_SPI&=~(1<<DD_SS);
73. PRT_SPI|=(1<<DD_SS);
75. SPI_MasterTransmit(data|(backLight<<BL));
76. PRT_SPI&=~(1<<DD_SS);
77. PRT_SPI|=(1<<DD_SS);
79. data=command<<4;
80. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN));
81. PRT_SPI&=~(1<<DD_SS);
82. lcd_delay(10);
83. PRT_SPI|=(1<<DD_SS);
84. SPI_MasterTransmit(data|(backLight<<BL));
85. PRT_SPI&=~(1<<DD_SS);
86. PRT_SPI|=(1<<DD_SS);
87. }
88. 
    
89. void spi_lcd_data(char command){
90. char data;
91. data=command&0xF0;
92. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN)|(1<<RS));
93. PRT_SPI&=~(1<<DD_SS);
94. PRT_SPI|=(1<<DD_SS);
95. SPI_MasterTransmit(data|(backLight<<BL)|(1<<RS));
96. PRT_SPI&=~(1<<DD_SS);
97. PRT_SPI|=(1<<DD_SS);
98. lcd_delay(50);
100. data=command<<4;
101. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN)|(1<<RS));
102. PRT_SPI&=~(1<<DD_SS);
103. PRT_SPI|=(1<<DD_SS);
104. SPI_MasterTransmit(data|(backLight<<BL)|(1<<RS));
105. PRT_SPI&=~(1<<DD_SS);
106. PRT_SPI|=(1<<DD_SS);
107. }
108. 
     
109. void spi_lcd_xy(int8_t x, int8_t y){
110. //16x2
111. //char addr[]={0x80,0xC0};
112. //16x4
113. char addr[]={0x80,0xC0,0x90,0xD0};
114. spi_lcd_command(addr[y-1]+x-1);
115. }
116. 
     
117. void spi_lcd_line_1(void){
118. spi_lcd_command(0x80);
119. }
120. 
     
121. void spi_lcd_line_2(void){
122. spi_lcd_command(0xC0);
123. }
124. 
     
125. void spi_lcd_line_3(void){
126. spi_lcd_command(0x90);
127. }
128. 
     
129. void spi_lcd_line_4(void){
130. spi_lcd_command(0xD0);
131. }
132. 
     
133. void spi_lcd_cursor_off(void){
134. spi_lcd_command(0x0C);
135. }
136. 
     
137. void spi_lcd_text(char *txt){
138. while(*txt) spi_lcd_data(*txt++);
139. }
140. 
     
141. void i2c_lcdClear(void){
142. spi_lcd_command(0x01);
143. _delay_ms(10);
144. }
145. 
     
146. void spi_lcd_init(void){
148. SPI_MasterTransmit(0);
149. lcd_delay(500);
150. spi_lcd_command(0x33);
151. lcd_delay(10);
152. spi_lcd_command(0x32);
153. lcd_delay(10);
154. spi_lcd_command(0x28);
155. lcd_delay(10);
156. spi_lcd_command(0x0F);
157. lcd_delay(10);
158. spi_lcd_command(0x01);
159. _delay_ms(10);
160. spi_lcd_command(0x06);
161. lcd_delay(10);
162. }
163. 
     
164. int main(void)
165. {
166. /* Replace with your application code */
167. _delay_ms(1000);
168. SPI_MasterInit();
169. PRT_SPI|=(1<<DD_SS); //Set CS Pin High
170. spi_lcd_init();
171. spi_lcd_line_1();
172. spi_lcd_text("ATMega644P SPI");
173. spi_lcd_line_2();
174. spi_lcd_text("SN74HC595N LCD");
175. spi_lcd_line_3();
176. spi_lcd_text("TC1604A-01(R)");
177. spi_lcd_line_4();
178. spi_lcd_text("Example Using C");
179. unsigned char data[7],msg[16];
180. while (1)
181. {
183. }
184. }
185. 
     
186. 
     
187. 
     
188. 
     

AVR Hardware Experiment:

Tested ATMega644P

For a full tutorial list of ATMega644P using C in Microchip Studio IDE please see this page.

On-Board DS1307 Real Time Clock

I use a software TWI I wrote to read date and time from the on-board DS1307 RTC that will show on this SPI LCD. 

AVR ATMega644P Experiment Board

 Source Code "main.c":

1. /*
2. * ds1307_1604.c
3. *
4. * Created: 2/19/2026 2:09:32 PM
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. 
    
20. void SPI_MasterInit(void)
21. {
22. /* Set MOSI and SCK output, all others input */
23. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
24. /* Enable SPI, Master, set clock rate fck/16 */
25. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
26. }
27. 
    
28. void SPI_MasterTransmit(char cData)
29. {
30. /* Start transmission */
31. SPDR = cData;
32. /* Wait for transmission complete */
33. while(!(SPSR & (1<<SPIF)))
34. ;
35. }
36. 
    
37. void SPI_SlaveInit(void)
38. {
39. /* Set MISO output, all others input */
40. DDR_SPI = (1<<DD_MISO);
41. /* Enable SPI */
42. SPCR = (1<<SPE);
43. }
44. 
    
45. char SPI_SlaveReceive(void)
46. {
47. /* Wait for reception complete */
48. while(!(SPSR & (1<<SPIF)))
49. ;
50. /* Return Data Register */
51. return SPDR;
52. }
53. 
    
54. /*TWI LCD Driver*/
55. #define RS 1
56. #define RW 2
57. #define EN 3
58. #define BL 0
59. 
    
60. 
    
61. char backLight=0;
62. 
    
63. void lcd_delay(unsigned int counts){
64. for (unsigned int i=0;i<counts;i++);
65. }
66. 
    
67. void spi_lcd_command(char command){
68. char data;
69. data=command&0xF0;
70. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN));
71. PRT_SPI&=~(1<<DD_SS);
72. PRT_SPI|=(1<<DD_SS);
74. SPI_MasterTransmit(data|(backLight<<BL));
75. PRT_SPI&=~(1<<DD_SS);
76. PRT_SPI|=(1<<DD_SS);
78. data=command<<4;
79. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN));
80. PRT_SPI&=~(1<<DD_SS);
81. lcd_delay(10);
82. PRT_SPI|=(1<<DD_SS);
83. SPI_MasterTransmit(data|(backLight<<BL));
84. PRT_SPI&=~(1<<DD_SS);
85. PRT_SPI|=(1<<DD_SS);
86. }
87. 
    
88. void spi_lcd_data(char command){
89. char data;
90. data=command&0xF0;
91. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN)|(1<<RS));
92. PRT_SPI&=~(1<<DD_SS);
93. PRT_SPI|=(1<<DD_SS);
94. SPI_MasterTransmit(data|(backLight<<BL)|(1<<RS));
95. PRT_SPI&=~(1<<DD_SS);
96. PRT_SPI|=(1<<DD_SS);
97. lcd_delay(50);
99. data=command<<4;
100. SPI_MasterTransmit(data|(backLight<<BL)|(1<<EN)|(1<<RS));
101. PRT_SPI&=~(1<<DD_SS);
102. PRT_SPI|=(1<<DD_SS);
103. SPI_MasterTransmit(data|(backLight<<BL)|(1<<RS));
104. PRT_SPI&=~(1<<DD_SS);
105. PRT_SPI|=(1<<DD_SS);
106. }
107. 
     
108. void spi_lcd_xy(int8_t x, int8_t y){
109. //16x2
110. //char addr[]={0x80,0xC0};
111. //16x4
112. char addr[]={0x80,0xC0,0x90,0xD0};
113. spi_lcd_command(addr[y-1]+x-1);
114. }
115. 
     
116. void spi_lcd_line_1(void){
117. spi_lcd_command(0x80);
118. }
119. 
     
120. void spi_lcd_line_2(void){
121. spi_lcd_command(0xC0);
122. }
123. 
     
124. void spi_lcd_line_3(void){
125. spi_lcd_command(0x90);
126. }
127. 
     
128. void spi_lcd_line_4(void){
129. spi_lcd_command(0xD0);
130. }
131. 
     
132. void spi_lcd_cursor_off(void){
133. spi_lcd_command(0x0C);
134. }
135. 
     
136. void spi_lcd_text(char *txt){
137. while(*txt) spi_lcd_data(*txt++);
138. }
139. 
     
140. void spi_lcd_clear(void){
141. spi_lcd_command(0x01);
142. _delay_ms(10);
143. }
144. 
     
145. void spi_lcd_init(void){
147. SPI_MasterTransmit(0);
148. lcd_delay(500);
149. spi_lcd_command(0x33);
150. lcd_delay(10);
151. spi_lcd_command(0x32);
152. lcd_delay(10);
153. spi_lcd_command(0x28);
154. lcd_delay(10);
155. spi_lcd_command(0x0F);
156. lcd_delay(10);
157. spi_lcd_command(0x01);
158. _delay_ms(10);
159. spi_lcd_command(0x06);
160. lcd_delay(10);
161. }
162. 
     
163. // DS1307 RTC Routine
164. 
     
165. const char DS1307_W=0xD0;
166. const char DS1307_R=0xD1;
167. void rtc_init(void){
168. char rtc[8]={0x30,0x10,0x21,0x04,0x11,0x02,0x26,1<<4};
169. for (char i=0;i<8;i++)
170. {
171. twi_start();
172. //D0 is DS1307 Write Address
173. twi_write(DS1307_W);
174. //Select Control Register
175. twi_write(i);
176. //Enable SQWE bit blinks at 1 Hz
177. twi_write(rtc[i]);
178. twi_stop();
179. _delay_ms(10);
180. }
181. }
182. 
     
183. char rtc[7], msg[16];
184. void rtc_read(void){
185. for(char i=0;i<7;i++){
186. /*Second Register*/
187. twi_start();
188. twi_write(DS1307_W);
189. /*Select Second register*/
190. twi_write(i);
191. twi_stop();
192. _delay_ms(10);
194. twi_start();
195. twi_write(DS1307_R);
196. rtc[i]=twi_read();
197. twi_stop();
198. _delay_ms(10);
199. }
200. }
201. 
     
202. int main(void)
203. {
204. /* Replace with your application code */
206. SPI_MasterInit();
207. PRT_SPI|=(1<<DD_SS); //Set CS Pin High
208. spi_lcd_init();
209. spi_lcd_line_1();
210. spi_lcd_text("ATMega644P SPI");
211. spi_lcd_line_2();
212. spi_lcd_text("SN74HC595N LCD");
213. spi_lcd_line_3();
214. spi_lcd_text("TC1604A-01(R)");
215. spi_lcd_line_4();
216. spi_lcd_text("Real Time Clock");
217. unsigned char data[7],msg[16];
218. //rtc_init();
219. _delay_ms(5000);
220. spi_lcd_clear();
221. spi_lcd_cursor_off();
222. while (1)
223. {
224. rtc_read();
225. spi_lcd_line_1();
226. spi_lcd_text("DS1307 RTC Chip");
227. spi_lcd_line_2();
228. spi_lcd_line_2();
229. spi_lcd_text("Software TWI");
230. spi_lcd_line_3();
231. sprintf(msg,"Time: %02X:%02X:%02X",rtc[2],rtc[1],rtc[0]);
232. spi_lcd_text(msg);
233. spi_lcd_line_4();
234. sprintf(msg,"Date: %02X/%02X/20%02X",rtc[4],rtc[5],rtc[6]);
235. spi_lcd_text(msg);
236. }
237. }
238. 
     
239. 
     
240. 
     
241. 
     
242. 
     
243. 
     

Its software TWI driver is place in separate file.

Source Code "twi.c": 

1. /*
2. * twi.c
3. *
4. * Created: 2/19/2026 2:13:04 PM
5. * Author: Admin
6. */
7. 
   
8. #include <avr/io.h>
9. 
   
10. #define TWI_PORT PORTC
11. #define TWI_SDA_IN PINC
12. #define TWI_DIR DDRC
13. 
    
14. const char SDA=1;
15. const char SCL=0;
16. const char PULSE=10;
17. 
    
18. void delay_counts(unsigned int count){
19. for(unsigned int i=0;i<count;i++);
20. }
21. 
    
22. void twi_start(void){
23. TWI_DIR|=(1<<SDA)|(1<<SCL);
24. TWI_PORT|=(1<<SDA)|(1<<SCL);
25. delay_counts(PULSE);
26. TWI_PORT&=~(1<<SDA);
27. delay_counts(PULSE);
28. TWI_PORT&=~(1<<SCL);
29. delay_counts(PULSE);
30. }
31. 
    
32. void twi_stop(void){
33. TWI_PORT&=~(1<<SCL);
34. TWI_PORT&=~(1<<SDA);
35. TWI_PORT|=(1<<SCL);
36. delay_counts(PULSE);
37. TWI_PORT|=(1<<SDA);
38. delay_counts(PULSE);
39. TWI_PORT|=(1<<SDA)|(1<<SCL);
40. delay_counts(PULSE);
41. }
42. 
    
43. void twi_write(char data){
44. char temp=0;
45. TWI_DIR|=(1<<SDA)|(1<<SCL);
46. for (unsigned char i=0;i<9;i++)
47. {
48. TWI_PORT&=~(1<<SCL);
49. delay_counts(PULSE);
50. if(i<8){
51. temp=data&0x80;
52. if(temp==0) TWI_PORT&=~(1<<SDA);
53. else TWI_PORT|=(1<<SDA);
54. }
55. else{
56. TWI_PORT&=~(1<<SDA);
57. TWI_DIR&=~(1<<SDA);
58. while(TWI_SDA_IN&(1<<SDA)==0);
59. }
61. TWI_PORT|=(1<<SCL);
62. delay_counts(PULSE);
63. data<<=1;
64. }
65. TWI_DIR|=(1<<SDA)|(1<<SCL);
66. }
67. 
    
68. char twi_read(void){
69. char temp=0,data=0;
70. TWI_DIR&=~(1<<SDA);
71. for (unsigned char i=0;i<9;i++)
72. {
73. TWI_PORT&=~(1<<SCL);
74. delay_counts(PULSE);
76. if(i<8){
77. /*
78. data<<=1;
79. temp=TWI_SDA_IN&(1<<SDA);
80. if(temp==(1<<SDA)) data|=1;
81. else data|=0;
82. */
84. temp=TWI_SDA_IN&(1<<SDA);
85. temp>>=1;
86. data|=(temp<<(7-i));
88. }
89. else{
90. while((TWI_SDA_IN&(1<<SDA))==0);
91. }
92. TWI_PORT|=(1<<SCL);
93. delay_counts(PULSE);
94. }
95. return data;
96. }

Schematic and Simulation:

Schematic

 AVR ATmega644P Experiment Board:

It works fine without error on my AVR Experiment Board.