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

ATMega644P TWI LCD RTC and Keypad Example

The PCF8574/PCF8574A series can interface to many parallel port I/O devices such as matrix keypad or even an HD44780 character LCD. Its 8-bit port can control the HD44780-based character LCD using the controller 4-bit data transfer mode without any auxiliary chip. Even the display is a one-line, two-line or 4-line display we can set its DD RAM via LCD command.

 

 

PCF8574T 16x2 Character LCD 

In this introductory example I use a popular Arduino PCF8574T character LCD interface module with the ATMega644P TWI to control a 16x2 character LCD.

A sample picture

Running Program on my ATMega644P Experiment Board

 

The I2C default address of this module is 0x4E since the A2:A0 pins are pulled high. For the Arduino IDE its TWI address is 0x27. I draw and make my own DIY using the PCF8574AP. Its schematic is shown below.

Schematic Diagram

However it works the same function except its I2C slave address. For more information about this DIY module please visit this blog.

Source Code: "main.c"

1. /*
2. * 10-i2c_pcf8574T_1602.c
3. *
4. * Created: 2/3/2026 11:05:19 AM
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. /*TWI LCD Driver*/
14. #define RS 0
15. #define RW 1
16. #define EN 2
17. #define BL 3
18. 
    
19. char backLight=0;
20. 
    
21. void i2c_lcdCommand(uint8_t command){
22. uint8_t data;
23. data=command&0xF0;
24. pcf8574Write(data|(backLight<<BL)|(1<<EN));
25. //_delay_us(10);
26. pcf8574Write(data|(backLight<<BL));
27. //_delay_us(50);
29. data=command<<4;
30. pcf8574Write(data|(backLight<<BL)|(1<<EN));
31. //_delay_us(10);
32. pcf8574Write(data|(backLight<<BL));
33. //_delay_us(50);
34. }
35. 
    
36. void i2c_lcdData(uint8_t command){
37. uint8_t data;
38. data=command&0xF0;
39. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
40. //_delay_us(10);
41. pcf8574Write(data|(backLight<<BL)|(1<<RS));
42. _delay_us(50);
44. data=command<<4;
45. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
46. //_delay_us(10);
47. pcf8574Write(data|(backLight<<BL)|(1<<RS));
48. //_delay_us(50);
49. }
50. 
    
51. void i2c_lcdXY(int8_t x, int8_t y){
52. int8_t addr[]={0x80,0xC0};
53. i2c_lcdCommand(addr[y-1]+x-1);
54. }
55. 
    
56. void i2c_lcdText(int8_t *txt){
57. while(*txt) i2c_lcdData(*txt++);
58. }
59. 
    
60. void i2c_lcdClear(void){
61. i2c_lcdCommand(0x01);
62. //_delay_ms(5);
63. }
64. 
    
65. void i2c_lcdInit(void){
66. i2cInit();
67. //_delay_us(10);
68. pcf8574Write(0);
69. //_delay_ms(10);
70. i2c_lcdCommand(0x33);
71. //_delay_us(10);
72. i2c_lcdCommand(0x32);
73. //_delay_us(10);
74. i2c_lcdCommand(0x28);
75. //_delay_us(10);
76. i2c_lcdCommand(0x0F);
77. //_delay_us(10);
78. i2c_lcdCommand(0x01);
79. //_delay_ms(5);
80. i2c_lcdCommand(0x06);
81. //_delay_us(10);
82. }
83. int main(void)
84. {
85. /* Replace with your application code */
86. _delay_ms(1000);
87. backLight=1;
88. i2c_lcdInit();
89. i2c_lcdText("ATMega644P I2C");
90. i2c_lcdXY(1,2);
91. i2c_lcdText(" PCF8574AP LCD");
92. long counter=0;
93. uint8_t msg[10];
94. _delay_ms(10000);
95. i2c_lcdClear();
96. i2c_lcdCommand(0x0C);
97. i2c_lcdText("Counter:");
98. while (1)
99. {
100. sprintf(msg,"%u",counter);
101. i2c_lcdXY(1,2);
102. i2c_lcdText(msg);
103. counter++;
104. _delay_ms(500);
105. }
106. }
107. 
     

I putted the pcf8574.c in a a separated file that's needed to copy and add in project source folder. But it's not include in the main C source file.

The "pcf8574.c": 

