Arduino Dahili ve Harici EEPROM Veri İşlemleri

Bilgisayarlar ve mikroişlemciler, verileri kalıcı veya geçici olarak depolamak için belleğe ihtiyaç duyar ve bu bellek çeşitli biçimlerde gelebilirken, iki temel türe ayrılabilir – geçici ve kalıcı olmayan.

Geçici bellek genellikle RAM yani Rasgele Erişimli Bellek biçimindedir. Bu, cihazınızın “çalışan” hafızasıdır, program çalışması sırasında kullanılan geçici verileri tutar. Güç kesildiğinde hafıza silinir.

Kalıcı bellek, tahmin edebileceğiniz gibi, verileri güç kesildikten sonra bile tutar. Çeşitli geçici olmayan bellek türleri vardır ve bugün bunlardan EEPROM’u inceleyeceğiz:

 Elektrikle Silinebilir Programlanabilir Salt Okunur Bellek veya EEPROM.

Geçici Olmayan Bellek Türleri

Bir EEPROM, bit başına iki transistör içeren bir dizi kayan kapı transistörü kullanılarak oluşturulur. ROM veya Salt Okunur Bellek aygıt ailesinin bir parçasıdır. EEPROM’lar Flash Belleğe benzer, aralarındaki fark Flash Belleğin daha büyük olması ve daha büyük veri blokları kullanmasıdır. Bu sayı, yeniden yazma veya “yazma döngüleri” pahasına olur, Flash Bellek yalnızca yaklaşık 10.000 kez yeniden yazılabilir. Arduino mikrodenetleyicileri, kendisine yüklenen programları (eskizleri) depolamak için Flash Belleği kullanır. Arduino da birazdan göreceğimiz gibi dahili bir EEPROM’a sahiptir.

EEPROM Nedir?

Flash bellekler, SD Kartlar, USB sürücüler, sabit disk sürücüleri ve SSD’ler dahil olmak üzere birçok başka kalıcı bellek türü vardır. Peki, EEPROM’un bu aygıtlardan farkı nedir? Yukarıda belirtilen bellek türleri ile karşılaştırıldığında, bir EEPROM’un çok az miktarda depolama alanı vardır, aslında, EEPROM kapasiteleri bayt yerine genellikle Bit cinsinden ölçülür. Yalnızca az miktarda veri depoladıkları için çok fazla akım tüketmezler, bu da onları pil ile beslemede ve düşük güçlü uygulamalar için ideal kılar. EEPROM’lar 1970’lerin başında geliştirildi ve ilk EEPROM, 1975’te NEC tarafından patentlendi.

EEPROM Sınırları

Flash Bellekte olduğu gibi, EEPROM’ların sınırlı sayıda yazma döngüsü vardır. EEPROM’dan istediğiniz kadar okuyabilirsiniz, ancak verileri yalnızca belirli sayıda yazabilir veya yeniden yazabilirsiniz. Yaygın EEPROM’lar için yazma döngüleri sınırı yaklaşık 100.000 ila 2 milyon yazma döngüsüdür. Birkaç yüz bin hatta birkaç milyon yazma döngüsü kulağa çok gelebilir, ancak modern bir mikro denetleyicinin veya mikroişlemcinin ne kadar hızlı veri yazabileceğini bir düşünün ve yakında bunun ciddi bir sınırlama haline gelebileceğini anlayacaksınız. EEPROM’a her saniye yeniden yazacak olsaydınız ve 100.000 yazma yazma döngüsü kapasitesine sahip olsaydınız, bu kapasiteyi bir günden biraz fazla bir sürede aşmış olurdunuz.

EEPROM’ları kullanarak tasarım yaparken, cihaza mümkün olduğunca az yazmak isteyeceksiniz. Bir süre sonra inceleyeceğimiz bir diğer teknik, biti yazılmadan önce okumaktır, zaten doğru değer ise yeniden yazmanın pekte anlamı yoktur.

