ATMega644P and 25AA010A SPI Bus Serial EEPROM

 Overview

The Microchip Technology Inc. 25XX010A is a 1-Kbit (8-bit x 127) Serial Electrically Erasable PROM (EEPROM). The memory is accessed via a simple Serial Peripheral Interface (SPI) compatible serial bus. The bus signals required are a clock input (SCK) plus separate data in (SI) and data out (SO) lines. Access to the device is controlled through a Chip Select (CS) input. 

Since it uses the SPI interface it can handle the clock rate up to 10MHz faster than other I2C(TWI) serial EEPROM. Its read/write cycles is up to 1M times.

 

It has various device's package including a DIP-8 package for hobbyists prototyping.

Device Selection Table

This chip also has a model in Proteus that enable the engineer to test its operation by software.

 

Package Types and Pin Function Table

The SPI transfer and receive must have the following data bytes, instruction, address, and data.

Block Diagram, Instructions, and SPI Read Sequence

 

The read command is 0x03 follows by the EEPROM address. The EEPROM 8-bit data will shift out by the SPI read routine issued by the microprocessor. 

Writing data to the EEPROM requires around 5ms. It requires a write enable instruction before the data writing sequence able to process.

Write Enable and Disable Commands

 

Write-enable command is 0x06 while the Write-disable command is 0x04. Additionally the Write Protect (WP) pin must pull high to enable data writing.

Byte write sequence instruction is 0x02 follows by the EEPROM address and the 8-bit data. It also has a page write sequence to write a burst of 16 bytes data package. The microprocessor needs to wait around 5ms to complete data writing.
 

Byte and Page Write Sequences

 

The Read Status Register Instruction is optional you can read the device datasheet for more detail. 

 It's useful the for a master MCU to determine when the next read or write operation will proceed. Some programmer just use a delay function that last around 100 micro-seconds instead of using this operation.

ATMega644 and  25AA010A Interfacing

Using a dedicated SPI interface of an MCU is very fast and reliable. The internal MCU serial communication module process this serial data transmission and reception tasks.

This example show a write and read operation to the 25AA010A from a master ATMega644P SPI. Data is written to the 25AA010A prior to reading back from this chip. Then they are shown on PORTC.

Schematic

 Source Code "main.c":

1. /*
2. * 12-spi_25AA010A.c
3. *
4. * Created: 2/24/2026 2:16:04 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. 
    
15. #define DD_SS 4
16. #define DD_MOSI 5
17. #define DD_MISO 6
18. #define DD_SCK 7
19. 
    
20. void SPI_MasterInit(void)
21. {
22. /* Set MOSI and SCK output, all others input */
23. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
24. /* Enable SPI, Master, set clock rate fck/16 */
25. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
26. }
27. 
    
28. void SPI_MasterTransmit(char cData)
29. {
30. /* Start transmission */
31. SPDR = cData;
32. /* Wait for transmission complete */
33. while(!(SPSR & (1<<SPIF)))
34. ;
35. }
36. 
    
37. void SPI_SlaveInit(void)
38. {
39. /* Set MISO output, all others input */
40. DDR_SPI = (1<<DD_MISO);
41. /* Enable SPI */
42. SPCR = (1<<SPE);
43. }
44. char SPI_SlaveReceive(void)
45. {
46. /* Wait for reception complete */
47. while(!(SPSR & (1<<SPIF)))
48. ;
49. /* Return Data Register */
50. return SPDR;
51. }
52. 
    
53. // 93AA46B SPI EEPROM
54. 
    
55. void write_enable(void){
56. PRT_SPI&=~(1<<DD_SS);
57. SPI_MasterTransmit(0x06);
58. PRT_SPI|=(1<<DD_SS);
59. }
60. 
    
61. unsigned char read_status(void){
62. PRT_SPI&=~(1<<DD_SS);
63. SPI_MasterTransmit(0x05);
64. SPI_MasterTransmit(0x00);
65. unsigned char temp=SPI_SlaveReceive();
66. PRT_SPI|=(1<<DD_SS);
67. return temp;
68. }
69. void write_93AA46B(unsigned char address, unsigned char data){
70. unsigned char temp;
71. PRT_SPI&=~(1<<DD_SS);
72. SPI_MasterTransmit(0x02);
73. SPI_MasterTransmit(address);
74. SPI_MasterTransmit(data);
75. PRT_SPI|=(1<<DD_SS);
76. //Check Write Busy Flag
77. do
78. {
79. temp=read_status();
80. } while ((temp&0x01)==1);
81. }
82. 
    
