ATMega644P Serial Peripheral Interface (SPI) Tutorial

Overview

The Serial Peripheral Interface (SPI) is a high speed serial communication that commonly use three wires, serial clock, serial data and enable (master transmit only). Most of modern micro-controller has this serial communication interface. It is useful for board to board or to device communication due to wiring complexity compare to parallel port data transmission.

SPI is popular among graphical display, Flash memory, I/O expansion chip, SRAM, EEPROM, real time clock chip etc. Its transmission and reception speed could reach up to several Mbits/s. These are some example of SPI devices:

• DS3234 Real Time Clock
• Nokia 5510 graphical LCD module
• MCP23S17 I/O Expansion Chip
• SN74HC595N Serial In Parallel Out Shift Registers
• ILI9341/ST7785 240x320 TFT Display
• ST7735 128x160 TFT Display
• W25Q64JVSSIQ Flash Memory Chip
• SD MMC Card etc. 

W25Q64JVSSIQ

 

ILI9341/ST7785 240x320 TFT Display

 

Some earlier MCU doesn't have an SPI module inside for instance the AT89S52 or PIC16F84A. However the programmer could emulate a software SPI by using the bit-banging technique. This method is popular but it yield a lower speed data transmission and reception. 

Typically a system operation contains a master MCU that transmit and receive data from its connected SPI slave devices.

Single master to single slave: basic SPI wiring

 

The pin names of the SPI module in the AVR micro-controller are different from other MCU such as PIC. These pins are:

Abbr.	Name	Description
SS	Slave Select	Active-low chip select signal from master to enable communication with a specific slave device
SCLK	Serial Clock	Clock signal from master
MOSI	Master Out Slave In	Serial data output from master
MISO	Master In Slave Out	Serial data output from slave

The master MCU must select any connected SPI slave device via its slave select (SS) pin. One slave device has a unique SS pin. So multiple slave devices have many SS pins.

A typical hardware setup using two shift registers to form an inter-chip circular buffer

The SS pin is active low or active high upon the specific device.

Its clock polarity is commonly positive (low to high). Somes device use a negative (high to low) clock polarity.

 

However its clock polarity and phase are configured by user software that requires an understanding of technical detail of an MCU (Dedicated SPI Module).

The master MCU can communicates with many different SPI slave devices (Multidrop SPI bus) on a single bus using additional SS pins.

Multidrop SPI bus

 

If multiple SPI slave devices with the same type connect to a single SPI bus we can use the Daisy chain configuration. For instance the SN74HC595N or SN74HC164 serial in parallel out shift registers.

Daisy chain configuration

 It is used for expanding a number of output ports for instance driving a dot matrix display.

 Currently there are a lot of newer method of SPI data transmission that is precise and high speed.

ATMega644P Serial Peripheral Interface

The SPI module of the ATMega644P has the following features:

•     Full-duplex, Three-wire Synchronous Data Transfer
•     Master or Slave Operation
•     LSB First or MSB First Data Transfer
•     Seven Programmable Bit Rates
•     End of Transmission Interrupt Flag
•     Write Collision Flag Protection
•     Wake-up from Idle Mode
•     Double Speed (CK/2) Master SPI Mode

Its operation mode and speed are configured in user program via its relevant special function registers.

SPI Block Diagram

 Its clock generator is divided form the MCU clock up to CK/2. Data is shifted in and out using its internal 8-bit shift register at each clock cycle of the SPI clock generator. It also generate interrupt flag whenever the shift registers is empty.

SPI Master-slave Interconnection

 These are its relevant registers:

•   SPCR – SPI Control Register

SPCR – SPI Control Register

•  SPSR – SPI Status Register 

SPSR – SPI Status Register

• SPDR – SPI Data Register 

SPDR – SPI Data Register

The ATMega644P may operate in master transmit only, slave receive only or even full duplex (synchronous data transfer) depending on these registers.  For more detail please see the device datasheet. 

ATMega644P SPI Interfacing and Programming

We can configure the SPI module of the ATMega644P to operates in a specific mode depends on the worked application.

SPI Master Transmit Mode 

An SPI master transmits only is common. There are many SPI slave device that only need data reception such as the SN74HC595N or 74HC164 shift register chips. 

SN74HC595N and SN74HC164N Shift Registers

These chips is very popular due to its availability, low cost, ease of control etc. The SN74HC595N is commonly found in output expanding application such as relays driving, LED driving especially the dot matrix display driver.

SN74HC595N Pin Diagram

In this example the ATMega644P operate in master mode to transmit data to the SN74HC595N shifter register chip. The output port of this chip can connects to LED, 7-Segment displays or even a character LCD.

There are sample code of using the SPI transmit in device data sheet in both Assembly and C program.

Sample Code

 

LED Driving

I have a DIY single chip SN74HC595N LED module that is very easy to make. However we can install them together on a single breadboard.

A completed Soldering Board

Copper Side

 For more information about this DIY PCB see this post.

 The program is very simple.

1. /*
2. * 12-spi_74hc595_led.c
3. *
4. * Created: 2/14/2026 6:57:01 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #define DDR_SPI DDRB
13. #define PRT_SPI PORTB
14. #define DD_MOSI 5
15. #define DD_SCK 7
16. #define DD_SS 4
17. 
    
18. void SPI_MasterInit(void)
19. {
20. /* Set MOSI and SCK output, all others input */
21. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
22. /* Enable SPI, Master, set clock rate fck/16 */
23. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
24. }
25. 
    