Diğer bir EEPROM sınırlaması, veri saklama süresidir. EEPROM teknolojisi günümüzde sürekli olarak gelişirken, EEPROM’lar bozulmadan önce verileri oda sıcaklığında yaklaşık 10 yıl saklayabilir. Bu verilerin yeniden yazılması, sayacı yeniden başlatacak ve EEPROM’un ömrünü uzatacaktır.

Ve son olarak, diğer bellek cihazlarıyla karşılaştırıldığında oldukça küçük olan EEPROM depolama kapasitesidir. Ancak, EEPROM’ların en yaygın kullanımı konfigürasyon ve kalibrasyon verilerini tutmak olduğu için bu çokta önemli bir sorun değildir.

EEPROM’un Ömrünü Uzatmak?

• Sürekli aynı adrese veri yazmak, kullanım ömrünü oldukça azaltacaktır. Döngü ömrünü tamamlamamış bir EEPROM çalışmıyorsa en büyük sebebi bu olabilir. Veri girişi olduktan sonra, sonraki veri grubunu, adresi kaydırarak girmelisiniz.

• Ayrıca EEPROM’a gereksiz ve sürekli veri girilip girilmediğinden emin olmalısınız, “update” fonksiyonunu bu yüzden kullanmalısınız, ayrıca program kodunu hazırlarken, EEPROM’a for döngüsü içerisinden veri yazmamaya çalışın, her hangi bir yanlışlık, hata, bug, EEPROM’un tamamen bozulmasına neden olabilir. EEPROM’lara veri yazmak yaklaşık 3ms sürmekte bu yüzden siz kod bloğunu durdurana kadar, çoktan bir EEPROM’u kaybetmiş olabilirsiniz.

Not

EEPROM’dan veri okumak hafızayı ya da kullanım ömrünü azaltmaz. Bir EEPROM adresini istediğiniz kadar okuyabilirsiniz.

Diğer ROM Çeşitleri

ROM

Read-Only Memory: Salt Okunur Bellek. Bu çipler üretim sırasında programlanır ve değiştirilemez.

PROM

Programmable Read-Only Memory:  Programlanabilir Salt Okunur Bellek. Bu çipler özel bir cihaz kullanılarak programlanabilir ancak silinemez ve yeniden programlanamazlar.

EPROM

Erasable Programmable Read-Only Memory: Silinebilir Programlanabilir Salt Okunur Bellek. PROM gibi, EPROM da özel bir programlama cihazı gerektirir. Bu tür bir bellek yongası ultraviyole ışık kullanılarak silinebilir ve ardından yeniden kullanılabilir.

Bilgi

Harici programlama veya yazma cihazı gerektirmeden kullanılabildiği için, EEPROM oldukça yaygın bir şekilde kullanıkmakta.

Arduino UNO: Flash ve ROM Kıyası

Flash Ömrü

Arduino UNO kartınıza günde 10 kere program yazarsanız, yaklaşık 2.7 sene içinde, flash yani PROGMEM ömrünü doldurmuş olursunuz.

10.000/10 = 1000 Gün = 2.7 sene.

EEPROM Ömrü

Eğer günde 10 kere EEPROM’a veri yazarsanız, yaklaşık 27 sene içinde EEPROM yazdırma döngüsünü tamamlamış olursunuz. Bu yüzden verileri EEPROM üzerinde saklamak her zaman daha mantıklı olacaktır.

Dahili EEPROM Kullanımı

Arduino projelerimize oldukça kolay bir şekilde EEPROM veri işlemerini ekleyebiliriz. Aslında, Arduino zaten programlarımızda bazı dahili işlemleri direk EEPROM’a yazabilme yetisini sahiptir. Ayrıca bellek miktarı, kullandığımız Arduino modeline göre değişmektedir.

Aşağıdaki tablo, bazı popüler Arduino modellerinde dahili EEPROM hafızasını görebilirsiniz:

Arduino’daki dahili EEPROM’u kullanarak EEPROM deneylerimize başlayacağız. Deneyimiz için biz Arduino Uno kullanıyoruz, ancak isterseniz farklı bir Arduino kullanabilirsiniz.

