ATMega644P TWI DS1307 and AT24C16 EEPROM Interfacing

The Two Wire Interface (TWI) is a serial communication protocol that uses only two wires, Serial Data (SDA) and Serial Clock (SCL). In some micro-controllers especially the PIC family it called I2C (Inter Integrated Circuit). It's bi-directional between master and slave devices. The MCU is a master device whenever it interfaces to a TWI peripheral device for instance a Real Time Clock (RTC). However between two TWI micro-controllers the user can select one of them to be a master or a slave device. For more information about the I2C please visit this link.

AVR ATMega644P Prototype Board

There are a lot TWI slave devices, EEPROM, Real Time Clock (RTC), Environmental Sensor and Graphical Display etc. For example,

• DS1307, DS3231 RTC
• AT24C08, AT24C16B EEPROM
• BME280 Temperature and Humidity Sensor
• SH1106 SD1306 OLED Display 

 

The ATMega644P TWI Interface

The ATMega644P has a TWI module that use a 7-bit addressing that allows up to 127 connection devices. It supports up to 400kHz clock rate via its baud rate generator and its pre-scaler. For more information about the TWI of AVR micro-controller please see this link. I won't write it here anymore due to duplication.

TWI Bus Interconnection

Since the clock and data pins of the TWI are open-drain they need two weak pull up resistors between 4.7kΩ to 10kΩ. It depends on the wires length, data and clock rate.

Overview of the TWI Module

The programmer must configure these registers to set a proper operation of the TWI:

1. TWBR – TWI Bit Rate Register
2.  TWCR – TWI Control Register
3.  TWSR – TWI Status Register
4.  TWDR – TWI Data Register
5.  TWAR – TWI (Slave) Address Register
6.  TWAMR – TWI (Slave) Address Mask Register

Its SCL frequency is the clock rate of the TWI transmission. It is calculated via this equation:

SCL frequency

 

For more information please the datasheet of this device. 

The DS1307 Real Time Clock (RTC)

This is an old TWI RTC chip released a few decade now. Its function is not rich compare to newer TWI RTC chip for instance the DS3231 RTC. It communication interface and internal organization is very simple.

The DS1307 Chip and RTC Module

DS1307 Pin Diagrams

TYPICAL OPERATING CIRCUIT

 Its date and time data are stored in device's SRAM. The SRAM contains date, time, configuration and user data. SRAM data are keep alive by an additional back up battery typically a CR2032 coin battery.

Timekeeper Registers

In this example the MCU read its time and date data and display them on a character LCD. This program requires the HD44780 LCD driver that I don't put them here. Please see this link. We just need to copy the hd44780.h and the hd44780.c to project source folder and add them to the project.

1. /*
2. * 10-i2c_ds1307_lcd.c
3. *
4. * Created: 1/31/2026 8:15:30 AM
5. * Author : Admin
6. */
7. 
   
8. 
   
9. #include <avr/io.h>
10. #include <util/delay.h>
11. #include <stdio.h>
12. 
    
13. #define F_CPU 16000000UL
14. 
    
15. void i2cInit(void){
16. TWSR|=0x00; //Prescaler Selection Bit
17. TWBR=0xF0; //Baud Rate Generator
18. TWCR=(1<<TWEN); //Enable The TWI Module
19. PORTC|=(1<<0);
20. PORTC|=(1<<1);
21. }
22. 
    
23. void i2cStart(void){
24. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
25. while((TWCR&(1<<TWINT))==0);
26. }
27. 
    
28. void i2cWrite(unsigned char data){
29. TWDR=data;
30. TWCR=(1<<TWINT)|(1<<TWEN);
31. while((TWCR&(1<<TWINT))==0);
32. }
33. 
    
34. unsigned char i2cRead(char ACK){
35. if(ACK==0)
36. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
37. else
38. TWCR=(1<<TWINT)|(1<<TWEN);
39. while((TWCR&(1<<TWINT))==0);
40. return TWDR;
41. }
42. 
    
43. void i2cStop(){
44. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
45. _delay_us(10);
46. }
47. 
    
