ATMega644P SPI and MCP23S17 LCD Matrix Keypad

In this post I use the TWI module of ATMega644P to interfaces with an MCP23017 GPIO expansion that able to control a character LCD and perform keypad scanning. However the SPI version MCP23S17 could do the same things like the TWI version MCP23017.

Using SPI the master MCU needs to four I/O pins unlike that TWI that use only two pins. However SPI offers a high speed data communication between master MCU and its slave devices.

MCP23S17 HD44780 LCD Driving

A single 8-bit port of this chip can control an HD44780 character LCD using LCD 4-bit data transfer mode similar to a direct control from an MCU output port.

Schematic

 Source Code "main.c":

1. /*
2. * 12-spi_mcp23s17_1602_kb.c
3. *
4. * Created: 2/17/2026 8:50:48 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. const char MCP23X17_W=0x40;
13. const char MCP23X17_R=0x41;
14. 
    
15. //IOCON.BANK=0
16. enum BANK0{
17. IODIRA=0,IODIRB,IPOLA,IPOLB,GPINTENA,GPINTENB,DEFVALA,
18. DEFVALB,INTCONA,INTCONB,IOCON1,IOCON2,GPPUA,GPPUB,
19. INTFA,INTFB,INTCAPA,INTCAPB,GPIOA,GPIOB,OLATA,OLATB
20. };
21. 
    
22. #define DDR_SPI DDRB
23. #define PRT_SPI PORTB
24. #define DD_MOSI 5
25. #define DD_MISO 6
26. #define DD_SCK 7
27. #define DD_SS 4
28. 
    
29. void SPI_MasterInit(void)
30. {
31. /* Set MOSI and SCK output, all others input */
32. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
33. /* Enable SPI, Master, set clock rate fck/16 */
34. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
35. }
36. 
    
37. void SPI_MasterTransmit(char cData)
38. {
39. /* Start transmission */
40. SPDR = cData;
41. /* Wait for transmission complete */
42. while(!(SPSR & (1<<SPIF)))
43. ;
44. }
45. 
    
46. void SPI_SlaveInit(void)
47. {
48. /* Set MISO output, all others input */
49. DDR_SPI = (1<<DD_MISO);
50. /* Enable SPI */
51. SPCR = (1<<SPE);
52. }
53. char SPI_SlaveReceive(void)
54. {
55. /* Wait for reception complete */
56. while(!(SPSR & (1<<SPIF)))
57. ;
58. /* Return Data Register */
59. return SPDR;
60. }
61. 
    
62. void mcp23s17_transmit(char address, char data){
63. PRT_SPI&=~(1<<DD_SS);
64. SPI_MasterTransmit(MCP23X17_W);
65. SPI_MasterTransmit(address);
66. SPI_MasterTransmit(data);
67. PRT_SPI|=(1<<DD_SS);
68. }
69. 
    
70. char mcp23s17_receive(char address){
71. PRT_SPI&=~(1<<DD_SS);
72. SPI_MasterTransmit(MCP23X17_R);
73. SPI_MasterTransmit(address);
74. SPI_MasterTransmit(0x00);
75. char data=SPI_SlaveReceive();
76. PRT_SPI|=(1<<DD_SS);
77. return data;
78. }
79. 
    
80. /*HD44780 LCD Section*/
81. const char RS=0,RW=1,EN=2;
82. char BLK_ON=0;
83. 
    
84. const char LCD_PORT = OLATA;
85. const char LCD_DIR = IODIRA;
86. 
    
87. void lcd_command(uint8_t temp){
88. uint8_t command,led;
89. command=temp&0xF0;
90. if(BLK_ON==1) led=0x08;
91. else led=0;
92. mcp23s17_transmit(LCD_PORT,command|led|(1<<EN));
93. _delay_us(10);
94. mcp23s17_transmit(LCD_PORT,command|led);
95. _delay_us(25);
97. command=temp<<4;
98. mcp23s17_transmit(LCD_PORT,command|led|(1<<EN));
99. _delay_us(10);
100. mcp23s17_transmit(LCD_PORT,command|led);
101. _delay_us(25);
102. }
103. 
     
