ATMega644P SPI and MCP23S17 GPIO Expansion Example

Overview 

The MCP23S17 is an SPI 16-bit (two ports) bi-directional GPIO expansion chip. Its TWI version is the MCP23017. It's rich of functions, data direction, control, distinct input and output registers, programmable weak pull up resistors, interrupt capabilities etc. Its configuration setting is very similar to most of PIC micro-controller since it is produced by Microchip Technology.

MCP23S17 I/O Ports Programming

 

It contains two 8-bit bi-directional port, GPA and GPB. Both of them are programmable with additional interrupt features. Its two interrupt flag pins correspond to each ports. 

MCP23S17-E/SP

 The SPI version of this chip is very similar to the I2C version.

Package Types

Its SPI interface is bi-directional since it's a general purpose I/O chip. Its four SPI pins are Chip Select(CS), Serial Clock(SCK), Serial In(SI) and Serial Out(SO). Its three optional address pins are A2:A0. We can connect them to GND to set the SPI slave write address to 0x40 and 0x41 for read address.

Functional Block Diagram

 The programmer must configure the following registers to get a proper operation.

Register Addressed

 By default we don't set the IOCON register the default bank is BANK0 ranges from 0x00 to 0x15. For example the IODIRB locates at 0x01 and its output register OLATB locates at 0x15.

SPI ADDRESSING REGISTERS

The idle state of CS pin is high. To complete a write or read operation the master MCU has to send at least 3 write operations.

ATMega644 and MCP23S17 SPI Programming

The write operations contain three data bytes, slave write address, register address and data. For example to make GPA as output we must do the following step:

1. Set CS pin low
2. Send its slave address 0x40 (A2:A0=0)
3. Send IODIRA address 0x00
4. Send data direction 0x00 that is output direction
5. Clear CS pin 

Here the output ports GPA and GPB are output. They blink LED(s) every half second.

GPA and GPB are output ports

SPI Waveform

 C source Code "main.c":

1. /*
2. * 12-spi_mcp23s17.c
3. *
4. * Created: 2/15/2026 9:55:53 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 MCP23017_W=0x40;
13. const char MCP23017_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(MCP23017_W);
65. SPI_MasterTransmit(address);
66. SPI_MasterTransmit(data);
67. PRT_SPI|=(1<<DD_SS);
68. }
69. 
    
70. 
    
71. int main(void)
72. {
73. /* Replace with your application code */
74. SPI_MasterInit();
75. PRT_SPI|=(1<<DD_SS); //Set CS Pin High
76. // GPA Output
77. mcp23s17_transmit(IODIRA,0x00);
78. //GPB Output
79. mcp23s17_transmit(IODIRB,0x00);
80. while (1)
81. {
82. mcp23s17_transmit(OLATA,0x0F);
83. mcp23s17_transmit(OLATB,0x00);
84. _delay_ms(500);
85. mcp23s17_transmit(OLATA,0xF0);
86. mcp23s17_transmit(OLATB,0xFF);
87. _delay_ms(500);
88. }
89. }
90. 
    

At this point the master MCU set a port as input.

This is an example of making GPB as input:

1. Set CS pin low
2. Send its slave address 0x40 (A2:A0=0)
3. Send IODIRB address 0x01
4. Send data direction 0xFF that is input direction
5. Clear CS pin 

And then we enable the weak pull up resistors of GPB:

1. Set CS pin low
2. Send its slave address 0x40 (A2:A0=0)
3. Send GPPUB address 0x0D
4. Send 0xFF to turn on all its pull up resistors
5. Clear CS pin 

The read operation also contains three data bytes, slave read address, register address, any data and read operation. For instance GPB is already an input port. So the MCU needs to read its input data:

1. Set CS pin low
2. Send its slave address 0x41 (A2:A0=0)
3. Send GPIOB address 0x13
4. Send one byte of data (eg:0x00) for shift data out from MCP23S17 SO pin
5. Perform the SPI read operation 
6. Clear CS pin 

This example GPB of MCP23S17 is an input port with weak pull resistors enabled. The master MCU read data from this port and send it back to GPA output port.

GPB as Input and GPA as Output

Waveform on virtual DSO

C Source Code "main.c":

1. /*
2. * 12-spi_mcp23s17_io.c
3. *
4. * Created: 2/15/2026 10:56: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 MCP23017_W=0x40;
13. const char MCP23017_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(MCP23017_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(MCP23017_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. int main(void)
81. {
82. /* Replace with your application code */
83. SPI_MasterInit();
84. PRT_SPI|=(1<<DD_SS); //Set CS Pin High
85. mcp23s17_transmit(IODIRA,0x00);
86. mcp23s17_transmit(IODIRB,0xFF);
87. mcp23s17_transmit(GPPUB,0xFF);
88. while (1)
89. {
90. char data=mcp23s17_receive(GPIOB);
91. mcp23s17_transmit(OLATA,data);
92. _delay_ms(500);
93. }
94. }
95. 
    
96. 
    
97. 
    

For PIC micro-controller user this post shows how a PIC16F887 interfaces with the MCP23S17 using its dedicated SPI hardware.