48. void rtc_init(void){
49. //i2cStart();
50. /*D0 is DS1307 Write Address*/
51. //i2cWrite(0xD0);
52. /*Select Control Register*/
53. //i2cWrite(0x07);
54. /*Enable SQWE bit blinks at 1 Hz*/
55. //i2cWrite(1<<4);
56. //i2cStop();
57. //_delay_ms(1);
58. char rtc[8]={0x30,0x00,0x17,0x07,0x31,0x01,0x26,1<<4};
59. for (char i=0;i<8;i++)
60. {
61. i2cStart();
62. //D0 is DS1307 Write Address
63. i2cWrite(0xD0);
64. //Select Control Register
65. i2cWrite(i);
66. //Enable SQWE bit blinks at 1 Hz
67. i2cWrite(rtc[i]);
68. i2cStop();
69. _delay_ms(10);
70. }
71. }
72. 
    
73. struct rtc{
74. char Seconds;
75. char Minutes;
76. char Hours;
77. char Day;
78. char Date;
79. char Month;
80. char Year;
81. char Control;
82. };
83. 
    
84. char rtc[6], msg[16];
85. 
    
86. int main(void)
87. {
88. _delay_ms(1000);
89. DDRB=0xFF;
90. struct rtc my_rtc={0x30,0x00,0x03,0x07,0x31,0x01,0x26,1<<4};
91. i2cInit();
92. lcd_init();
93. 
    
94. lcd_text("ATMega644P I2C");
95. lcd_xy(1,2);
96. lcd_text("ds1307 RTC");
97. _delay_ms(10000);
98. lcd_clear();
99. char count;
100. lcd_command(0x0C);
101. //rtc_init();
102. char counter=0;
103. while (1)
104. {
105. for(char i=0;i<7;i++){
106. /*Second Register*/
107. i2cStart();
108. i2cWrite(0xD0);
109. /*Select Second register*/
110. i2cWrite(i);
111. i2cStop();
112. _delay_us(10);
115. i2cStart();
116. i2cWrite(0xD1);
117. rtc[i]=i2cRead(1);
118. i2cStop();
119. _delay_us(10);
120. //PORTB=rtc[i];
122. }
124. lcd_xy(1,1);
125. sprintf(msg,"Time: %02X:%02X:%02X",rtc[2],rtc[1],rtc[0]);
126. lcd_text(msg);
127. lcd_xy(1,2);
128. sprintf(msg,"Date: %02X/%02X/20%02X",rtc[4],rtc[5],rtc[6]);
129. lcd_text(msg);
130. counter++;
131. if(counter>=2) { PORTB=1; counter=0;}
132. else PORTB=0;
133. _delay_ms(500);
134. }
135. }
136. 
     

However the HD44780 LCD driver is placed in separated package, "hd44780.h" and "hd44780.c". We just copy this two files into the project source folder with the "main.c". Then we just include the "hd44780.c" in main function to be able calling its functions. Anyway if we add the "hd44780.c" files into project workspace we don't need to include it in main C source file.

The hd44780.h

1. /*
2. * hd44780.h
3. *
4. * Created: 1/28/2026 9:56:39 PM
5. * Author: Admin
6. */
7. 
   
8. 
   
9. #ifndef HD44780_H_
10. #define HD44780_H_
11. 
    
12. 
    
13. 
    
14. 
    
15. 
    
16. #endif /* HD44780_H_ */
17. 
    
18. #include <avr/io.h>
19. #include <stdio.h>
20. #include <util/delay.h>
21. #define F_CPU 16000000UL
22. 
    
23. #define RS 2
24. #define EN 3
25. 
    
26. const char d_time=50;
27. 
    
28. void lcd_command(char command);
29. void lcd_data(char data);
30. void lcd_init(void);
31. void lcd_xy(char x, char y);
32. void lcd_text(char *text);
33. void lcd_clear(void);

The hd44780.c

1. /*
2. * hd44780.c
3. *
4. * Created: 1/28/2026 9:55:18 PM
5. * Author: Admin
6. */
7. 
   
8. 
   
9. #include "hd44780.h"
10. 
    
11. 
    
