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.