1. /*
2. * pcf8574.c
3. *
4. * Created: 2/3/2026 11:06:53 AM
5. * Author: Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. //DIY PCF8574AP LCD Module (A2:A0=0)
13. const char pcf8574_w=0x40;
14. const char pcf8574_r=0x41;
15. //PCF8574 (A2:A0=0)
16. const char pcf8574a_w=0x70;
17. const char pcf8574a_r=0x71;
18. //DIY Arduino PCF8574T LCD Module
19. const char pcf8574T_LCD_W=0x4E;
20. const char pcf8574T_LCD_R=0x4F;
21. 
    
22. void i2cInit(void){
23. TWSR|=0x00; //Prescaler Selection Bit
24. TWBR=0xF0; //Baud Rate Generator
25. TWCR=(1<<TWEN); //Enable The TWI Module
26. PORTC|=(1<<0);
27. PORTC|=(1<<1);
28. }
29. 
    
30. void i2cStart(void){
31. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
32. while((TWCR&(1<<TWINT))==0);
33. }
34. 
    
35. void i2cWrite(unsigned char data){
36. TWDR=data;
37. TWCR=(1<<TWINT)|(1<<TWEN);
38. while((TWCR&(1<<TWINT))==0);
39. }
40. 
    
41. unsigned char i2cRead(char ACK){
42. if(ACK==0)
43. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
44. else
45. TWCR=(1<<TWINT)|(1<<TWEN);
46. while((TWCR&(1<<TWINT))==0);
47. return TWDR;
48. }
49. 
    
50. void i2cStop(){
51. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
52. _delay_us(10);
53. }
54. 
    
55. void pcf8574Write(char data){
56. i2cStart();
57. i2cWrite(pcf8574T_LCD_W);
58. i2cWrite(data);
59. i2cStop();
60. }
61. 
    
62. char pcf8574Read(void){
63. i2cStart();
64. i2cWrite(pcf8574T_LCD_R);
65. char temp=i2cRead(1);
66. i2cStop();
67. return temp;
68. }

Schematic:

Schematic Diagram and Simulation

Simulating Program

ATMega644 Experiment Board: 

ATMega644 Experiment Board

 

 

ATMega644 Experiment Board

 

PCF8574T 16x4 LCD 

Now I replace with a TC1604A-01(R) I posses that is a 16x4 character LCD. It almost identical to the previous one's. 

TC1604A-01(R) MODULE OUTLINE DRAWING

Its display data RAM address is listed below.

Source Code "main.c":

1. /*
2. * 10-i2c_pcf8574T_1604.c
3. *
4. * Created: 2/3/2026 3:01:44 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. /*TWI LCD Driver*/
14. #define RS 0
15. #define RW 1
16. #define EN 2
17. #define BL 3
18. 
    
19. char backLight=0;
20. 
    
21. void i2c_lcdCommand(char command){
22. char data;
23. data=command&0xF0;
24. pcf8574Write(data|(backLight<<BL)|(1<<EN));
25. //_delay_us(10);
26. pcf8574Write(data|(backLight<<BL));
27. //_delay_us(50);
29. data=command<<4;
30. pcf8574Write(data|(backLight<<BL)|(1<<EN));
31. //_delay_us(10);
32. pcf8574Write(data|(backLight<<BL));
33. //_delay_us(50);
34. }
35. 
    
36. void i2c_lcdData(char command){
37. char data;
38. data=command&0xF0;
39. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
40. //_delay_us(10);
41. pcf8574Write(data|(backLight<<BL)|(1<<RS));
42. _delay_us(50);
44. data=command<<4;
45. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
46. //_delay_us(10);
47. pcf8574Write(data|(backLight<<BL)|(1<<RS));
48. //_delay_us(50);
49. }
50. 
    
51. void i2c_lcdXY(int8_t x, int8_t y){
52. //16x2
53. //char addr[]={0x80,0xC0};
54. //16x4
55. char addr[]={0x80,0xC0,0x90,0xD0};
56. i2c_lcdCommand(addr[y-1]+x-1);
57. }
58. 
    
59. void i2c_lcdText(int8_t *txt){
60. while(*txt) i2c_lcdData(*txt++);
61. }
62. 
    
63. void i2c_lcdClear(void){
64. i2c_lcdCommand(0x01);
65. //_delay_ms(5);
66. }
67. 
    