26. void SPI_MasterTransmit(char cData)
27. {
28. /* Start transmission */
29. SPDR = cData;
30. /* Wait for transmission complete */
31. while(!(SPSR & (1<<SPIF)))
32. ;
33. }
34. 
    
35. int main(void)
36. {
37. /* Replace with your application code */
38. SPI_MasterInit();
39. char i=0;
40. while (1)
41. {
42. SPI_MasterTransmit(1<<i);
43. PRT_SPI&=~(1<<DD_SS);
44. _delay_us(100);
45. PRT_SPI=(1<<DD_SS);
46. _delay_us(100);
47. i++;
48. if(i>8) i=0;
49. _delay_ms(100);
50. }
51. }
52. 
    

Schematic:

SN74HC595N LED Driving

 AVR Experiment Board:

SN74HC595N LED Driving

 

SN74HC595N LED Driving

 

 

SN74HC595N LED Driving

 The program just shift each bits of the SN74HC595N output port.

 

Seven Segments Display Driving

I made a single common cathode 7-Segment display that is driven by an SN74HC595N chip. So it's easy for the MCU to connect to this display using a little wires. 

Fully Solder Board

 

Copper Side After I Soldered.

 Source Code:

1. /*
2. * 12-spi_74hc595_7.c
3. *
4. * Created: 2/14/2026 9:42:04 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. //Common Anode
13. const char ca_7[16]={0xC0, 0xF9, 0xA4, 0xB0,0x99, 0x92,
14. 0x82, 0xF8, 0x80, 0x90, 0x88, 0x83, 0xA7, 0xA1, 0x86, 0x8E};
15. //Common Cathode
16. const char cc_7[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,
17. 0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
18. 
    
19. #define DDR_SPI DDRB
20. #define PRT_SPI PORTB
21. #define DD_MOSI 5
22. #define DD_SCK 7
23. #define DD_SS 4
24. 
    
25. void SPI_MasterInit(void)
26. {
27. /* Set MOSI and SCK output, all others input */
28. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
29. /* Enable SPI, Master, set clock rate fck/16 */
30. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
31. }
32. 
    
33. void SPI_MasterTransmit(char cData)
34. {
35. /* Start transmission */
36. SPDR = cData;
37. /* Wait for transmission complete */
38. while(!(SPSR & (1<<SPIF)))
39. ;
40. }
41. 
    
42. int main(void)
43. {
44. /* Replace with your application code */
45. SPI_MasterInit();
46. char i=0;
47. while (1)
48. {
49. SPI_MasterTransmit(ca_7[i]);
50. PRT_SPI&=~(1<<DD_SS);
51. _delay_us(100);
52. PRT_SPI=(1<<DD_SS);
53. _delay_us(100);
54. i++;
55. if(i>15) i=0;
56. _delay_ms(500);
57. }
58. }
59. 
    

Schematic:

Seven Segments Display Driving

 

 

 
 

 

 

 

 

 

 

ATMega644P Software TWI SH1106 OLED and DS1307 RTC

In previous example the ATMega644P emulate the TWI via software bit-banging that able to communicate to various slave TWI devices on a single bus. In this example the ATMega644P master MCU send display data to the SH1106 128x64 OLED display and read calendar data from the DS1307 RTC. For more information about using the SH1106 128x64 OLED display please visit this post.

ATMega644P Software TWI SH1106 OLED 

 

ATMega644P Software TWI SH1106 OLED 

For an introductory example the master MCU send display data to the SH1106 128x64 OLED module. 

Source Code "main.c":

1. /*
2. * 11-soft_twi_sh1106.c
3. *
4. * Created: 2/10/2026 12:03:22 AM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. int main(void)
13. {
14. /* Replace with your application code */
15. _delay_ms(1000);
16. display_init();
17. display_clear(0);
18. display_text_8x16(0,0,"SH1106 I2C OLED");
19. display_text_8x16(0,1,"And ATMega644P");
20. display_text_8x16(0,2,"Programming With");
21. display_text_8x16(0,3,"Microchip Studio");
22. _delay_ms(10000);
23. display_clear(0x00);
24. while (1)
25. {
26. display_text_8x16(0,0,"Software TWI");
27. _delay_ms(2500);
28. uint8_t h=15;
29. for(uint8_t i=0;i<10;i++) {
30. display_char_8x16(h,1,'0'+i);
31. h+=10;
32. }
33. _delay_ms(2500);
34. h=0;
35. for(uint8_t i=0;i<14;i++) {
36. display_char_8x16(h,2,'A'+i);
37. h+=10;
38. }
39. _delay_ms(2500);
40. h=0;
41. for(uint8_t i=0;i<14;i++) {
42. display_char_8x16(h,3,'N'+i);
43. h+=10;
44. }
45. _delay_ms(10000);
46. display_clear(255);
47. _delay_ms(10000);
48. display_clear(0);
49. _delay_ms(1000);
50. }
51. }

Schematic:

Schematic

Proteus only has a model for the SSD1306. Simulating this part is very slow.

AVR Prototype Board:

ATMega644P AVR Prototype Board

 

 

 

ATMega644P AVR Prototype Board

 

Click here to download this example. 

ATMega644P Software TWI SH1106 OLED 

Here the ATMega644P read the calendar from DS1307 RTC that will display on the SH1106 128x64 OLED display.

Source Code "main.c":

1. /*
2. * 11-soft_twi_ds1307_sh1106.c
3. *
4. * Created: 2/9/2026 7:34:19 PM
5. * Author : Admin
6. */
7. 
   
8. 
   