104. void lcd_data(uint8_t temp){
105. uint8_t data,led;
106. data=temp&0xF0;
107. if(BLK_ON==1) led=0x08;
108. else led=0;
109. mcp23s17_transmit(LCD_PORT,data|led|(1<<EN)|(1<<RS));
110. _delay_us(10);
111. mcp23s17_transmit(LCD_PORT,data|led|(1<<RS));
112. _delay_us(25);
114. data=temp<<4;
115. mcp23s17_transmit(LCD_PORT,data|led|(1<<EN)|(1<<RS));
116. _delay_us(10);
117. mcp23s17_transmit(LCD_PORT,data|led|(1<<RS));
118. _delay_us(25);
119. }
120. 
     
121. void lcd_xy(uint8_t x, uint8_t y){
122. uint8_t cursor[]={0x80,0xC0};
123. lcd_command(cursor[y-1]+x-1);
124. }
125. 
     
126. void lcd_line_1(void){
127. lcd_command(0x80);
128. }
129. 
     
130. void lcd_line_2(void){
131. lcd_command(0xC0);
132. }
133. 
     
134. void lcd_text(uint8_t *text){
135. while(*text) lcd_data(*text++);
136. }
137. 
     
138. void lcd_clear(void){
139. lcd_command(0x01);
140. _delay_ms(5);
141. }
142. 
     
143. void lcd_init(void){
144. BLK_ON=1;
145. mcp23s17_transmit(LCD_DIR,0x00);
146. lcd_command(0x33);
147. _delay_us(10);
148. lcd_command(0x32);
149. _delay_us(10);
150. lcd_command(0x28);
151. _delay_us(10);
152. lcd_command(0x0F);
153. _delay_us(10);
154. lcd_command(0x01);
155. _delay_ms(5);
156. lcd_command(0x06);
157. _delay_us(10);
158. }
159. int main(void)
160. {
161. /* Replace with your application code */
162. SPI_MasterInit();
163. PRT_SPI|=(1<<DD_SS); //Set CS Pin High
164. lcd_init();
165. lcd_text("ATMega644P SPI");
166. lcd_line_2();
167. lcd_text("MCP23S17 GPIO");
168. while (1)
169. {
171. }
172. }
173. 
     
174. 
     
175. 
     
176. 
     

We can control a larger display for instance a 20x4 character LCD with additional display address modification.

MCP23S17 HD44780 LCD and Matrix Keypad

There is one I/O port left, the GPB. So I added a 4x4 matrix keypad to this port. The result of found key scanning will show on a 16x2 character LCD connects to GPA.

MCP23S17 HD44780 LCD and Matrix Keypad

 Source Code "main.c":

1. /*
2. * lcd_keyboard.c
3. *
4. * Created: 2/17/2026 11:07:07 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. /*SPI Setting*/
14. 
    
15. #define DDR_SPI DDRB
16. #define PRT_SPI PORTB
17. #define DD_MOSI 5
18. #define DD_MISO 6
19. #define DD_SCK 7
20. #define DD_SS 4
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. /*MCP23S17 Setting*/
56. const char MCP23X17_W=0x40;
57. const char MCP23X17_R=0x41;
58. 
    
59. //IOCON.BANK=0
60. enum BANK0{
61. IODIRA=0,IODIRB,IPOLA,IPOLB,GPINTENA,GPINTENB,DEFVALA,
62. DEFVALB,INTCONA,INTCONB,IOCON1,IOCON2,GPPUA,GPPUB,
63. INTFA,INTFB,INTCAPA,INTCAPB,GPIOA,GPIOB,OLATA,OLATB
64. };
65. 
    
66. void mcp23s17_transmit(char address, char data){
67. PRT_SPI&=~(1<<DD_SS);
68. SPI_MasterTransmit(MCP23X17_W);
69. SPI_MasterTransmit(address);
70. SPI_MasterTransmit(data);
71. PRT_SPI|=(1<<DD_SS);
72. }
73. 
    
74. char mcp23s17_receive(char address){
75. PRT_SPI&=~(1<<DD_SS);
76. SPI_MasterTransmit(MCP23X17_R);
77. SPI_MasterTransmit(address);
78. SPI_MasterTransmit(0x00);
79. char data=SPI_SlaveReceive();
80. PRT_SPI|=(1<<DD_SS);
81. return data;
82. }
83. 
    
84. 
    
85. /*HD44780 LCD Section*/
86. const char RS=0,RW=1,EN=2;
87. char BLK_ON=0;
88. 
    
89. const char LCD_PORT = OLATA;
90. const char LCD_DIR = IODIRA;
91. 
    