68. void i2c_lcdInit(void){
69. i2cInit();
70. //_delay_us(10);
71. pcf8574Write(0);
72. //_delay_ms(10);
73. i2c_lcdCommand(0x33);
74. //_delay_us(10);
75. i2c_lcdCommand(0x32);
76. //_delay_us(10);
77. i2c_lcdCommand(0x28);
78. //_delay_us(10);
79. i2c_lcdCommand(0x0F);
80. //_delay_us(10);
81. i2c_lcdCommand(0x01);
82. //_delay_ms(5);
83. i2c_lcdCommand(0x06);
84. //_delay_us(10);
85. }
86. int main(void)
87. {
88. /* Replace with your application code */
89. _delay_ms(1000);
90. backLight=1;
91. i2c_lcdInit();
92. i2c_lcdText("ATMega644P TWI");
93. i2c_lcdXY(1,2);
94. i2c_lcdText("PCF8574T LCD");
95. i2c_lcdXY(1,3);
96. i2c_lcdText("TC1604A-01(R)");
97. i2c_lcdXY(1,4);
98. i2c_lcdText("16x4 Lines LCD");
100. while (1)
101. {
102. }
103. }
104. 
     
105. 
     
106. 
     

Schematic:

Schematic

ATMega644 Prototype Board:

PCF8574T TC1604A-01(R) 16x4 LCD

 

PCF8574T 20x4 LCD 

A 20x4 character LCD is needed in any application that need to display a large amount of data. However a 4-line display is far more expensive than a conventional 16x2 LCD.

A Sample Image of a PCF8574T 2004A LCD

To display any text on this LCD correctly we need to modify the Display Data RAM (DD RAM) map. They are different depends on the manufacturer data sheet. Most of newer LCD(s) use modern controllers. However the conventional HD4478 LCD controller its DD RAM map for the 20x4 LCD is,

1. Line 1: 0x80
2. Line 2: 0xC0
3. Line 3: 0x94
4. Line 4: 0xD4 

However I don't have this LCD in my lab. In Proteus there is a model for 20x4 LCD and PCF8574-based I2C LCD. The I2C 20x4 LCD allow us to set its frequency, I2C slave address, and line number addresses.

Proteus Set the I2C Address to 0x4E

Source Code:

1. /*
2. * 10-i2c_pcf8574T_2004A.c
3. *
4. * Created: 2/3/2026 6:47:50 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. /*TWI LCD Driver*/
14. #define RS 0
15. #define RW 1
16. #define EN 2
17. #define BL 3
18. 
    
19. char backLight=0;
20. 
    
21. void i2c_lcdCommand(char command){
22. char data;
23. data=command&0xF0;
24. pcf8574Write(data|(backLight<<BL)|(1<<EN));
25. //_delay_us(10);
26. pcf8574Write(data|(backLight<<BL));
27. //_delay_us(50);
29. data=command<<4;
30. pcf8574Write(data|(backLight<<BL)|(1<<EN));
31. //_delay_us(10);
32. pcf8574Write(data|(backLight<<BL));
33. //_delay_us(50);
34. }
35. 
    
36. void i2c_lcdData(char command){
37. char data;
38. data=command&0xF0;
39. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
40. //_delay_us(10);
41. pcf8574Write(data|(backLight<<BL)|(1<<RS));
42. _delay_us(50);
44. data=command<<4;
45. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
46. //_delay_us(10);
47. pcf8574Write(data|(backLight<<BL)|(1<<RS));
48. //_delay_us(50);
49. }
50. 
    
51. void i2c_lcdXY(int8_t x, int8_t y){
52. //16x2
53. //char addr[]={0x80,0xC0};
54. //16x4
55. //char addr[]={0x80,0xC0,0x90,0xD0};
56. //20x4
57. char addr[]={0x80,0xC0,0x94,0xD4};
58. i2c_lcdCommand(addr[y-1]+x-1);
59. }
60. 
    
61. void i2c_lcdText(int8_t *txt){
62. while(*txt) i2c_lcdData(*txt++);
63. }
64. 
    
65. void i2c_lcdClear(void){
66. i2c_lcdCommand(0x01);
67. //_delay_ms(5);
68. }
69. 
    