9. #include<stdio.h>
10. #include <avr/io.h>
11. #include <util/delay.h>
12. #define F_CPU 16000000UL
13. 
    
14. #include "twi_device.h"
15. 
    
16. void rtc_init(void){
17. char rtc[8]={0x30,0x35,0x13,0x07,0x31,0x01,0x26,1<<4};
18. for (char i=0;i<8;i++)
19. {
20. twi_start();
21. //D0 is DS1307 Write Address
22. twi_write(DS1307_W);
23. //Select Control Register
24. twi_write(i);
25. //Enable SQWE bit blinks at 1 Hz
26. twi_write(rtc[i]);
27. twi_stop();
28. _delay_ms(10);
29. }
30. }
31. 
    
32. unsigned char rtc[50], msg[20];
33. float voltage;
34. unsigned int temp;
35. 
    
36. void rtc_read(void){
37. for(char i=0;i<50;i++){
38. /*Second Register*/
39. twi_start();
40. twi_write(DS1307_W);
41. /*Select Second register*/
42. twi_write(i);
43. twi_stop();
44. _delay_us(100);
46. twi_start();
47. twi_write(DS1307_R);
48. rtc[i]=twi_read();
49. twi_stop();
50. _delay_us(100);
51. }
52. }
53. int main(void)
54. {
55. /* Replace with your application code */
56. _delay_ms(1000);
57. display_init();
58. adc_init();
59. //rtc_init();
60. display_clear(0);
62. display_text_8x16(0,0,"Software TWI");
63. display_text_8x16(0,1,"ATMega644P OLED");
64. display_text_8x16(0,2,"SH1106 DS1307");
65. display_text_8x16(0,3,"RTC Example");
66. _delay_ms(10000);
67. display_clear(0);
68. while (1)
69. {
70. rtc_read();
71. sprintf(msg,"Time: %02X:%02X:%02X",rtc[2],rtc[1],rtc[0]);
72. display_text_8x16(0,0,msg);
73. sprintf(msg,"Date: %02X/%02X/20%02X",rtc[4],rtc[5],rtc[6]);
74. display_text_8x16(0,1,msg);
76. //Read POT
77. temp=read_adc(0);
78. //Convert To Voltage
79. voltage=temp*5.0/1023;
80. sprintf(msg,"ADC0: %4d %.2fV",temp,voltage);
81. display_text_8x16(0,2,msg);
82. //Read LM35
83. temp=read_adc(1);
84. voltage=temp*5.0/1023;
85. voltage*=100;
86. sprintf(msg,"Temp: %.2f C",voltage);
87. display_text_8x16(0,3,msg);
88. _delay_us(500);
89. }
90. }
91. 
    

The schematic is the one's above.

 

AVR Experiment Board: 

ATMega644P Software TWI SH1106 OLED 

ATMega644P Software TWI SH1106 OLED

 Click here to download this example.

 

 

ATMega644P Software TWI Example

Overview

For any MCU that doesn't have a dedicated TWI module inside the programmer can emulate a TWI using software bit-banging. It's very common and readable for most of students, programmers and electronics hobbyists. They just need to understand about the overall protocol of TWI data transmission and reception. It's very similar to the SPI but it excepts START, REPEATED START, STOP Condition and one additional ACK/NACK bit. Without an MCU the programmer uses the PC parallel port instead.

 

However using software TWI it's not robust and fast like the TWI module inside an MCU. The software TWI can fit to any MCU with any additional code modifications without understanding the the detail of the dedicated TWI module of an MCU.

For an AVR micro-controller the user need set a correct fuse and a proper software configuration for the internal TWI module to make a correct operation of the TWI data transmission and reception. 

Unfortunately my ATMega644P was supplied with a over voltage supply of around 10VDC for almost one day. It caused by a malfunction ASM1117-5.0 low drop out voltage regulator chip. But the MCU still works with some defected parts. Then its dedicated TWI module also defected.

PCF8574AP Software TWI GPIO Port Writing 

I decide to learn and write my own software TWI routine to control a TWI OLED display I posses. I worked well. To get started I wrote a simple C routine for writing data to a PCF8574AP I/O expansion chip.

A simple software TWI data sending to the PCF8574AP I/O Expansion

This introductory example is a draft of C routine I first wrote. The master MCU send data to the PCF8574AP via its software TWI pins, SCL and SDA. We can select other pins depends on the program settings. The 8-bit write address of PCF8574AP (A2:A0=0x00) is 0x70 and 0x71 for read address.

C Source File "main.c" :