92. void lcd_command(uint8_t temp){
93. uint8_t command,led;
94. command=temp&0xF0;
95. if(BLK_ON==1) led=0x08;
96. else led=0;
97. mcp23s17_transmit(LCD_PORT,command|led|(1<<EN));
98. mcp23s17_transmit(LCD_PORT,command|led);
100. command=temp<<4;
101. mcp23s17_transmit(LCD_PORT,command|led|(1<<EN));
102. mcp23s17_transmit(LCD_PORT,command|led);
103. }
104. 
     
105. void lcd_data(uint8_t temp){
106. uint8_t data,led;
107. data=temp&0xF0;
108. if(BLK_ON==1) led=0x08;
109. else led=0;
110. mcp23s17_transmit(LCD_PORT,data|led|(1<<EN)|(1<<RS));
111. mcp23s17_transmit(LCD_PORT,data|led|(1<<RS));
113. data=temp<<4;
114. mcp23s17_transmit(LCD_PORT,data|led|(1<<EN)|(1<<RS));
115. mcp23s17_transmit(LCD_PORT,data|led|(1<<RS));
116. }
117. 
     
118. void lcd_xy(uint8_t x, uint8_t y){
119. uint8_t cursor[]={0x80,0xC0};
120. lcd_command(cursor[y-1]+x-1);
121. }
122. 
     
123. void lcd_line_1(void){
124. lcd_command(0x80);
125. }
126. 
     
127. void lcd_line_2(void){
128. lcd_command(0xC0);
129. }
130. 
     
131. void lcd_text(uint8_t *text){
132. while(*text) lcd_data(*text++);
133. }
134. 
     
135. void lcd_clear(void){
136. lcd_command(0x01);
137. _delay_ms(5);
138. }
139. 
     
140. void lcd_init(void){
141. BLK_ON=1;
142. mcp23s17_transmit(LCD_DIR,0x00);
143. lcd_command(0x33);
144. _delay_us(10);
145. lcd_command(0x32);
146. _delay_us(10);
147. lcd_command(0x28);
148. _delay_us(10);
149. lcd_command(0x0F);
150. _delay_us(10);
151. lcd_command(0x01);
152. _delay_ms(5);
153. lcd_command(0x06);
154. _delay_us(10);
155. }
156. 
     
157. const char key_16[4][4]={'1','2','3','A',
158. '4','5','6','B',
159. '7','8','9','C',
160. '*','0','#','D'};
161. 
     
162. char key_scan(void){
163. char data=0,temp,key;
164. for(char i=0;i<4;i++){
165. data=0xFF;
166. data&=~(1<<i);
167. mcp23s17_transmit(OLATB,data);
168. _delay_ms(5);
169. data=mcp23s17_receive(GPIOB);
170. data&=0xF0;
171. if((data&0x10)==0) {temp=key_16[i][0]; break;}
172. else if((data&0x20)==0){temp=key_16[i][1]; break;}
173. else if((data&0x40)==0){temp=key_16[i][2]; break;}
174. else if((data&0x80)==0){temp=key_16[i][3]; break;}
175. else temp=0;
176. _delay_ms(10);
177. }
178. return temp;
179. }
180. 
     
181. void key_init(void){
182. mcp23s17_transmit(IODIRB,0xF0);
183. mcp23s17_transmit(GPPUB,0xF0);
184. }
185. 
     
186. int main(void)
187. {
188. /* Replace with your application code */
189. SPI_MasterInit();
190. PRT_SPI|=(1<<DD_SS);
191. lcd_init();
192. key_init();
193. lcd_line_1(); lcd_text("ATMega644P SPI");
194. lcd_line_2(); lcd_text("MCP23S17 LCD");
195. char temp,charCount=0,newLine=0,line=1;
196. _delay_ms(5000);
197. lcd_clear();
198. while (1)
199. {
200. temp=key_scan();
201. if(temp!=0){
202. lcd_data(temp);
203. charCount++;
204. _delay_ms(500);
205. }
206. if(charCount>16){
207. newLine=1;
208. charCount=0;
209. line+=1;
210. }
211. if(newLine){
212. newLine=0;
213. if(line==2) lcd_xy(1,2);
214. else{
215. lcd_xy(1,1);
216. lcd_command(0x01);
217. _delay_ms(5);
218. line=1;
220. }
221. }
222. }
223. }
224. 
     

For a full tutorial list of ATMega644P using C in Microchip Studio IDE please see 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.