EEPROM, adalah jenis memori non-volatile yang mempertahankan isinya bahkan setelah daya dimatikan. Ada dua jenis EEPROM berdasarkan lokasinya. Pertama adalah EEPROM Internal, yang tertanam di dalam Mikrokontroler dan EEPROM Eksternal, yang berupa IC dan harus terhubung ke Mikrokontroler melalui Serial Interface (seperti I2C atau SPI).
Jika kita berbicara tentang IC Serial EEPROM, maka seri Atmel (sekarang Microchip) AT24 dan AT25 sangat populer. Seri AT24 adalah EEPROM I2C sedangkan Seri AT25 adalah IC EEPROM SPI. Memori di dalam IC AT24C256 disusun menjadi beberapa blok/halaman (page) setiap page terdiri dari 64-byte. Untuk pengalamatannya membutuhkan 15-bit alamat data word.
Untuk proyek ini, kita gunakan IC AT24C256, yang merupakan EEPROM 256 kbit. Ini berarti 262.144 bit atau 32.768 Bytes (32 kB). AT24C256 adalah IC 8-pin yang tersedia dalam bentuk SOIC 8-lead, TSSOP 8-lead, 8-pad UDFN atau 8-bola VFBGA. SOIC 8-lead populer di modul mikrokontroler.
Pengiriman Data AT24C256
Dalam penulisan data memungkinkan untuk menulis beberapa byte data sekaligus. Berikut ini adalah untuk Page Write:
Setiap data I2C dimulai/dibuka dengan tiga byte data: Alamat perangkat, Alamat data word pertama, dan Alamat data word kedua. Pembukaan ini kemudian diikuti dengan data sebenarnya yang ingin Anda tulis.
Penulisan Alamat ATC24C256 (contoh: Alamat Pembuka)
Berfokus pada bagian diagram ini (yang diberi kotak merah), kita melihat bahwa alamat perangkat 7 bit dimulai dengan ‘1’, diikuti oleh ‘0’, ‘1’, dan seterusnya sehingga didapatkan 0b1010000. Dua bit terakhir Least Significant Bits (LSB) adalah ‘0’ tetapi sebenarnya dapat diubah untuk memungkinkan menggunakan hingga empat EEPROM dengan komunikasi I2C.
Bit ke-8 digunakan untuk mengatur perangkat EEPROM (mode Read atau Write),untuk Arduino dapat menggunakan library Wire untuk mengakses alamat 7-bit. Jika Anda diberi alamat 8-bit seperti pada Gambar, maka harus digeser satu bit ke kanan untuk mendapatkan alamat 7-bit.
Alamat Pertama & Kedua SPI ATC24C256
Asumsikan kita menggunakan IC EEPROM yang kosong. Jadi kita mulai dari pengalamatan data word pertama dan sebaiknya dilanjutkan dengan pengalamatan data word kedua (sebagai 1 alamat --> 16 bit).
Karena menggunakan EEPROM 256K, MSB untuk alamat dimulai pada tanda + (sebenarnya memiliki alamat 15-bit) dengan 7-bit alamat data word pertama dan 8 bit untuk alamat data word kedua. Oleh karena itu alamat 15-bit ini menjadi: 0b0000000000000000 (jumlah ‘0’-nya = 15).
Penulisan Data ATC24C256
Untuk penulisan data dapat dilakukan dengan mengirimkan data yang akan ditulis. Kelebihan menggunakan Page Write adalah anda dapat menulis lebih dari satu byte dalam satu waktu. Dengan Page Write, setelah mengirim data pembukaan, Anda dapat mengirim seluruh data array yang akan ditulis sekaligus.
Pembacaan Data ATC24C256
Pembacaan data di dalam EEPROM memiliki proses yang sama dengan penulisannya kecuali pada bit R/W yang sekarang diset ‘1’ (Mode Read).
Penulisan SPI ATC24C256 + Arduino
Berikut ini Fungsi Page Write hard-coded:
Contoh Rangkaian EEPROM Eksternal ATC24C256 Arduino:
Percobaan 64: Akses EEPROM Eksternal AT24C256
- Hubungkan SDA dengan pin D20 ATMEGA 2560
- Hubungkan SCL dengan pin D21 ATMEGA 2560
- Hubungkan board ATMEGA 2560 dengan Komputer menggunakan kabel USB.
- Bukalah IDE Arduino, kemudian ketikkan kode program/sketch atau buka file EEPROM_AT24C256 (untuk menulis dan membaca tiap Byte) atau EEPROM_AT24C256_v2 (untuk menulis dan membaca tiap Page)
- Compile menggunakan verify button (tanda ceklist pada IDE arduino) untuk mengecek ada atau tidaknya error/kesalahan dalam pengetikan.
- Upload program ke arduino dengan cara, pilih File > Upload to I/O board, atau tekan tombol tanda panah pada jendela IDE arduino.
Code EEPROM_AT24C256 (untuk menulis dan membaca tiap Byte):
#include <Wire.h>
#define M1 0x50 // Device Address
void setup() {
Serial.begin(9600);
Wire.begin();
unsigned int address = 1;
for (int i = 1; i <= 100; i++ )
writeEEPROM(M1, i, i);
for (int i = 1; i <= 100; i++ )
readEEPROM(M1, i);
}
void loop()
{}
void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) {
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); //LSB
Wire.write(data);
Wire.endTransmission();
//Serial.println(Wire.endTransmission());
delay(20);
}
void readEEPROM(int deviceaddress, unsigned int eeaddress ) {
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // MSB
Wire.write((int)(eeaddress & 0xFF)); // LSB
Wire.endTransmission();
//Serial.println(Wire.endTransmission());
delay(5);
Wire.requestFrom(deviceaddress, 1);
if (Wire.available() > 0) {
Serial.println(Wire.read(), HEX);
} else {
Serial.println("NO DATA!");
}
}
.
Code EEPROM_AT24C256_v2 (untuk menulis dan membaca tiap Page):
#include <Wire.h>
#define EEPROM_ADDR 0x50 // I2C Buss address of 24LC256 256K EEPROM
void setup()
{
Wire.begin(); // join I2C bus (address optional for master)
Serial.begin(9600);
// TESTS FOR EACH FUNCTION BEGIN HERE
Serial.println("Writing Test:");
for (int i=0; i<20; i++){ // loop for first 20 slots
i2c_eeprom_write_byte(EEPROM_ADDR,i,i+65); // write address + 65 A or 97 a
Serial.print(". ");
delay(10); // NEED THIS DELAY!
}
Serial.println("");
delay(500);
Serial.println("Reading Test:");
for (int i=0; i<20; i++){ // loop for first 20 slots
Serial.write(i2c_eeprom_read_byte(EEPROM_ADDR, i));
Serial.print(" ");
}
// setup for page tests . . .
byte PageData[30]; // array that will hold test data for a page
byte PageRead[30]; // array that will hold result of data for a page
for (int i=0; i<30; i++){ // zero both arrays for next test
PageData[i] = 0;
PageRead[i] = 0;
}
Serial.println("");
for (int i=0; i<30; i++) PageData[i] = i+33; // fill up array for next test char 33 = !
Serial.println("Writing Page Test:");
i2c_eeprom_write_page(EEPROM_ADDR, 100, PageData, 28 ); // 28 bytes/page is max
Serial.println("Reading Page Test:");
i2c_eeprom_read_buffer( EEPROM_ADDR, 100, PageRead, 28);
for (int i=0; i<28; i++){
Serial.write(PageRead[i]); // display the array read
Serial.print(" ");
}
}
void loop()
{
}
void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data )
{
int rdata = data;
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // Address High Byte
Wire.write((int)(eeaddress & 0xFF)); // Address Low Byte
Wire.write(rdata);
Wire.endTransmission();
}
// Address is a page address, 6-bit (63). More and end will wrap around
// But data can be maximum of 28 bytes, because the Wire library has a buffer of 32 bytes
void i2c_eeprom_write_page
( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length )
{
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddresspage >> 8)); // Address High Byte
Wire.write((int)(eeaddresspage & 0xFF)); // Address Low Byte
byte c;
for ( c = 0; c < length; c++)
Wire.write(data[c]);
Wire.endTransmission();
delay(10); // need some delay
}
byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress )
{
byte rdata = 0xFF;
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // Address High Byte
Wire.write((int)(eeaddress & 0xFF)); // Address Low Byte
Wire.endTransmission();
Wire.requestFrom(deviceaddress,1);
if (Wire.available()) rdata = Wire.read();
return rdata;
}
// should not read more than 28 bytes at a time!
void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length )
{
Wire.beginTransmission(deviceaddress);
Wire.write((int)(eeaddress >> 8)); // Address High Byte
Wire.write((int)(eeaddress & 0xFF)); // Address Low Byte
Wire.endTransmission();
Wire.requestFrom(deviceaddress,length);
//int c = 0;
for ( int c = 0; c < length; c++ )
if (Wire.available()) buffer[c] = Wire.read();
}