1. /*
2. * 11-soft_twi_pcf8574ap.c
3. *
4. * Created: 2/9/2026 10:06:25 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #define TWI_PORT PORTC
13. #define TWI_SDA_IN PINC
14. #define TWI_DIR DDRC
15. 
    
16. const char SDA=1;
17. const char SCL=0;
18. 
    
19. void delay_counts(unsigned int count){
20. for(unsigned int i=0;i<count;i++);
21. }
22. 
    
23. void twi_start(void){
24. TWI_DIR=(1<<SDA)|(1<<SCL);
25. TWI_PORT=(1<<SDA)|(1<<SCL);
26. delay_counts(20);
27. TWI_PORT&=~(1<<SDA);
28. delay_counts(10);
29. TWI_PORT&=~(1<<SCL);
30. delay_counts(10);
31. }
32. 
    
33. void twi_stop(void){
34. TWI_PORT&=~(1<<SCL);
35. TWI_PORT&=~(1<<SDA);
36. TWI_PORT|=(1<<SCL);
37. delay_counts(10);
38. TWI_PORT|=(1<<SDA);
39. delay_counts(10);
40. TWI_PORT=(1<<SDA)|(1<<SCL);
41. delay_counts(20);
42. }
43. /*
44. void twi_write(char data){
45. char temp=0;
46. for (unsigned char i=0;i<8;i++)
47. {
48. TWI_PORT&=~(1<<SCL);
49. temp=data&(1<<7);
50. if(temp==0) TWI_PORT&=~(1<<SDA);
51. else TWI_PORT|=(1<<SDA);
52. delay_counts(10);
53. TWI_PORT|=(1<<SCL);
54. data<<=1;
55. delay_counts(10);
57. }
58. TWI_PORT&=~(1<<SDA);
59. TWI_PORT&=~(1<<SCL);
60. TWI_DIR&=~(1<<SDA);
61. while(TWI_PORT&(1<<SDA)==0);
62. delay_counts(10);
63. TWI_PORT|=(1<<SCL);
64. delay_counts(10);
65. TWI_DIR=(1<<SDA)|(1<<SCL);
66. }
67. */
68. void twi_write(char data){
69. char temp=0;
70. TWI_DIR|=(1<<SDA)|(1<<SCL);
71. for (unsigned char i=0;i<9;i++)
72. {
73. TWI_PORT&=~(1<<SCL);
74. if(i<8){
75. temp=data&0x80;
76. if(temp==0) TWI_PORT&=~(1<<SDA);
77. else TWI_PORT|=(1<<SDA);
78. }
79. else{
80. TWI_PORT&=~(1<<SDA);
81. TWI_DIR&=~(1<<SDA);
82. while(TWI_SDA_IN&(1<<SDA)==0);
83. }
84. delay_counts(100);
85. TWI_PORT|=(1<<SCL);
86. data<<=1;
87. delay_counts(100);
88. }
89. TWI_DIR|=(1<<SDA)|(1<<SCL);
90. }
91. 
    
92. char twi_read(void){
93. char temp=0,data=0;
94. for (unsigned char i=0;i<8;i++)
95. {
96. TWI_PORT&=~(1<<SCL);
97. temp=data&(1<<7);
98. temp=TWI_PORT&&(1<<SDA);
99. if(temp==1) data|=1;
100. else data|=0;
101. delay_counts(10);
102. TWI_PORT|=(1<<SCL);
103. data<<=1;
104. delay_counts(10);
106. }
107. TWI_PORT&=~(1<<SDA);
108. TWI_PORT&=~(1<<SCL);
109. //TWI_DIR&=~(1<<SDA);
110. while(TWI_PORT&(1<<SDA)==0);
111. delay_counts(10);
112. TWI_PORT|=(1<<SCL);
113. delay_counts(10);
114. TWI_DIR=(1<<SDA)|(1<<SCL);
115. }
116. 
     
117. int main(void)
118. {
119. /* Replace with your application code */
120. char i=0;
121. DDRB=0xFF;
122. twi_start();
123. twi_write(0x70);
124. twi_write(1);
125. twi_stop();
126. _delay_ms(5000);
127. twi_start();
128. twi_write(0x70);
129. twi_write(0);
130. twi_stop();
131. _delay_ms(5000);
132. while (1)
133. {
135. twi_start();
136. twi_write(0x70);
137. twi_write(1<<i);
138. twi_stop();
139. _delay_ms(500);
140. i++;
141. if(i==8) i=0;
142. /*
143. twi_start();
144. twi_write(0x70);
145. twi_write(0xF0);
146. twi_stop();
147. _delay_ms(500);
148. */
149. }
150. }
151. 
     

I didn't test this firmware in real hardware. But I think it work like the one's in software simulator. 

PCF8574AP Software TWI GPIO Port Reading and Writing 

Now I added and test a software TWI write routine. The master ATMega644P MCU periodically send data between PORTB and I/O port of the PCF8574AP.

PCF8574AP GPIO Port Reading and Writing

The lower nibble of PORTB is an output port while its higher nibble is an input port. The lower nibble of PCF8574AP is an input port while its higher nibble is an output port. The data is exchanged between these two chip periodically.

Source File "main.c" :