Dahili EEPROM’u nasıl kullandığımızı anlamak için Arduino’muza bir potansiyometre ekleyerek onu analog giriş portlarından birine bağlayacağız.

Dahili EEPROM Devre Şeması

Bağlantıları tamamladıktan sonra, Arduino’yu bilgisayara bağlayıp, Arduino IDE’yi çalıştırabilirsiniz.

Arduino EEPROM Library

EEPROM işlemlerini, Arduino IDE’ye zaten dahil olan Arduino EEPROM kitaplığını kullanarak yapıyoruz. Kütüphane, birkaç kısa örnekle birlikte geliyor. Bunları Arduino’nun dahili EEPROM’unu denemek için kullanacağız. Kütüphanenin yalnızca dahili EEPROM ile çalıştığını, harici bir cihazı kullanmak için farklı bir kütüphane/I2C&Wire gerektireceğini unutmayın.

EEPROM Update Fonksiyonu – Kontrollü Yazma

Kütüphanede doğrudan “write” yazma fonksiyonu olmasına rağmen, update yöntemi ile bu işlemi gerçekleştirmek, EEPROM açısından oldukça sağlıklı olacaktır. Bu sayede eğer veri de bir değişiklik varsa yazma işlemi başlayacak, yoksa her hangi bir yazma işlemi olmayacaktır. Bu işlem ile yazma döngüsünün azalmasının önüne geçmiş oluyoruz. Bu tekniğe yabancı kaynaklarda “wear levelling” olarak karşılaşabilirsiniz, Türkçe çevirisi için “aşınma dengeleme” gibi bir tabir kullanabiliriz.

/***
   EEPROM Update Fonksiyonu
   Stores values read from analog input 0 into the EEPROM.
   These values will stay in the EEPROM when the board is
   turned off and may be retrieved later by another sketch.
   If a value has not changed in the EEPROM, it is not overwritten
   which would reduce the life span of the EEPROM unnecessarily.
   Released using MIT licence.
 ***/
#include <EEPROM.h>
/** the current address in the EEPROM (i.e. which byte we're going to write to next) **/
int address = 0;
void setup() {
  /** Eppty setup **/
}
void loop() {
  /***
    need to divide by 4 because analog inputs range from
    0 to 1023 and each byte of the EEPROM can only hold a
    value from 0 to 255.
  ***/
  int val = analogRead(0) / 4;
  /***
    Update the particular EEPROM cell.
    these values will remain there when the board is
    turned off.
  ***/
  EEPROM.update(address, val);
  /***
    The function EEPROM.update(address, val) is equivalent to the following:
    if( EEPROM.read(address) != val ){
      EEPROM.write(address, val);
    }
  ***/
  /***
    Advance to the next address, when at the end restart at the beginning.
    Larger AVR processors have larger EEPROM sizes, E.g:
    - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno:        1kb EEPROM storage.
    - Arduino Mega:       4kb EEPROM storage.
    Rather than hard-coding the length, you should use the pre-provided length function.
    This will make your code portable to all AVR processors.
  ***/
  address = address + 1;
  if (address == EEPROM.length()) {
    address = 0;
  }
  /***
    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
    EEPROM address is also doable by a bitwise and of the length - 1.
    ++address &= EEPROM.length() - 1;
  ***/
  delay(100);
}

Bu taslak, potansiyometremizi bağladığımız analog pin A0’dan değer okumak için yazıldı. Girişi(0-1024) alır ve dörde böler, böylece tek bir bayt ile temsil edilebilen 0 – 255 aralığında bir değer olur.

Bu değer daha sonra ilk EEPROM adresine yazılır, ancak yalnızca veriler mevcut verilerden farklıysa yazılır (update methodu). Açıkçası, programı ilk çalıştırdığınızda her zaman bir yazma işlemi gerçekleştirecektir, ancak sonraki çalıştırmalar sırasında, yalnızca değer mevcut olandan farklıysa yazacaktır.

Artık elimizde bazı veriler olduğuna göre şimdi yazdığımız verileri okuyalım.

EEPROM Read Fonksiyonu – Okuma