70. void i2c_lcdInit(void){
71. i2cInit();
72. //_delay_us(10);
73. pcf8574Write(0);
74. //_delay_ms(10);
75. i2c_lcdCommand(0x33);
76. //_delay_us(10);
77. i2c_lcdCommand(0x32);
78. //_delay_us(10);
79. i2c_lcdCommand(0x28);
80. //_delay_us(10);
81. i2c_lcdCommand(0x0F);
82. //_delay_us(10);
83. i2c_lcdCommand(0x01);
84. //_delay_ms(5);
85. i2c_lcdCommand(0x06);
86. //_delay_us(10);
87. }
88. int main(void)
89. {
90. /* Replace with your application code */
91. _delay_ms(1000);
92. backLight=1;
93. i2c_lcdInit();
94. i2c_lcdText("ATMega644P PCF8574T");
95. i2c_lcdXY(1,2);
96. i2c_lcdText("20x4 Character LCD");
97. i2c_lcdXY(1,3);
98. i2c_lcdText("AVR TWI Example");
99. i2c_lcdXY(1,4);
100. i2c_lcdText("Microchip Studio IDE");
102. while (1)
103. {
104. }
105. }
106. 
     
107. 
     

Schematic and Simulation:

 

TWI LCD and KeyPad

Fortunately I have these two chips, PCF8574T (LCD) and PCF8574AP(DIP). So I'm making an I2C LCD and I2C 4x4 matrix keypad that connects to a single TWI bus.

Schematic and Simulation

KeyPad Scanning

Source Code

The main.c:

1. /*
2. * i2c-lcd_keypad.c
3. *
4. * Created: 2/3/2026 8:23:40 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. /*TWI LCD Driver*/
14. #define RS 0
15. #define RW 1
16. #define EN 2
17. #define BL 3
18. 
    
19. char backLight=0;
20. 
    
21. void i2c_lcdCommand(uint8_t command){
22. uint8_t data;
23. data=command&0xF0;
24. pcf8574Write(data|(backLight<<BL)|(1<<EN));
25. //_delay_us(10);
26. pcf8574Write(data|(backLight<<BL));
27. //_delay_us(50);
29. data=command<<4;
30. pcf8574Write(data|(backLight<<BL)|(1<<EN));
31. //_delay_us(10);
32. pcf8574Write(data|(backLight<<BL));
33. //_delay_us(50);
34. }
35. 
    
36. void i2c_lcdData(uint8_t command){
37. uint8_t data;
38. data=command&0xF0;
39. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
40. //_delay_us(10);
41. pcf8574Write(data|(backLight<<BL)|(1<<RS));
42. _delay_us(50);
44. data=command<<4;
45. pcf8574Write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
46. //_delay_us(10);
47. pcf8574Write(data|(backLight<<BL)|(1<<RS));
48. //_delay_us(50);
49. }
50. 
    
51. void i2c_lcdXY(int8_t x, int8_t y){
52. int8_t addr[]={0x80,0xC0};
53. i2c_lcdCommand(addr[y-1]+x-1);
54. }
55. 
    
56. void i2c_lcdText(int8_t *txt){
57. while(*txt) i2c_lcdData(*txt++);
58. }
59. 
    
60. void i2c_lcdClear(void){
61. i2c_lcdCommand(0x01);
62. //_delay_ms(5);
63. }
64. 
    
65. void i2c_lcdInit(void){
66. i2cInit();
67. //_delay_us(10);
68. pcf8574Write(0);
69. //_delay_ms(10);
70. i2c_lcdCommand(0x33);
71. //_delay_us(10);
72. i2c_lcdCommand(0x32);
73. //_delay_us(10);
74. i2c_lcdCommand(0x28);
75. //_delay_us(10);
76. i2c_lcdCommand(0x0F);
77. //_delay_us(10);
78. i2c_lcdCommand(0x01);
79. //_delay_ms(5);
80. i2c_lcdCommand(0x06);
81. //_delay_us(10);
82. }
83. 
    
84. char key_16[][4]={'1','2','3','A',
85. '4','5','6','B',
86. '7','8','9','C',
87. '*','0','#','D'};
88. 
    