1. /*
2. * 11-soft_twi_pcf8574ap_ex.c
3. *
4. * Created: 2/12/2026 9:02:47 AM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #define TWI_PORT PORTC
13. #define TWI_SDA_IN PINC
14. #define TWI_DIR DDRC
15. 
    
16. const char SDA=1;
17. const char SCL=0;
18. const char PULSE=20;
19. 
    
20. void delay_counts(unsigned int count){
21. for(unsigned int i=0;i<count;i++);
22. }
23. 
    
24. void twi_start(void){
25. TWI_DIR|=(1<<SDA)|(1<<SCL);
26. TWI_PORT|=(1<<SDA)|(1<<SCL);
27. delay_counts(PULSE);
28. TWI_PORT&=~(1<<SDA);
29. delay_counts(PULSE);
30. TWI_PORT&=~(1<<SCL);
31. delay_counts(PULSE);
32. }
33. 
    
34. void twi_stop(void){
35. TWI_PORT&=~(1<<SCL);
36. TWI_PORT&=~(1<<SDA);
37. TWI_PORT|=(1<<SCL);
38. delay_counts(PULSE);
39. TWI_PORT|=(1<<SDA);
40. delay_counts(PULSE);
41. TWI_PORT|=(1<<SDA)|(1<<SCL);
42. delay_counts(PULSE);
43. }
44. 
    
45. void twi_write(char data){
46. char temp=0;
47. TWI_DIR|=(1<<SDA)|(1<<SCL);
48. for (unsigned char i=0;i<9;i++)
49. {
50. TWI_PORT&=~(1<<SCL);
51. delay_counts(PULSE);
52. if(i<8){
53. temp=data&0x80;
54. if(temp==0) TWI_PORT&=~(1<<SDA);
55. else TWI_PORT|=(1<<SDA);
56. }
57. else{
58. TWI_PORT&=~(1<<SDA);
59. TWI_DIR&=~(1<<SDA);
60. while(TWI_SDA_IN&(1<<SDA)==0);
61. }
63. TWI_PORT|=(1<<SCL);
64. delay_counts(PULSE);
65. data<<=1;
66. }
67. TWI_DIR|=(1<<SDA)|(1<<SCL);
68. }
69. 
    
70. char twi_read(void){
71. char temp=0,data=0;
72. TWI_DIR&=~(1<<SDA);
73. for (unsigned char i=0;i<9;i++)
74. {
75. TWI_PORT&=~(1<<SCL);
76. delay_counts(PULSE);
78. if(i<8){
79. /*
80. data<<=1;
81. temp=TWI_SDA_IN&(1<<SDA);
82. if(temp==(1<<SDA)) data|=1;
83. else data|=0;
84. */
86. temp=TWI_SDA_IN&(1<<SDA);
87. temp>>=1;
88. data|=(temp<<(7-i));
90. }
91. else{
92. while((TWI_SDA_IN&(1<<SDA))==0);
93. }
94. TWI_PORT|=(1<<SCL);
95. delay_counts(PULSE);
96. }
97. return data;
98. }
99. 
    
100. int main(void)
101. {
102. /* Replace with your application code */
103. char data;
104. DDRB=0x0F;
105. PORTB=0xF0;
106. twi_start();
107. twi_write(0x70);
108. twi_write(0x0F);
109. twi_stop();
110. _delay_ms(100);
112. while (1)
113. {
114. twi_start();
115. twi_write(0x71);
116. data=twi_read();
117. twi_stop();
118. _delay_ms(100);
119. //Send Data To PORTB and Turn On Pull Up For PINC4:PINC7
120. PORTB=data|0xF0;
121. //Read PINB Turn On Pull Up For P3:P0
122. data=PINB|0x0F;
123. twi_start();
124. twi_write(0x70);
125. twi_write(data);
126. twi_stop();
127. _delay_ms(100);
128. }
129. }
130. 
     
131. 
     
132. 
     
133. 
     
134. 
     

I don't need to test this example on a physical hardware because it work nearly identical. We can use this chip to make a 4x4 matrix keypad. In this post the dedicated TWI module of this chip make a key pad scanning via a PCF8574AP.

PCF8574AP Software TWI HD44780 LCD and DS1307 RTC

I tested the on-board DS13017 RTC and the HD44780 based 16x2 characters LCD. This 8-bit parallel port LCD operates in its 4-bit data transfer mode at PORTC. The software TWI uses PORTC PC0(SCL) and PC1(SDA) in the same port with the LCD. It doesn't cause any problem since I use masking in C program.

AVR Prototype Board

Source Code "main.c" : 

1. /*
2. * 11-soft_twi_ds1307_lcd.c
3. *
4. * Created: 2/10/2026 3:03:24 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. #define TWI_PORT PORTC
13. #define TWI_SDA_IN PINC
14. #define TWI_DIR DDRC
15. 
    
16. const char SDA=1;
17. const char SCL=0;
18. const unsigned int PULSE=100;
19. 
    
20. //DS1307 and DS3231 RTC Chip
21. const char DS1307_W=0xD0;
22. const char DS1307_R=0xD1;
23. //AT24C16B 16kB EEPROM
24. const char AT24C16B_W=0xA0;
25. const char AT24C16B_R=0xA1;
26. //PCF8574 and PCF8574A Series
27. const char PCF8574_W=0x40;
28. const char PCF8574_R=0x41;
29. const char PCF8574A_W=0x70;
30. const char PCF8574A_R=0x71;
31. //DIY Arduino PCF8574T LCD Module
32. const char PCF8574T_LCD_W=0x4E;
33. const char PCF8574T_LCD_R=0x4F;
34. //SH1106 OLED Module
35. const char SH1106_W=0x78;
36. const char SH1106_R=0x79;
37. //MCP23017 GPIO Expansion
38. const char MCP23017_W=0x40;
39. const char MCP23017_R=0x41;
40. 
    
41. void delay_counts(unsigned int count){
42. for(unsigned int i=0;i<count;i++);
43. }
44. 
    
45. void twi_start(void){
46. TWI_DIR|=(1<<SDA)|(1<<SCL);
47. TWI_PORT|=(1<<SDA)|(1<<SCL);
48. delay_counts(PULSE);
49. TWI_PORT&=~(1<<SDA);
50. delay_counts(PULSE);
51. TWI_PORT&=~(1<<SCL);
52. delay_counts(PULSE);
53. }
54. 
    
55. void twi_stop(void){
56. TWI_DIR|=(1<<SDA)|(1<<SCL);
57. TWI_PORT&=~(1<<SCL);
58. TWI_PORT&=~(1<<SDA);
59. TWI_PORT|=(1<<SCL);
60. delay_counts(PULSE);
61. TWI_PORT|=(1<<SDA);
62. delay_counts(PULSE);
63. TWI_PORT|=(1<<SDA)|(1<<SCL);
64. delay_counts(PULSE);
65. }
66. 
    
67. void twi_write(char data){
68. char temp=0;
69. TWI_DIR|=(1<<SDA)|(1<<SCL);
70. for (unsigned char i=0;i<9;i++)
71. {
72. TWI_PORT&=~(1<<SCL);
73. delay_counts(PULSE);
74. if(i<8){
75. temp=data&0x80;
76. if(temp==0) TWI_PORT&=~(1<<SDA);
77. else TWI_PORT|=(1<<SDA);
78. }
79. else{
80. TWI_PORT&=~(1<<SDA);
81. TWI_DIR&=~(1<<SDA);
82. while(TWI_SDA_IN&(1<<SDA)==0);
83. }
84. TWI_PORT|=(1<<SCL);
85. delay_counts(PULSE);
86. data<<=1;
87. }
88. TWI_DIR|=(1<<SDA)|(1<<SCL);
89. }
90. 
    
91. char twi_read(void){
92. char temp=0,data=0;
93. TWI_DIR&=~(1<<SDA);
94. for (unsigned char i=0;i<9;i++)
95. {
96. TWI_PORT&=~(1<<SCL);
97. delay_counts(PULSE);
98. TWI_PORT|=(1<<SCL);
99. delay_counts(PULSE);
103. if(i<8){
104. /*
105. data<<=1;
106. temp=TWI_SDA_IN&(1<<SDA);
107. if(temp==(1<<SDA)) data|=1;
108. else data|=0;
109. */
110. /*
111. temp=TWI_SDA_IN&(1<<SDA);
112. temp>>=1;
113. data|=temp<<(7-i);
114. */
115. data<<=1;
116. if (TWI_SDA_IN&(2))
117. {
118. data|=1;
119. }
121. }
122. else{
123. while((TWI_SDA_IN&(1<<SDA))==0);
125. }
127. }
129. return data;
130. }
131. 
     
