ATMega644P TWI MCP23017 GPIO Example

Overview 

The MCP23017 is an I2C interface 16-bit (two 8-bit GPIO Ports) I/O expansion chip. Its variance MCP23S17 is an SPI interface I/O expansion chip that functions almost identical. Any micro-controller that has a limit I/O port can easily add this chip to expand its I/O pins using its dedicated hardware communication module, or even by software bit-banging. 

ATMega644P Experiment Board

The MCP23017 uses the TWI communication interface that implement only two wires, Serial Clock(SCL) and Serial Data(SDA). It supports up to 1.7MHz serial clock rate. 

MCP23017 Chip and Module

This chip a DIP and an SMD package. There are a lot of module that use the SMD chip that is very friendly to use for hobbyist prototyping. 

Package Types

This chip contains some main blocks, TWI Interface, 3-bit Address Select, Reset, Interrupt Request and GPIO ports.

Functional Block Diagram

The MCP23017 is a slave I2C interface device that supports 7-bit slave addressing, with the read/write bit filling out the control byte. The slave address contains four fixed bits and three user-defined hardware address bits (pins A2, A1 and A0).

I2C ADDRESSING REGISTERS

Its I/O pins work in a similar way with the I/O port model of PIC micro-controllers. The I/O ports operation are controlled by its internal registers.

There are two port registers GPA and GPB. The data input for GPA is GPIOA while its output register is OLATA. IODIRA is its data direction control register. For example setting IODIRA to 0xFF make GPA to input port. It also has interrupt input and interrupt flag pin that's control via other registers listed in its data sheet. GPB operation works very similar to GPA.

Each port has its pull resistors that's enabled by setting the GPPUx registers. 

By default we don't set bit 7 (BANK) of IOCON register its control register are arranged below.

 

For more detail please check this device's datasheet.

ATMega644P TWI and MCP23017 Programming Example

For a simple programming the ATMega644P send data to GPA of the MCP23017. So in software the GPA register must set to 0x00 to make it as input port.

Source Code "main.c" :

1. /*
2. * 10-i2c_mcp23017_output_a.c
3. *
4. * Created: 2/4/2026 7:40:16 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #include "twi.c"
13. 
    
14. //MCP23017 TWI Slave Address
15. const char MCP23017_W=0x40;
16. const char MCP23017_R=0x41;
17. 
    
18. /*GPIO A and B Direction Control Register*/
19. const char IODIRA = 0x00;
20. const char IODIRB = 0x01;
21. /*GPIOA PULL UP REGISTER CONTROL*/
22. const char GPPUA = 0x0C;
23. /*GPIOA I/O PORT register*/
24. const char GPIOA = 0x12;
25. /*GPIOB Output Register*/
26. const char OLATA = 0x14;
27. /*GPIOB Output Register*/
28. const char OLATB = 0x15;
29. 
    
30. 
    
31. 
    
32. void mcp23017_write(char address,char data){
33. twi_start();
34. /*Select the write address*/
35. twi_write(MCP23017_W);
36. /*Select a register address*/
37. twi_write(address);
38. /*Send configuration data*/
39. twi_write(data);
40. twi_stop();
41. }
42. 
    
43. unsigned char mcp23017_read(char address){
44. /*Select a specific address*/
45. twi_start();
46. twi_write(MCP23017_W);
47. twi_write(address);
48. twi_stop();
49. /*Read data from the given address*/
50. twi_start();
51. twi_write(MCP23017_R);
52. unsigned char i2cData=twi_read(1);
53. twi_stop();
54. return i2cData;
55. }
56. 
    
57. int main(void)
58. {
59. /* Replace with your application code */
60. _delay_ms(1000);
61. char data;
62. twi_init();
63. /*Set GPIOA To Output*/
64. mcp23017_write(IODIRA,0x00);
65. while (1)
66. {
67. /*Send Data to OLATA*/
68. mcp23017_write(OLATA,data);
69. data++;
70. _delay_ms(100);
71. }
72. }
73. 
    
74. 
    
75. 
    

Source Code "twi.c" :

