EEPROM.h

Knižnica pre Arduino EEPROM.h sa využíva na čítanie a zápis dát do internej pamäte EEPROM. To je tá časť pamäte, ktorá si zachová uložené dáta aj po vypnutí napájania Arduina. Veľkosť tejto pamäte je daná mikrokontrolérom, napr. ATmega328 má 1024 bajtov, ATmega1280 a ATmega2560 má 4096 bajtov.

Obsah tejto pamäte môže modifikovať len bežiaci program v Arduine, nieje možné túto časť pamäte prepísať pri nahrávaní kódu do Arduina . Zápis do EEPROM trvá 3,3 ms a má stanovenú životnosť 100.000 cyklov pre zápis (mazanie), takže možno budete musieť dávať pozor na to, ako často budete do nej zapisovať. Číslovanie adresy pamäte začína ako obvykle od nuly.

EEPROM.write(adresa, hodnota)

Funkcia zapíše údaj do pamäte, kde:

• adresa – miesto v pamäti, kde sa hodnota zapíše (číslovanie je od nuly)
• hodnota – zapisovaný údaj v rozsahu 0 – 255 (1 bajt)

#include <EEPROM.h>

void setup() {
  for (int i = 0; i < 255; i++)
    EEPROM.write(i, i);   // zapíšeme na adresu "i" hodnotu "i"
}

void loop() {
}

EEPROM.read(adresa)

Funkcia načíta z adresy v pamäti hodnotu v rozsahu jedného bajtu (0 – 255). Pamäťové miesta, kde ešte neboli zapísané žiadne údaje, majú hodnotu 255.

#include <EEPROM.h>

int a = 0;
int value;

void setup() {
  Serial.begin(9600);
}

void loop() {
  value = EEPROM.read(a);   // z adresy "a" načíta hodnotu

  Serial.print(a);
  Serial.print("\t");
  Serial.print(value);
  Serial.println();

  a = a + 1;                // adresu "a" zvýšime o 1

  if (a == 512)             // adresu "a" zvyšujeme do 512, potom začíname od nuly
    a = 0;

  delay(500);
}

EEPROM.update(adresa, hodnota)

Funkcia zapíše údaj do pamäti iba vtedy, ak sa líši od tej, ktorá je už uložená na rovnakej adrese.

#include <EEPROM.h>

void setup() {
  for (int i = 0; i < 255; i++) {
    // zápis údajov je podobný ako EEPROM.write(i, i)
    EEPROM.update(i, i);
  }
  for (int i = 0; i < 255; i++) {
    EEPROM.update(3, 12);
    // zapíše hodnotu "12" na adresu 3 len prvý krát
    // a zvyšných 254 cyklov už nezapisuje nič, lebo hodnota "12" je na adrese 3 rovnaká
  }
}
void loop() {
}

EEPROM.put(adresa, data)

Funkcia zapisuje ľubovoľný dátový typ alebo objekt do pamäte EEPROM. Používa sa, keď potrebujeme zapísať viac ako jeden bajt, napr. hodnotu typu float alebo objekt struct. Táto funkcia využíva EEPROM.update()na vykonanie zápisu, takže neprepíše hodnotu v pamäti, pokiaľ sa nezmenila.

#include <EEPROM.h>

struct MyObject {
  float field1;
  byte field2;
  char name[10];
};

void setup() {
  Serial.begin(9600);  
  float f = 123.456f;        // premenná f typu float 
  int eeAddress = 0;         // počiatočná adresa v pamäti
  EEPROM.put(eeAddress, f);  // premennú float zapíšeme do pamäti 
  Serial.println("Zapísaná hodnota typu float");

  /** použitie objektu struct **/
  MyObject customVar = {     // dáta k uloženiu
    3.14f,                   
    65,
    "Hotovo!"
  };

  eeAddress += sizeof(float); // presunieme sa na adresu ďalšieho bajtu po float "f"
  EEPROM.put(eeAddress, customVar);
  Serial.print("Dáta typu struct zapísané!");  // v ďalšom príklade si tieto dáta načítame
}

void loop() {  
}

EEPROM.get(adresa, data)

Funkcia načíta ľubovoľný dátový typ alebo objekt z pamäte EEPROM. Teraz načítame údaje uložené predchádzajúcim príkladom.

#include <EEPROM.h>

struct MyObject{
  float field1;
  byte field2;
  char name[10];
};

void setup(){
  Serial.begin(9600);
  float f = 0.00f;       // premenná typu float
  int eeAddress = 0;     // počiatočná adresa v pamäti  
  Serial.print("Nacitana hodnota typu float z EEPROM: ");
  EEPROM.get(eeAddress, f );  // načítanie premennej typu float z EEPROM
  Serial.println( f, 3 );  

  /** použitie objektu struct **/
  eeAddress = sizeof(float);  // presunieme sa na adresu ďalšieho bajtu po float "f"
  MyObject customVar;         // premenná objektu struc
  EEPROM.get(eeAddress, customVar);  // načítanie dát z EEPROM do premennej
  Serial.println( "Dáta typu struct načítane z EEPROM: " );
  Serial.println( customVar.field1 );
  Serial.println( customVar.field2 );
  Serial.println( customVar.name );
}

void loop(){ 
}

EEPROM.length()

Táto funkcia nám vráti číslo unsigned int obsahujúce počet buniek v pamäti EEPROM. Ukážeme si ju na jednoduchom príklade vymazania celej pamäte EEPROM.

#include <EEPROM.h>

void setup() {
  
  /***
    Rôzne AVR procesory majú rôzne veľkú EEPROM:
    - Arduno Duemilanove: 512b EEPROM
    - Arduino Uno:        1kb EEPROM
    - Arduino Mega:       4kb EEPROM

    Namiesto pevného označovania veľkosti EEPROM pamäte 
    by ste mali používať preddefinovanú funkciu na zistenie jej veľkosti. 
    To umožní, aby bol váš kód prenosný pre všetky procesory AVR.
  ***/

  for (int i = 0 ; i < EEPROM.length() ; i++) {
    EEPROM.write(i, 0);
  }

}

void loop() {
  /** Prázdny loop. **/
}

EEPROM[adresa]

Tento operátor nám umožňuje používať identifikátor EEPROM ako pole. EEPROM bunky je možné čítať a písať priamo pomocou tejto metódy. Tento operátor vráti odkaz na bunku EEPROM.

unsigned char val;

//načítaj prvú EEPROM bunku
val = EEPROM[ 0 ];

//zapíš do prvej EEPROM bunky
EEPROM[ 0 ] = val;

//porovnaj obsah
if( val == EEPROM[ 0 ] ){
  //kód programu po splnení podmienky...
}

Tento text je preložený a upravený zo stránok arduino.cc pod licenciou Creative Commons Attribution-ShareAlike 3.0.