/*
 * EEPROM Read
 *
 * Reads the value of each byte of the EEPROM and prints it
 * to the computer.
 * This example code is in the public domain.
 */
#include <EEPROM.h>
// start reading from the first byte (address 0) of the EEPROM
int address = 0;
byte value;
void setup() {
  // initialize serial and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
}
void loop() {
  // read a byte from the current address of the EEPROM
  value = EEPROM.read(address);
  Serial.print(address);
  Serial.print("t"); 
  Serial.print(value, DEC);
  Serial.println();
  /***
    Advance to the next address, when at the end restart at the beginning.
    Larger AVR processors have larger EEPROM sizes, E.g:
    - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno:        1kb EEPROM storage.
    - Arduino Mega:       4kb EEPROM storage.
    Rather than hard-coding the length, you should use the pre-provided length function.
    This will make your code portable to all AVR processors.
  ***/
  address = address + 1;
  if (address == EEPROM.length()) {
    address = 0;
  }
  /***
    As the EEPROM sizes are powers of two, wrapping (preventing overflow) of an
    EEPROM address is also doable by a bitwise and of the length - 1.
    ++address &= EEPROM.length() - 1;
  ***/
  delay(500);
}

Bu taslak ise basitçe EEPROM’u okur ve verileri seri monitöre yazdırır. Dolayısıyla, bir önceki taslaktan sonra çalıştıracaksanız, potansiyometre ile oynamalar yaptıktan sonra, EEPROM’a veri yazılacaktır çünkü update metodu ile yazdırma işlemi yaptırmıştık.

EEPROM Clear Fonksiyonu – Temizleme

Temizleme fonksiyonu EEPROM’da ki tüm verileri 0 yapar:

/*
 * EEPROM Clear
 *
 * Sets all of the bytes of the EEPROM to 0.
 * Please see eeprom_iteration for a more in depth
 * look at how to traverse the EEPROM.
 *
 * This example code is in the public domain.
 */
#include <EEPROM.h>
void setup() {
  // initialize the LED pin as an output.
  pinMode(13, OUTPUT);
  /***
    Iterate through each byte of the EEPROM storage.
    Larger AVR processors have larger EEPROM sizes, E.g:
    - Arduno Duemilanove: 512b EEPROM storage.
    - Arduino Uno:        1kb EEPROM storage.
    - Arduino Mega:       4kb EEPROM storage.
    Rather than hard-coding the length, you should use the pre-provided length function.
    This will make your code portable to all AVR processors.
  ***/
  for (int i = 0 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }
  // turn the LED on when we're done
  digitalWrite(13, HIGH);
}
void loop() {
  /** Empty loop. **/
}

Bu taslak, EEPROM’un bütün adreslerini tek tek gezip “0” yapan bir koddur. Bu kodu çalıştırdıktan sonra, bir üstteki read fonksiyonu ile adresleri kontrol edin hepsini “0” olarak göreceksiniz.

Sıfırlama işlemine gerçekten ihtiyacınız yoksa ya da sadece belirli bir yeri temizleyeceksiniz, bu kodu kullanmamak daha sağlıklı olacaktır. Sonuçta temizleme işlemide aslında yazma işlemidir sadece bütün girdiler “0” olarak geçer.

Harici EEPROM

Arduino’daki dahili EEPROM oluşturduğunuz uygulamanız için yetersizse, harici bir EEPROM ekleyebilirsiniz. Bir I2C destekleyen EEPROM kullanmak hem kablolamayı hem de kodu basitleştirir. Daha önce ki seri haberleşme protokolleri ve I2C örneklerimizi(I2C OLED) inceleyerek, nasıl çalıştığını daha iyi anlayabilirsiniz.

24LC256 EEPROM

24LC256, (32Kx8) 256Kbit bir EEPROM’dur. Bir baytta sekiz bit olduğu için bu 32 Kb’lık bir belleğe dönüşür. I2C desteği sayesinde, 8 taneye kadar bir birine paralel bağlantı yapabilirsiniz. Ayrıca 3 pini I2C adresini ayarlamak için kullanılıyor. Bunun yanında 1 milyon gibi yazma döngüsüne sahip, fiyatının da uygun olmasıyla birlikte oldukça sık kullanılan EEPROM’lardan biridir.