12. void lcd_command(char command){
13. char temp;
14. temp=command&0xF0;
15. PORTC=temp|(1<<EN);
16. _delay_us(d_time);
17. PORTC=temp;
18. _delay_us(d_time);
20. temp=command<<4;
21. PORTC=temp|(1<<EN);
22. _delay_us(d_time);
23. PORTC=temp;
24. _delay_us(d_time);
25. }
26. 
    
27. void lcd_data(char data){
28. char temp;
29. temp=data&0xF0;
30. PORTC=temp|(1<<EN)|(1<<RS);
31. _delay_us(d_time);
32. PORTC=temp|(1<<RS);
33. _delay_us(d_time);
35. temp=data<<4;
36. PORTC=temp|(1<<EN)|(1<<RS);
37. _delay_us(d_time);
38. PORTC=temp|(1<<RS);
39. _delay_us(d_time);
40. }
41. void lcd_init(void){
42. DDRC=0xFF;
43. lcd_command(0x33);
44. _delay_us(100);
45. lcd_command(0x32);
46. _delay_us(100);
47. lcd_command(0x28);
48. _delay_us(100);
49. lcd_command(0x0F);
50. _delay_us(100);
51. lcd_command(0x01);
52. _delay_ms(5);
53. lcd_command(0x06);
54. _delay_us(100);
55. }
56. void lcd_xy(char x, char y){
57. char addr[]={0x80,0xC0};
58. lcd_command(addr[y-1]+x-1);
59. }
60. void lcd_text(char *text){
61. while(*text) lcd_data(*text++);
62. }
63. void lcd_clear(void){
64. lcd_command(0x01);
65. _delay_ms(5);
66. }
67. 
    

The RTC chip is halted whenever it's newly inserted or error by the MCU program for instance a high speed TWI clock rate. 

Shematic:

Schematic and Simulation

AVR Prototype Board: 

Start Up Screen

Date and Time Reading

This PCB also has a 6-digit common cathode display. Here The RTC time value will display on this display instead:

Source Code:

1. /*
2. * 10-i2c_ds1307_7.c
3. *
4. * Created: 2/1/2026 4:02:12 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 d_time=5;
13. const char cc_7[16]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,
14. 0x07,0x7F,0x6F,0x77,0x7C,0x39,0x5E,0x79,0x71};
15. volatile long count=0,temp=0;
16. unsigned int loop_count=0;
17. char rtc[6],digits=0;
18. 
    
19. void i2cInit(void){
20. TWSR|=0x00; //Prescaler Selection Bit
21. TWBR=0xF0; //Baud Rate Generator
22. TWCR=(1<<TWEN); //Enable The TWI Module
23. PORTC|=(1<<0);
24. PORTC|=(1<<1);
25. }
26. 
    
27. void i2cStart(void){
28. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
29. while((TWCR&(1<<TWINT))==0);
30. }
31. 
    
32. void i2cWrite(unsigned char data){
33. TWDR=data;
34. TWCR=(1<<TWINT)|(1<<TWEN);
35. while((TWCR&(1<<TWINT))==0);
36. }
37. 
    
38. unsigned char i2cRead(char ACK){
39. if(ACK==0)
40. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
41. else
42. TWCR=(1<<TWINT)|(1<<TWEN);
43. while((TWCR&(1<<TWINT))==0);
44. return TWDR;
45. }
46. 
    
47. void i2cStop(){
48. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
49. _delay_us(10);
50. }
51. 
    
52. void rtc_init(void){
53. char rtc[8]={0x30,0x00,0x17,0x07,0x31,0x01,0x26,1<<4};
54. for (char i=0;i<7;i++)
55. {
56. i2cStart();
57. //D0 is DS1307 Write Address
58. i2cWrite(0xD0);
59. //Select Control Register
60. i2cWrite(i);
61. //Enable SQWE bit blinks at 1 Hz
62. i2cWrite(rtc[i]);
63. i2cStop();
64. _delay_ms(10);
65. }
66. }
67. 
    
68. void show_ds1307(int times){
69. for (int i=0;i<times;i++)
70. {
71. PORTC=0;
72. PORTB=cc_7[13];
73. PORTC=0x20;
74. _delay_ms(d_time);
76. PORTC=0;
77. PORTB=cc_7[5];
78. PORTC=0x40;
79. _delay_ms(d_time);
81. PORTC=0;
82. PORTB=cc_7[1];
83. PORTC=0x80;
84. _delay_ms(d_time);
86. PORTC=0;
87. PORTB=cc_7[3];
88. PORTC=0x04;
89. _delay_ms(d_time);
91. PORTC=0;
92. PORTB=cc_7[0];
93. PORTC=0x08;
94. _delay_ms(d_time);
96. PORTC=0;
97. PORTB=cc_7[7];
98. PORTC=0x10;
99. _delay_ms(d_time);
100. }
102. }
103. 
     
104. void rtc_read(void){
105. for(char i=0;i<3;i++){
106. /*Second Register*/
107. i2cStart();
108. i2cWrite(0xD0);
109. /*Select Second register*/
110. i2cWrite(i);
111. i2cStop();
112. //_delay_us(10);
114. i2cStart();
115. i2cWrite(0xD1);
116. rtc[i]=i2cRead(1);
117. i2cStop();
118. //_delay_us(10);
119. }
120. }
121. 
     