83. unsigned char read_93AA46B(unsigned char address){
85. PRT_SPI&=~(1<<DD_SS);
86. SPI_MasterTransmit(0x03);
87. SPI_MasterTransmit(address);
88. SPI_MasterTransmit(0xFF);
89. unsigned char data=SPI_SlaveReceive();
90. PRT_SPI|=(1<<DD_SS);
91. return data;
92. }
93. int main(void)
94. {
95. /* Replace with your application code */
96. SPI_MasterInit();
97. PRT_SPI|=(1<<DD_SS);
98. unsigned char temp=0, data=0;
99. DDRC=0xFF;
100. write_enable();
101. while (1)
102. {
103. for (unsigned char i=0;i<8;i++)
104. {
105. write_93AA46B(i,1<<i);
106. PORTC=read_93AA46B(i);
107. _delay_ms(1000);
108. }
109. }
110. }
111. 
     
112. 
     
113. 
     
114. 
     
115. 
     

I don't have a physical device for this chip. So I just tested it in a simulator.

Now I added a character LCD to display some ASCII data. 

Schematic

 

Source Code "main.c":

1. /*
2. * 25AA010A_1602.c
3. *
4. * Created: 2/24/2026 9:36:19 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. 
    
15. #define DD_SS 4
16. #define DD_MOSI 5
17. #define DD_MISO 6
18. #define DD_SCK 7
19. 
    
20. void SPI_MasterInit(void)
21. {
22. /* Set MOSI and SCK output, all others input */
23. DDR_SPI = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);
24. /* Enable SPI, Master, set clock rate fck/16 */
25. SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
26. }
27. 
    
28. void SPI_MasterTransmit(char cData)
29. {
30. /* Start transmission */
31. SPDR = cData;
32. /* Wait for transmission complete */
33. while(!(SPSR & (1<<SPIF)))
34. ;
35. }
36. 
    
37. void SPI_SlaveInit(void)
38. {
39. /* Set MISO output, all others input */
40. DDR_SPI = (1<<DD_MISO);
41. /* Enable SPI */
42. SPCR = (1<<SPE);
43. }
44. char SPI_SlaveReceive(void)
45. {
46. /* Wait for reception complete */
47. while(!(SPSR & (1<<SPIF)))
48. ;
49. /* Return Data Register */
50. return SPDR;
51. }
52. 
    
53. // 93AA46B SPI EEPROM
54. 
    
55. void write_enable(void){
56. PRT_SPI&=~(1<<DD_SS);
57. SPI_MasterTransmit(0x06);
58. PRT_SPI|=(1<<DD_SS);
59. }
60. 
    
61. unsigned char read_status(void){
62. PRT_SPI&=~(1<<DD_SS);
63. SPI_MasterTransmit(0x05);
64. SPI_MasterTransmit(0x00);
65. unsigned char temp=SPI_SlaveReceive();
66. PRT_SPI|=(1<<DD_SS);
67. return temp;
68. }
69. void write_25AA010A(unsigned char address, unsigned char data){
70. write_enable();
71. unsigned char temp;
72. PRT_SPI&=~(1<<DD_SS);
73. SPI_MasterTransmit(0x02);
74. SPI_MasterTransmit(address&0x7F);
75. SPI_MasterTransmit(data);
76. PRT_SPI|=(1<<DD_SS);
77. //Check Write Busy Flag
78. do
79. {
80. temp=read_status();
81. } while ((temp&0x01)==1);
82. }
83. 
    
84. unsigned char read_25AA010A(unsigned char address){
85. PRT_SPI&=~(1<<DD_SS);
86. SPI_MasterTransmit(0x03);
87. SPI_MasterTransmit(address&0x7F);
88. SPI_MasterTransmit(0x00);
89. _delay_us(100);
90. unsigned char data=SPI_SlaveReceive();
91. PRT_SPI|=(1<<DD_SS);
92. return data;
93. }
94. 
    
95. int main(void)
96. {
97. /* Replace with your application code */
98. SPI_MasterInit();
99. PRT_SPI|=(1<<DD_SS);
100. lcd_init();
102. unsigned char temp[16]="ATMEGA644P SPI";
103. for (unsigned char i=0;i<16;i++)
104. {
105. write_25AA010A(i,temp[i]);
106. }
107. for (unsigned char i=0;i<16;i++)
108. {
109. temp[i]=read_25AA010A(i);
110. }
111. lcd_text(temp);
113. unsigned char temp_1[16]="25AA010A EEPROM";
114. for (unsigned char i=16;i<32;i++)
115. {
116. write_25AA010A(i,temp_1[i]);
117. }
118. for (unsigned char i=16;i<32;i++)
119. {
120. temp_1[15-i]=read_25AA010A(i);
121. }
122. lcd_xy(1,2);
123. lcd_text(temp_1);
125. while (1)
126. {
128. }
129. }

Click here to download this example.

 

 

 

PIC16F887 SPI 25AA010A EEPROM XC8 Example

Overview

The 25AA010A is 1Kbit SPI bus serial EEPROM. It could handle up to 10MHz clock frequency with a high endurance of 1M erase/write cycles. Its memory space is organized into 128x8-bit.

Simulating Program in Proteus

It has various device's package including a DIP-8 package for hobbyists prototyping.

Device Selection Table

I don't have a physical device of this chip. So I just take a model of this chip to simulate in Proteus.

Package Types and Pin Function Table