89. char keyScan(void){
90. char data=0,temp,key;
91. for(char i=0;i<4;i++){
92. data=0xFF;
93. data&=~(1<<i);
94. pcf8574AWrite(data);
95. _delay_ms(5);
96. data=pcf8574ARead();
97. data&=0xF0;
98. if((data&0x10)==0) {temp=key_16[i][0]; break;}
99. else if((data&0x20)==0){temp=key_16[i][1]; break;}
100. else if((data&0x40)==0){temp=key_16[i][2]; break;}
101. else if((data&0x80)==0){temp=key_16[i][3]; break;}
102. else temp=0;
103. _delay_ms(10);
104. }
105. return temp;
106. }
107. 
     
108. int main(void)
109. {
110. /* Replace with your application code */
111. _delay_ms(1000);
112. backLight=1;
113. i2c_lcdInit();
114. i2c_lcdText("PCF8574T LCD");
115. i2c_lcdXY(1,2);
116. i2c_lcdText("PCF8574AP KeyPad");
117. long counter=0;
118. uint8_t msg[10];
119. _delay_ms(10000);
120. i2c_lcdClear();
121. pcf8574AWrite(0x0F);
122. char temp,charCount=0,newLine=0,line=1;
123. while (1)
124. {
125. temp=keyScan();
126. if(temp!=0){
127. i2c_lcdData(temp);
128. charCount++;
129. _delay_ms(500);
130. }
131. if(charCount>16){
132. newLine=1;
133. charCount=0;
134. line+=1;
135. }
136. if(newLine){
137. newLine=0;
138. if(line==2) i2c_lcdXY(1,2);
139. else{
140. i2c_lcdXY(1,1);
141. i2c_lcdCommand(0x01);
142. _delay_ms(5);
143. line=1;
145. }
146. }
147. }
148. }
149. 
     
150. 
     

The pcf8574.c

1. /*
2. * pcf8574.c
3. *
4. * Created: 2/3/2026 11:06:53 AM
5. * Author: Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. //DIY PCF8574AP LCD Module (A2:A0=0)
13. const char pcf8574_w=0x40;
14. const char pcf8574_r=0x41;
15. //PCF8574 (A2:A0=0)
16. const char pcf8574a_w=0x70;
17. const char pcf8574a_r=0x71;
18. //DIY Arduino PCF8574T LCD Module
19. const char pcf8574T_LCD_W=0x4E;
20. const char pcf8574T_LCD_R=0x4F;
21. 
    
22. void i2cInit(void){
23. TWSR|=0x00; //Prescaler Selection Bit
24. TWBR=0xF0; //Baud Rate Generator
25. TWCR=(1<<TWEN); //Enable The TWI Module
26. PORTC|=(1<<0);
27. PORTC|=(1<<1);
28. }
29. 
    
30. void i2cStart(void){
31. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
32. while((TWCR&(1<<TWINT))==0);
33. }
34. 
    
35. void i2cWrite(unsigned char data){
36. TWDR=data;
37. TWCR=(1<<TWINT)|(1<<TWEN);
38. while((TWCR&(1<<TWINT))==0);
39. }
40. 
    
41. unsigned char i2cRead(char ACK){
42. if(ACK==0)
43. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
44. else
45. TWCR=(1<<TWINT)|(1<<TWEN);
46. while((TWCR&(1<<TWINT))==0);
47. return TWDR;
48. }
49. 
    
50. void i2cStop(){
51. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
52. _delay_us(10);
53. }
54. 
    
55. // PCF8574
56. void pcf8574Write(char data){
57. i2cStart();
58. i2cWrite(pcf8574T_LCD_W);
59. i2cWrite(data);
60. i2cStop();
61. }
62. 
    
63. char pcf8574Read(void){
64. i2cStart();
65. i2cWrite(pcf8574T_LCD_R);
66. char temp=i2cRead(1);
67. i2cStop();
68. return temp;
69. }
70. 
    
71. //PCF8574A
72. void pcf8574AWrite(char data){
73. i2cStart();
74. i2cWrite(pcf8574a_w);
75. i2cWrite(data);
76. i2cStop();
77. }
78. 
    
79. char pcf8574ARead(void){
80. i2cStart();
81. i2cWrite(pcf8574a_r);
82. char temp=i2cRead(1);
83. i2cStop();
84. return temp;
85. }

 ATMega644P AVR Experiment Board

ATMega644P PCF8574T LCD PCF8574AP 4x4 Matrix KeyPad

ATMega644P PCF8574T LCD PCF8574AP 4x4 Matrix KeyPad

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