1. /*
2. * twi.c
3. *
4. * Created: 2/4/2026 10:22:02 AM
5. * Author: Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. const write_address=0xA0;
13. const read_address=0xA1;
14. 
    
15. 
    
16. void twi_init(void){
17. TWSR|=0x00; //Prescaler Selection Bit
18. TWBR=0x0F; //Baud Rate Generator
19. TWCR=(1<<TWEN); //Enable The TWI Module
20. PORTC|=(1<<0);
21. PORTC|=(1<<1);
22. }
23. 
    
24. void twi_start(void){
25. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
26. while((TWCR&(1<<TWINT))==0);
27. }
28. 
    
29. void twi_write(unsigned char data){
30. TWDR=data;
31. TWCR=(1<<TWINT)|(1<<TWEN);
32. while((TWCR&(1<<TWINT))==0);
33. }
34. 
    
35. unsigned char twi_read(char ACK){
36. if(ACK==0)
37. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
38. else
39. TWCR=(1<<TWINT)|(1<<TWEN);
40. while((TWCR&(1<<TWINT))==0);
41. return TWDR;
42. }
43. 
    
44. void twi_stop(){
45. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
46. _delay_us(10);
47. }

Schematic:

Schematic and Simulation

ATMega644P Prototype Board:

ATMega644P Prototype Board

 For more example the ATMega644P will read data from GPAand then send it to GPB.

Source Code:

1. /*
2. * 10-i2c_mcp23017_io.c
3. *
4. * Created: 2/4/2026 9:59:26 AM
5. * Author : Admin
6. */
7. #include <avr/io.h>
8. #include <util/delay.h>
9. #define F_CPU 16000000UL
10. 
    
11. //MCP23017 TWI Slave Address
12. const char MCP23017_W=0x40;
13. const char MCP23017_R=0x41;
14. 
    
15. /*GPIO A and B Direction Control Register*/
16. const char IODIRA = 0x00;
17. const char IODIRB = 0x01;
18. /*GPIOA PULL UP REGISTER CONTROL*/
19. const char GPPUA = 0x0C;
20. /*GPIOA I/O PORT register*/
21. const char GPIOA = 0x12;
22. /*GPIOB Output Register*/
23. const char OLATB = 0x15;
24. 
    
25. 
    
26. 
    
27. void mcp23017_write(char address,char data){
28. twi_start();
29. /*Select the write address*/
30. twi_write(MCP23017_W);
31. /*Select a register address*/
32. twi_write(address);
33. /*Send configuration data*/
34. twi_write(data);
35. twi_stop();
36. }
37. 
    
38. unsigned char mcp23017_read(char address){
39. /*Select a specific address*/
40. twi_start();
41. twi_write(MCP23017_W);
42. twi_write(address);
43. twi_stop();
44. /*Read data from the given address*/
45. twi_start();
46. twi_write(MCP23017_R);
47. unsigned char i2cData=twi_read(1);
48. twi_stop();
49. return i2cData;
50. }
51. 
    
52. int main(void)
53. {
54. /* Replace with your application code */
55. _delay_ms(1000);
56. char data;
57. twi_init();
58. /*Set GPIOA To Input*/
59. mcp23017_write(IODIRA,0xFF);
60. /*Set GPIOB To Output*/
61. mcp23017_write(IODIRB,0x00);
62. /*Turn On Pull Up Resistors On GPIOA*/
63. mcp23017_write(GPPUA,0xFF);
65. while (1)
66. {
67. /*Read digital input from GPIOA*/
68. data=mcp23017_read(GPIOA);
69. /*Send it back to GPIOB*/
70. mcp23017_write(OLATB,data);
71. }
72. }
73. 
    

The "twi.c" must be add to project folder the IDE.

Schematic:

Schematic

ATMega644P Prototype Board:

This PCB was offered by PCBWay (pcbway.com).

I have been using PCBWay for many years now. PCBWay fabricate PCBs at low cost, fast processing time for only 24 hours, and fast delivery time using any carrier options. This double side 10cmx10cm can be fabricate at only 5USD for 5 to 10pcs by PCBWay. It's a standard PCB with silk screen and solder mask.

10 PCBs for only 5USD

 

For different size of PCB we can instantly quote on PCBWay website using a zip PCB Gerber file without account.

PCBWay Instant Quote