The SPI transfer and receive must have the following data bytes, instruction, address, and data.

Block Diagram, Instructions, and SPI Read Sequence

 

The read command is 0x03 follows by the EEPROM address. The EEPROM 8-bit data will shift out by the SPI read routine issued by the microprocessor. 

Writing data to the EEPROM requires around 5ms. It requires a write enable instruction before the data writing sequence able to process.

Write Enable and Disable Commands

 

Write-enable command is 0x06 while the Write-disable command is 0x04. Additionally the Write Protect (WP) pin must pull high to enable data writing.

Byte write sequence instruction is 0x02 follows by the EEPROM address and the 8-bit data. It also has a page write sequence to write a burst of 16 bytes data package. The microprocessor needs to wait around 5ms to complete data writing.
 

Byte and Page Write Sequences

 

The Read Status Register Instruction is optional you can read the device datasheet for more detail. 

PIC16F887 MPLABX IDE and XC8 Programming

I use a PIC16F887 micro-controller from Microchip Technology. It has the SPI module inside along with the I2C module. The XC8 C compiler is free to use without registering or buy a software license.

Screen Shot of This Example Program

In this example, the microprocessor write and read the EEPROM data from this SPI chip. It will show on a 20x2 character LCD and PORTB of PIC16F887 micro-controller.

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on February 13, 2024, 3:49 PM
 */
 
#include <xc.h>
#include "config.h"
#include "LCD4Bits.h"
#include "spi.h"
 
#define _XTAL_FREQ  8000000UL
 
void write_25AA010(uint8_t address, uint8_t data){
    /*Write Enable Command*/
    nCS=0;
    spi_send(0x06);
    nCS=1;
    /*Write Process*/
    nCS=0;
    spi_send(0x02);
    spi_send(address);
    spi_send(data);
    nCS=1;
    /*EEPROM Write Time*/
    __delay_ms(10);
}
 
void write_text(uint8_t start, uint8_t *txt){
    uint8_t addr=0;
    while(*txt){
        write_25AA010(start+addr,*txt++);
        addr++;
    }
}
 
uint8_t read_25AA010(uint8_t address){
    uint8_t data;
    nCS=0;
    spi_send(0x03);
    spi_send(address);
    data=spi_receive();
    nCS=1;
    return data;
}
 
void main(void) {
    OSCCONbits.IRCF=7;
    lcdInit();
    spi_init();
 
    uint8_t data;
    uint8_t txt[]="PIC16F887 24AA010A";
    write_text(0,txt);
    for(uint8_t i=0;i<sizeof(txt)-1;i++){
        data=read_25AA010(i);
        lcdData(data);
    }
 
    PORTB=0;
    TRISB=0;
    ANSELH=0;
    while(1){
        for(uint8_t i=0;i<8;i++){
            write_25AA010(20+i,1<<i);
            PORTB=read_25AA010(20+i);
            __delay_ms(100);
        }
        __delay_ms(1000);
        for(int8_t i=7;i>=0;i--){
            write_25AA010(40-i,1<<i);
            PORTB=read_25AA010(40-i);
            __delay_ms(100);
        }
        __delay_ms(1000);
    }
    return;
}
 

I wrote an SPI driver that it's putted in one package.

The SPI.h header file:

/* 
 * File:   spi.h
 * Author: Admin
 *
 * Created on February 9, 2024, 9:13 AM
 */
 
#include <xc.h>
 
#define nCS     RC2
 
void spi_init(void);
void spi_send(uint8_t data);
uint8_t spi_receive(void);
 
 

The SPI.c source file:

 
#include "spi.h"
 
void spi_init(void){
    /*SPI Mode Clock Low To High*/
    SSPCONbits.CKP=0;
    SSPSTATbits.CKE=1;
    SSPSTATbits.SMP=0;
    /*SPI Master Mode Clock = Fosc/4*/
    SSPCONbits.SSPM=2;
    /*Turn On The Module*/
    SSPCONbits.SSPEN=1;
    SSPSTATbits.BF=1;
    PORTC=0;
    TRISC=0;
    /*SPI SDI Pin Input*/
    TRISC4=1;
}
 
void spi_send(uint8_t data){
    SSPSTATbits.BF==1;
    SSPBUF=data;
    while(SSPSTATbits.BF==0);
    SSPSTATbits.BF==1;
}
 
uint8_t spi_receive(void){
    uint8_t data;
    spi_send(0x00);
    data=SSPBUF;
    return data;
}

If you wonder about using the SPI communication interface of PIC16F887 you can see this post.

See Also:

1. PIC16F887 Serial Peripheral Interface Example
2. PIC16F887 SPI and MCP23S17 XC8 Example 
3. PIC16F887 SPI MCP23S17 and Character LCD XC8 Example 
4. PIC16F887 SPI MCP23S17 Character LCD and KeyPad XC8 Example 
5. PIC16F887 SPI SN74HC165 LCD XC8 Example
   

Click here to download this example from GitHub.