132. void rtc_init(void){
133. char rtc[8]={0x30,0x10,0x21,0x04,0x11,0x02,0x26,1<<4};
134. for (char i=0;i<8;i++)
135. {
136. twi_start();
137. //D0 is DS1307 Write Address
138. twi_write(DS1307_W);
139. //Select Control Register
140. twi_write(i);
141. //Enable SQWE bit blinks at 1 Hz
142. twi_write(rtc[i]);
143. twi_stop();
144. _delay_ms(10);
145. }
146. }
147. 
     
148. char rtc[7], msg[16];
149. void rtc_read(void){
150. for(char i=0;i<7;i++){
151. /*Second Register*/
152. twi_start();
153. twi_write(DS1307_W);
154. /*Select Second register*/
155. twi_write(i);
156. twi_stop();
157. _delay_ms(10);
159. twi_start();
160. twi_write(DS1307_R);
161. rtc[i]=twi_read();
162. twi_stop();
163. _delay_ms(10);
164. }
165. }
166. 
     
167. int main(void)
168. {
169. /* Replace with your application code */
170. lcd_init();
171. lcd_text("ATMega644P RTC");
172. lcd_xy(1,2);
173. lcd_text("Software TWI");
174. _delay_ms(10000);
175. lcd_clear();
176. char count;
177. lcd_command(0x0C);
178. //rtc_init();
179. while (1)
180. {
181. rtc_read();
182. lcd_xy(1,1);
183. sprintf(msg,"Time: %02X:%02X:%02X",rtc[2],rtc[1],rtc[0]);
184. lcd_text(msg);
185. lcd_xy(1,2);
186. sprintf(msg,"Date: %02X/%02X/20%02X",rtc[4],rtc[5],rtc[6]);
187. lcd_text(msg);
188. _delay_ms(500);
189. }
190. }
191. 
     

This package contain the HD44780 LCD driver.

Simulation Program

 In simulation program it run without error.

 

 

 

Click here to download this example. 

 

PCF8574T HD44780 Character LCD Controller

Driving an HD4470 based character LCD using the PCF8574T is very easy. A character LCD with a PCF8574T is widely available at very low cost. It uses only four wires connects to a master MCU, GND, VCC, SDA and SCL. 

PCF8574T HD44780 Character LCD Controller

We don't need to use its full 8-bit data transfer mode. Sending the 8-bit data or command twice using its 4-bit data transfer mode is suitable for most of applications.

Source Code: 

1. /*
2. * 11-soft_twi_pcf8574T_1602.c
3. *
4. * Created: 2/12/2026 4:04:24 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. /*TWI LCD Driver*/
13. #define RS 0
14. #define RW 1
15. #define EN 2
16. #define BL 3
17. 
    
18. #define twi_lcd_cursor_off() twi_lcd_command(0x0C)
19. #define twi_lcd_line_1() twi_lcd_command(0x80)
20. #define twi_lcd_line_2() twi_lcd_command(0xC0)
21. 
    
22. char backLight=1;
23. 
    
24. void twi_lcd_command(uint8_t command){
25. uint8_t data;
26. data=command&0xF0;
27. pcf8574_write(data|(backLight<<BL)|(1<<EN));
28. //_delay_us(10);
29. pcf8574_write(data|(backLight<<BL));
30. //_delay_us(50);
32. data=command<<4;
33. pcf8574_write(data|(backLight<<BL)|(1<<EN));
34. //_delay_us(10);
35. pcf8574_write(data|(backLight<<BL));
36. //_delay_us(50);
37. }
38. 
    