• A0-A2 (pin 1,2,) – I2C adresini seçmek için kullanılır.
• WP (pin 7) – EEPROM’a yazma engeli(write protection) koymak için bu pini HIGH yapmak gerekiyor.
• SDA (pin 5) – I2C için Serial Data.
• SCL (pin 6) – I2C için Serial Clock.

Hazır 24LC256 Modülleri

Eğer sadece prototiple yapmak istiyorsanız bu modülü kullanabilirsiniz, ama bir devre tasarlamak ya da breadboard üzerinde kullanmak istiyorsanız, DIP model halini almak sizin için daha iyi olacaktır.

24LC256 İçin Devre Şeması

Bu devrede, 24LC256 EEPROM’unu 10k bir potansiyometre ve SG90 servo ile kullanıyoruz. 10k potansiyometreniz yoksa herhangi bir 5k>x potansiyometre işinizi görecektir. Bunun dışında EEPROM’a veri kaydetmek için başka bir giriş hatta doğrudan Arduino üzerinden bir veri kaydedebilirsiniz.

Arduino’nun güç hattını parazitlendirmemesi için, servo motoru harici bir 5V kaynak ile besliyoruz. Ayrıca kullanılan güç kaynağının GND’si ile Arduino’nun GND’sini birleştirmeyi unutmayın. Harici bir güç kaynağı kullanmak istemiyorsanız doğrudan Arduinonun güç hattına bağlayabilirsiniz, parazitlenmenin önüne geçmek için, servo motorun GND ve VCC bacağına paralel bir kapasitör yerleştirmeniz işinizi görecektir. Ayrıca EEPROM’un yazma korumasını tam anlamıyla kapatmak için, PW pinini GND’ye bağlamalısınız.

Detay

I2C scanner ile EEPROM’un adresini göremiyorsanız, I2C pinlerine 4.7k ve 10k arasında bir pull-up direnci bağlayarak bu sorunun önüne geçebilirsiniz.

Harici EEPROM Arduino Kodu

Örnek kodumuz EEPROM’a servo hareketlerini kaydedecek. Bunu yaklaşık bir dakika yapacak ve sonra sona erecek (dilerseniz uzatabilirsiniz). Bundan sonra, beş saniye bekleyecek ve ardından EEPROM’a kaydedilmiş hareketleri oynatacaktır. Seri monitör hem kayıt işlemini hem de servo motor hareketlerini gösterecektir.