122. 
     
123. int main(void)
124. {
125. /* Replace with your application code */
126. _delay_ms(1000);
127. DDRB=0xFF;
128. DDRC=0xFF;
129. i2cInit();
130. show_ds1307(200);
131. //rtc_init();
132. rtc_read();
133. while (1)
134. {
136. PORTC=0;
137. PORTB=cc_7[rtc[2]>>4];
138. PORTC=0x20;
139. _delay_ms(d_time);
141. PORTC=0;
142. PORTB=cc_7[rtc[2]&0x0F];
143. PORTC=0x40;
144. _delay_ms(d_time);
146. PORTC=0;
147. PORTB=cc_7[rtc[1]>>4];
148. PORTC=0x80;
149. _delay_ms(d_time);
151. PORTC=0;
152. PORTB=cc_7[rtc[1]&0x0F];
153. PORTC=0x04;
154. _delay_ms(d_time);
156. PORTC=0;
157. PORTB=cc_7[rtc[0]>>4];
158. PORTC=0x08;
159. _delay_ms(d_time);
161. PORTC=0;
162. PORTB=cc_7[rtc[0]&0x0F];
163. PORTC=0x10;
164. _delay_ms(d_time);
166. temp++;
167. if(temp>=30){temp=0;rtc_read();}
168. }
169. }
170. 
     

Schematic:

Schematic and Simulation

AVR Prototype Board: 

  

 

 

This PCB was offered from PCBWay. 

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

The AT24C16B TWI EEPROM

The EEPROM is an auxiliary persistent storage behind the MCU's internal EEPROM and Flash when they have capacity limited. The TWI has an advantage of adding the device on the same bus without adding additional MCU's wire. However they operate at lower speed than the one's in the MCU. The TWI EEPROM was commonly found in most of old TV motherboard since the micro-processor has limited resource at that time.

A Sample of AT24C16B

I bought one lot of ten pieces of this chip since I was at college. 

Atmel AT24C16B Spec

The AT24C16B is a  TWI 16kB (2048x8) EEPROM memory storage from Atmel. However is not obsolete now. Currently there are a lot of new EEPROM with a larger memory space, low power and fast write read speed.

Block Diagram of AT24C16B

The write speed of this chip is around 100ms. So the programmer must lower the TWI clock frequency and wait for writing completion by adding delay time between write cycle.

The default write address of this chip is 0xA0 and 0xA1 is read address. 

The example below the ATMega644P write data into the AT24C16B using different data and addresses. The result will display on the character LCD and LED.

1. /*
2. * 10-i2c_at24c16b_lcd.c
3. *
4. * Created: 1/31/2026 6:33:03 PM
5. * Author : Admin
6. */
7. 
   
8. #include <avr/io.h>
9. #include <util/delay.h>
10. #include <stdio.h>
11. 
    
12. #define F_CPU 16000000UL
13. 
    
14. const write_address=0xA0;
15. const read_address=0xA1;
16. 
    