39. void twi_lcd_data(uint8_t command){
40. uint8_t data;
41. data=command&0xF0;
42. pcf8574_write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
43. //_delay_us(10);
44. pcf8574_write(data|(backLight<<BL)|(1<<RS));
45. _delay_us(50);
47. data=command<<4;
48. pcf8574_write(data|(backLight<<BL)|(1<<EN)|(1<<RS));
49. //_delay_us(10);
50. pcf8574_write(data|(backLight<<BL)|(1<<RS));
51. //_delay_us(50);
52. }
53. 
    
54. void twi_lcd_xy(int8_t x, int8_t y){
55. int8_t addr[]={0x80,0xC0};
56. twi_lcd_command(addr[y-1]+x-1);
57. }
58. 
    
59. void twi_lcd_text(int8_t *txt){
60. while(*txt) twi_lcd_data(*txt++);
61. }
62. 
    
63. void twi_lcd_clear(void){
64. twi_lcd_command(0x01);
65. _delay_ms(5);
66. }
67. 
    
68. void twi_lcd_init(void){
69. pcf8574_write(0);
70. //_delay_ms(10);
71. twi_lcd_command(0x33);
72. //_delay_us(10);
73. twi_lcd_command(0x32);
74. //_delay_us(10);
75. twi_lcd_command(0x28);
76. //_delay_us(10);
77. twi_lcd_command(0x0F);
78. //_delay_us(10);
79. twi_lcd_command(0x01);
80. //_delay_ms(5);
81. twi_lcd_command(0x06);
82. //_delay_us(10);
83. }
84. 
    
85. int main(void)
86. {
87. /* Replace with your application code */
88. twi_lcd_init();
89. twi_lcd_text("Software TWI");
90. twi_lcd_line_2();
91. twi_lcd_text("PCF8574T LCD");
92. twi_lcd_cursor_off();
93. while (1)
94. {
95. }
96. }
97. 
    

Schematic:

PCF8574T HD44780 Character LCD Controller

 

AVR Prototype Board:

PCF8574T HD44780 Character LCD Controller

Click here to download its source file. 

PCF8574T HD44780 Character LCD and DS1307 RTC

At this point the ATMega644P master MCU read the RTC data from the on-board DS1307 Real Time Clock (RTC). The date and time data will show on an HD44780 character LCD via its driver PCF8574T. The software TWI work fine without reading or writing error.

PCF8574T HD44780 Character LCD and DS1307 RTC

 

Source Code:

1. /*
2. * 11-soft_twi_ds1307_pcf8574T_1602.c
3. *
4. * Created: 2/12/2026 5:21:17 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #define F_CPU 16000000UL
11. 
    
12. char rtc[7], msg[16];
13. void rtc_read(void){
14. for(char i=0;i<7;i++){
15. /*Second Register*/
16. twi_start();
17. twi_write(0xD0);
18. /*Select Second register*/
19. twi_write(i);
20. twi_stop();
21. _delay_ms(10);
23. twi_start();
24. twi_write(0xD1);
25. rtc[i]=twi_read();
26. twi_stop();
27. _delay_ms(10);
28. }
29. }
30. 
    
31. void rtc_init(void){
32. char rtc[8]={0x30,0x10,0x21,0x04,0x11,0x02,0x26,1<<4};
33. for (char i=0;i<8;i++)
34. {
35. twi_start();
36. //D0 is DS1307 Write Address
37. twi_write(0xD0);
38. //Select Control Register
39. twi_write(i);
40. //Enable SQWE bit blinks at 1 Hz
41. twi_write(rtc[i]);
42. twi_stop();
43. _delay_ms(10);
44. }
45. }
46. 
    
47. int main(void)
48. {
49. /* Replace with your application code */
50. twi_lcd_init();
51. twi_lcd_text("Software TWI");
52. twi_lcd_line_2();
53. twi_lcd_text("DS1307 PCF8574T");
54. _delay_ms(10000);
55. twi_lcd_clear();
56. twi_lcd_cursor_off();
57. while (1)
58. {
59. rtc_read();
60. twi_lcd_line_1();
61. sprintf(msg,"Time: %02X:%02X:%02X",rtc[2],rtc[1],rtc[0]);
62. twi_lcd_text(msg);
63. twi_lcd_line_2();
64. sprintf(msg,"Date: %02X/%02X/20%02X",rtc[4],rtc[5],rtc[6]);
65. twi_lcd_text(msg);
66. _delay_ms(500);
67. }
68. }
69. 
    

Schematic:

PCF8574T HD44780 Character LCD and DS1307 RTC

AVR Prototype Board:

 

 

Click here to download its source file.

PCF8574T HD44780 Character LCD and DS3231 RTC

There are a lot of newer Real Time Clock chip that consumes lower energy, rich of functions and more precise. The DS3231 or DS3232 is a TWI Real Time Clock(RTC) that has some addional functions for example alarm setting and alarm triggering. Its timing data is very precise due to its internal clock and programmable capacitors.

 

I bought a few Arduino DS3231 RTC AT2432N EEPROM module around 2USD. Its slave address and data/time data are quivalent to the DS1307. So I don't need to write additional firmware for this example. It work the same way as above. I just modify some lines of code.

Schematic:

Schematic

The DS3231 and PCF8574T connected on a single TWI bus.

AVR Experiment Board:

 

MCP23017 16-bit GPIO Example

The Microchip MCP23017 is a TWI 16-bit GPIO expansion chip. It I/O port and internal structure is well organized. However it's more expensive than the PCF8574. The PCF8574 is more popular and widely available at very low cost.