// Include the I2C Wire Library
#include "Wire.h"
// Include the Servo Library
#include "Servo.h"
// EEPROM I2C Address
#define EEPROM_I2C_ADDRESS 0x50
// Analog pin for potentiometer
int analogPin = 0;
// Integer to hold potentiometer value
int val = 0;
// Byte to hold data read from EEPROM
int readVal = 0;
// Integer to hold number of addresses to fill
int maxaddress = 1500;
// Create a Servo object
Servo myservo;
// Function to write to EEPROOM
void writeEEPROM(int address, byte val, int i2c_address)
{
  // Begin transmission to I2C EEPROM
  Wire.beginTransmission(i2c_address);
  // Send memory address as two 8-bit bytes
  Wire.write((int)(address >> 8));   // MSB
  Wire.write((int)(address & 0xFF)); // LSB
  // Send data to be stored
  Wire.write(val);
  // End the transmission
  Wire.endTransmission();
  // Add 5ms delay for EEPROM
  delay(5);
}
// Function to read from EEPROM
byte readEEPROM(int address, int i2c_address)
{
  // Define byte for received data
  byte rcvData = 0xFF;
  // Begin transmission to I2C EEPROM
  Wire.beginTransmission(i2c_address);
  // Send memory address as two 8-bit bytes
  Wire.write((int)(address >> 8));   // MSB
  Wire.write((int)(address & 0xFF)); // LSB
  // End the transmission
  Wire.endTransmission();
  // Request one byte of data at current memory address
  Wire.requestFrom(i2c_address, 1);
  // Read the data and assign to variable
  rcvData =  Wire.read();
  // Return the data as function output
  return rcvData;
}
void setup()
{
  // Connect to I2C bus as master
  Wire.begin();
  // Setup Serial Monitor
  Serial.begin(9600);
  // Attach servo on pin 9 to the servo object
  myservo.attach(9);
  // Print to Serial Monitor
  Serial.println("Start Recording...");
  // Run until maximum address is reached
  for (int address = 0; address <= maxaddress; address++) {
    // Read pot and map to range of 0-180 for servo
    val = map(analogRead(analogPin), 0, 1023, 0, 180);
    // Write to the servo
    // Delay to allow servo to settle in position
    myservo.write(val);
    delay(15);
    // Record the position in the external EEPROM
    writeEEPROM(address, val, EEPROM_I2C_ADDRESS);
    // Print to Serial Monitor
    Serial.print("ADDR = ");
    Serial.print(address);
    Serial.print("t");
    Serial.println(val);
  }
  // Print to Serial Monitor
  Serial.println("Recording Finished!");
  // Delay 5 Seconds
  delay(5000);
  // Print to Serial Monitor
  Serial.println("Begin Playback...");
  // Run until maximum address is reached
  for (int address = 0; address <= maxaddress; address++) {
    // Read value from EEPROM
    readVal = readEEPROM(address, EEPROM_I2C_ADDRESS);
    // Write to the servo
    // Delay to allow servo to settle in position
    // Convert value to integer for servo
    myservo.write(readVal);
    delay(15);
    // Print to Serial Monitor
    Serial.print("ADDR = ");
    Serial.print(address);
    Serial.print("t");
    Serial.println(readVal);
  }
  // Print to Serial Monitor
  Serial.println("Playback Finished!");
}
void loop()
{
  // Nothing in loop
}

Dahili EEPROM’un aksine, 24LC256 EEPROM’u ile çalışmak için özel bir kütüphane kullanmayacağız. Bununla birlikte, I2C için Arduino Wire kütüphanesini ve Servo Kütüphanesini kullanacağız. Bu kitaplıkların her ikisi de Arduino IDE’nize zaten dahil olarak gelmekte.

Gerekli kütüphaneleri ekledikten sonra birkaç sabit ve değişken oluşturduki şimdi bunların ne olduğunu inceleyelim:

• EEPROM_I2C_ADDRESS: EEPROM I2C adresini temsil eden kısım, bizim EEPROM’umuz 50hex olarak ayarlandı.
• analogPin: Potansiyometrenin bağlı olduğunu analog pin
• val: Kayıt sırasında servo motora gönderilen değeri temsil etmek için kullanılan değişken.
• readVal: Kayıttan oynatma sırasında servo motora gönderilen değeri temsil etmek için kullanılan tam sayı.
• maxaddress: Kullanmak istediğimiz en yüksek adres konumu. Dilerseniz bunu artırabilirsiniz, demoyu çalıştırmak için geçen süreyi en aza indirmek için 1500 kullandık.