17. void i2cInit(void){
18. TWSR|=0x03; //Prescaler Selection Bit
19. TWBR=0xF0; //Baud Rate Generator
20. TWCR=(1<<TWEN); //Enable The TWI Module
21. PORTC|=(1<<0);
22. PORTC|=(1<<1);
23. }
24. 
    
25. void i2cStart(void){
26. TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
27. while((TWCR&(1<<TWINT))==0);
28. }
29. 
    
30. void i2cWrite(unsigned char data){
31. TWDR=data;
32. TWCR=(1<<TWINT)|(1<<TWEN);
33. while((TWCR&(1<<TWINT))==0);
34. }
35. 
    
36. unsigned char i2cRead(char ACK){
37. if(ACK==0)
38. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWEA);
39. else
40. TWCR=(1<<TWINT)|(1<<TWEN);
41. while((TWCR&(1<<TWINT))==0);
42. return TWDR;
43. }
44. 
    
45. void i2cStop(){
46. TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
47. _delay_us(10);
48. }
49. 
    
50. 
    
51. char msg[16];
52. 
    
53. int main(void)
54. {
55. _delay_ms(1000);
56. DDRB=0xFF;
58. i2cInit();
59. lcd_init();
60. 
    
61. lcd_text("ATMega644P I2C");
62. lcd_xy(1,2);
63. lcd_text("AT24C16B EEPROM");
64. _delay_ms(10000);
65. lcd_clear();
67. lcd_command(0x0C);
69. char counter=0;
70. uint16_t length=0;
72. DDRB=0xFF;
73. char i=0;
75. lcd_text("Writing AT24C16B");
76. i2cStart();
77. i2cWrite(write_address);
78. i2cWrite(0);
79. for (char i=0;i<16;i++) { i2cWrite('A'+i); _delay_us(1);}
80. i2cStop();
81. _delay_ms(70);
83. lcd_clear();
84. lcd_text("Reading AT24C16B");
85. lcd_xy(1,2);
86. char temp;
87. for (char i=0;i<16;i++){
88. i2cStart();
89. i2cWrite(write_address);
90. i2cWrite(i);
91. i2cStop();
93. i2cStart();
94. i2cWrite(read_address);
95. temp=i2cRead(1);
96. lcd_data(temp);
97. PORTB=temp;
98. _delay_us(1);
99. }
101. _delay_ms(10000);
102. lcd_clear();
103. lcd_text("Writing AT24C16B");
104. char *txt1="ATMega644P AVR",count1=0;
105. i2cStart();
106. i2cWrite(write_address);
107. i2cWrite(0);
108. while(*txt1) { i2cWrite(*txt1++); count1++; _delay_ms(1);}
109. i2cStop();
110. _delay_ms(70);
112. lcd_clear();
113. lcd_text("Reading AT24C16B");
114. lcd_xy(1,2);
115. for (char i=0;i<count1;i++)
116. {
117. i2cStart();
118. i2cWrite(write_address);
119. i2cWrite(i);
120. i2cStop();
122. i2cStart();
123. i2cWrite(read_address);
124. temp=i2cRead(1);
125. i2cStop();
126. lcd_data(temp);
127. PORTB=temp;
129. _delay_ms(1);
130. }
131. _delay_ms(10000);
132. lcd_clear();
133. while (1)
134. {
135. lcd_xy(1,1);
136. lcd_text("Write and Read");
137. i2cStart();
138. i2cWrite(write_address);
139. i2cWrite(10);
140. i2cWrite(i);
141. i2cStop();
142. _delay_ms(80);
144. i2cStart();
145. i2cWrite(write_address);
146. i2cWrite(10);
147. i2cStop();
149. i2cStart();
150. i2cWrite(read_address);
151. char temp=i2cRead(1);
152. i2cStop();
153. sprintf(msg,"AT24C16B: %3d %02X",temp,temp);
154. lcd_xy(1,2);
155. lcd_text(msg);
156. PORTB=temp;
157. i++;
158. }
159. }
160. 
     

The LCD driver is the one's that listed above.

 

 

 

 

 

 

Proteus simulator works very fine.

However to get a real result I tested it on my DIY AVR Prototype Board. It works fine.

Some errors cause by improper clock frequency setting and TWI read/write routines. 

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