MCP23017 Chip and Module

 

Package Types

For more example about using this chip please see this post. 

In this example the ATMega644P implements its software TWI to read data from GPB and send it back to GPA of the MCP23017. 

MCP23017 16-bit GPIO Example

 

Source Code "main.c":

/*
 * 11-soft_twi_mcp23017_gpio.c
 *
 * Created: 2/12/2026 9:40:26 PM
 * Author : Admin
 */ 

#include <avr/io.h>
#include <util/delay.h>
#define F_CPU 16000000UL

#define TWI_PORT PORTC
#define TWI_SDA_IN PINC
#define TWI_DIR  DDRC

const char SDA=1;
const char SCL=0;
const char PULSE=20;

void delay_counts(unsigned int count){
	for(unsigned int i=0;i<count;i++);	
}

void twi_start(void){
	TWI_DIR|=(1<<SDA)|(1<<SCL);
	TWI_PORT|=(1<<SDA)|(1<<SCL);
	delay_counts(PULSE);
	TWI_PORT&=~(1<<SDA);
	delay_counts(PULSE);
	TWI_PORT&=~(1<<SCL);
	delay_counts(PULSE);
}

void twi_stop(void){
	TWI_PORT&=~(1<<SCL);
	TWI_PORT&=~(1<<SDA);
	TWI_PORT|=(1<<SCL);
	delay_counts(PULSE);
	TWI_PORT|=(1<<SDA);
	delay_counts(PULSE);
	TWI_PORT|=(1<<SDA)|(1<<SCL);
	delay_counts(PULSE);
}

void twi_write(char data){
	char temp=0;
	TWI_DIR|=(1<<SDA)|(1<<SCL);
	for (unsigned char i=0;i<9;i++)
	{
		TWI_PORT&=~(1<<SCL);
		delay_counts(PULSE);
		if(i<8){
			temp=data&0x80;
			if(temp==0) TWI_PORT&=~(1<<SDA);
			else TWI_PORT|=(1<<SDA);
		}		
		else{
			TWI_PORT&=~(1<<SDA);
			TWI_DIR&=~(1<<SDA);
			while(TWI_SDA_IN&(1<<SDA)==0);
		}	
		
		TWI_PORT|=(1<<SCL);
		delay_counts(PULSE);	
		data<<=1;
	}
	TWI_DIR|=(1<<SDA)|(1<<SCL);
}

char twi_read(void){
	char temp=0,data=0;
	TWI_DIR&=~(1<<SDA);
	for (unsigned char i=0;i<9;i++)
	{
		TWI_PORT&=~(1<<SCL);
		delay_counts(PULSE);
		
		if(i<8){
			/*
			data<<=1;
			temp=TWI_SDA_IN&(1<<SDA);
			if(temp==(1<<SDA)) data|=1;
			else data|=0;
			*/
			
			temp=TWI_SDA_IN&(1<<SDA);
			temp>>=1;
			data|=(temp<<(7-i));
			
		}
		else{		
			while((TWI_SDA_IN&(1<<SDA))==0);			
		}
		TWI_PORT|=(1<<SCL);
		delay_counts(PULSE);	
	}
	return data;
}

// MCP2017 Routine
//MCP23017 TWI Slave Address
const char MCP23017_W=0x40;
const char MCP23017_R=0x41;

//IOCON.BANK=0
enum BANK0{
	IODIRA=0,IODIRB,IPOLA,IPOLB,GPINTENA,GPINTENB,DEFVALA,
	DEFVALB,INTCONA,INTCONB,IOCON1,IOCON2,GPPUA,GPPUB,
	INTFA,INTFB,INTCAPA,INTCAPB,GPIOA,GPIOB,OLATA,OLATB
};


void mcp23017_write(char address,char data){
	twi_start();
	/*Select the write address*/
	twi_write(MCP23017_W);
	/*Select a register address*/
	twi_write(address);
	/*Send configuration data*/
	twi_write(data);
	twi_stop();
}

unsigned char mcp23017_read(char address){
	/*Select a specific address*/
	twi_start();
	twi_write(MCP23017_W);
	twi_write(address);
	twi_stop();
	/*Read data from the given address*/
	twi_start();
	twi_write(MCP23017_R);
	unsigned char i2cData=twi_read();
	twi_stop();
	return i2cData;
}

int main(void)
{
    /* Replace with your application code */
	char data;
	/*Set GPIOA To Output*/
	mcp23017_write(IODIRA,0x00);
	/*Set GPIOB To Input With Pull Up Enable*/
	mcp23017_write(IODIRB,0xFF);
	mcp23017_write(GPPUB,0xFF);
    while (1) 
    {
	/*Read GPIOB*/
	data=mcp23017_read(GPIOB);
	_delay_ms(10);
	/*Send Data to OLATA*/
	mcp23017_write(OLATA,data);
	_delay_ms(10);
    }
}

I use C enum to keep all registers of the MCP23017 chip. 

Schematic and Simulation: 

Schematic and Simulation

I tested this example on my AVR Prototype Board.

AVR Prototype Board

 

AVR Prototype Board

 

AVR Prototype Board

We can use this chip to make a 4x4 matrix keypad and character LCD controlling etc. For more examples about using this chip please visit these posts.

• ATMega644P TWI MCP23017 GPIO Example 
• ATMega644P TWI MCP23017 LCD Keypad 
• ATMega644P TWI MCP23017 Character LCD 

For a full list of ATMega644P AVR C programming tutorials see this page.