Daha sonra motoru temsil etmek için myservo adında bir servo nesnesi oluşturuyoruz.
Daha sonra, sırasıyla EEPROM yazma ve okumamızı gerçekleştiren writeEEPROM ve readEEPROM olmak üzere iki işlev tanımlıyoruz.
WriteEEPROM işlevi bellek adresini, bu adrese yazmak istediğiniz verileri ve EEPROM I2C adresini girdi olarak alır. Daha sonra EEPROM’a bağlanır ve bellek adresini iki bağımsız bayt olarak geçirir. Bunun nedeni, I2C veri yolunun bir seferde yalnızca bir adres baytı aktarmanıza izin vermesidir.
Ardından, kaydetmek istediğimiz değeri I2C veriyoluna yerleştiriyoruz. Ondan sonra iletimi sonlandırıyoruz.
EEPROM, yazma işlemleri arasında bunu gerektirdiğinden, yazdıktan sonra 5 ms’lik bir gecikme de ekledik. Bu EEPROM’un yazma süresi maksimum 5ms sürüyor.
ReadEEPROM işlevi bellek adresini ve I2C adresini giriş olarak alır. Daha sonra I2C veriyoluna bağlanır, adres bilgilerini iletir ve iletimi sonlandırır. Bu, EEPROM’un veriyi belirtilen adresteki çıktı tamponuna ana bilgisayar tarafından okunmaya hazır bir şekilde yerleştirmesine neden olur. Bu değeri okuruz ve ardından işlevi sonlandırmak için çıkarırız.
Seri monitöre yazdırdıktan sonra, tüm adresler arasında geçiş yaparak bir sonraki döngüye giriyoruz. Her adreste, potansiyometrenin bağlı olduğu analog porttan değeri yakalayıp servo motorumuz için 0-180 arası bir değere dönüştürüyoruz.

Harici EEPROM’un Çalıştırılması

Kod taslağını Arduino’nuya yükleyin ve potansiyometreyi çevirmeye başlayın. Seri monitörde görüntülenen verilerin yanı sıra servo hareketi buna istinaden başlayacaktır. Yaklaşık bir dakika sonra kayıt sona erecektir. 5 saniyelik bir gecikmenin ardından, motor EEPROM’a kaydettiğiniz veriyi okuyarak aynı düzende kendi kendine hareket etmeye başlayacaktır.

Kurduğumuz devre ve kod doğru çalıştıktan sonra, Arduino’nun gücünü kesip, EEPROM’un kalıcı bir şekilde verileri nasıl sakladığını gözlemleyin, işte aslında yapmak istediğimiz şeyi yapmış olduk.

EKSTRALAR

EEPROM’un Resetlenmesi/Sıfırlanması

Bu EEPROM’ entegresinde haricen bir sıfırlama ya da resetleme fonksiyonu bulunmamakta. Yukarıda belirttiğimiz gibi bütün baytlara 0 yazdırarak sıfırlayabilirsiniz. Basit bir loop döngüsü oluşturarak 0’dan 999’a kadar olan bütün adreslere 0xFF yani 0 yazabilirsiniz.

Arduino EEPROM vs Progmem

EEPROM ve Progmem(Flash) belleğin ömürlerini ve kapasitelerini yazının üst kısmında belirtmiştik. EEPROM’a kalıcı/kaybolmaması gereken verileri yazmak her zaman daha sağlıklı olacaktır.

Arduino EEPROM vs SD card.

EEPROM’un avantajı hızlı olmasıdır. Fakat dezavantajı, depolama kapasitesinin küçük olmasıdır (1k Bayt)

SD kartın avantajı depolama kapasitesinin çok büyük olmasıdır (Gigabyte). Fakat dezavantajı, yavaş olmasıdır.

SD kart’ın bir diğer dezavantajı, bir RAM tamponuna ihtiyaç duymasıdır (muhtemelen her biri yaklaşık 512 bayt SRAM’den 2 tane). SD kartın yazılması zaman alır – bu nedenle çift ara belleğe ihtiyaç duyulur. EEPROM yazılırken ise sadece bir arabellek güncellenir.

EEPROM Fonksiyon Kıyaslaması

EEPROM put vs update

update() tek byte için geçerlidir
Byte okur ve aynıysa bir işlem yapmaz, farklıysa değiştirir.

put() birden fazla byte adresinden başlayarak doğrudan değişiklik yapar.

EEPROM update vs write

update() tek byte için geçerlidir

Byte okur ve aynıysa bir işlem yapmaz, farklıysa değiştirir.

write() tek byte üzerinde işlem yapar ve yazar.

EEPROM write vs put

write() tek byte üzerinde işlem yapar ve yazar.

put() birden fazla byte adresinden başlayarak doğrudan değişiklik yapar.

EEPROM get vs read

read() tek byte üzerinde işlem yapar.
adresteki tek byte okur.

get() bir adresten başlayarak tüm byteları okur.