Adatbázis kezelés EEPROM-ban

Tartalom:

  • Szövegek tárolása az Arduino belső EEPROM-jában, annak érdekében, hogy több hely maradjon a flash memóriában illetve a ram-ban a programnak, vagy időnként megváltoztatható szavakat tároljon a program
  • Változó rekordhosszúság, 1-255 karakter hosszú szavak kényelmes tárolására
  • Kijelölhető EEPROM terület a szavaknak, hogy maradjon más adatnak is hely
  • Alapvető adatbáziskezelő függvények, írás, megadott sorszámú szó olvasása, adott sorszámú szó törlése, rendelkezésre álló hely lekérdezése
  • Teljes forráskód példa programmal

———————————————————————————

Ez azért egy kicsit nagyképű kijelentés, de részben igaz. Valóban fel lehet az alábbi függvények segítségével építeni egy szöveges, változó rekordhosszú adatbázist az ATmega eeprom-jában. Az ötletet az adta, hogy szükségem volt egy olyan programra, ami számokat leír szövegesen (és ki is mondja egy mp3 lejátszón). Jó sok string-et kellett a programban definiálnom, ami természetesen az Arduino ram-ba került, és teljesen elfogyott a 2Kbyte ram memória. Arra gondoltam, hogy ezeket a szövegeket beírom az eeprom-ba és onnan használom. Nevezetesen 88 szöveget kellett volna tárolnom, ami az 1kbyte eepromban 1024/88=~11 karakteres szavakat tett volna lehetővé. Ekkor nagyon egyszerű lett volna a program, hiszen konkrétan kiszámolható kezdőcímen kezdődtek volna a szövegek. Igen ám, de nekem ennél hosszabb szövegeim is voltak. Ugyanakkor a legtöbb szövegem ennél jóval rövidebb pl. „öt”. Ugyanakkor terveim között szerepel egy olyan kütyü, amiben a néhány nyomógomb (rotary kapcsoló) segítségével lehet szavakat szerkeszteni, és azokat tárolni kell. Az itt megadott szavak, szövegek jóval hosszabbak is lehetnek mint 10-20 karakter, bár várhatóan a szövegek száma nem lesz több mint 40-50db, de ezt nem lehet előre tudni. Ezért kezdtem el foglalkozni a kérdéssel, hogyan lehetne ezeket a szövegeket változó rekordhosszú adatbázisban tárolni. Túl bonyolult nem lehet az adminisztráció, mert alig van memória. Így kompromisszumokat kellett kötni. Az első és legfontosabb kompromisszum, hogy a szövegeket kizárólag az eeprom-ba írt sorrend alapján keletkező index (sorszám) szerint lehet visszakeresni. A visszakereséskor végig kell olvasni elejétől az adatbázist, bár 1kbyte esetében ez nemfog sokáig tartani. A szövegek maximális hossza is korlátozott, maximum 255 byte lehet, mert a hosszúságot egy byte-on tárolom. Igaz, ilyen hosszú szövegből már csak 4 db férne el.

Mini adatbázis kezelőm ezért a következő képen működik! Az első szöveg tárolásakor kiszámolom a szöveg teljes hosszát, és a legeslegelső byte-ra (0.cím) letárolom a hosszúságot egy byte-on. Ezt követően karakterenként egy byte felhasználásával beírom a szöveget. A szöveg utolsó karaktere után beírok egy 0-át. Ez fogja jelezni az adatbázisom végét, az utolsó rekord után mindig 0 lesz. Amikor be akarok írni egy új szöveget, elindulok az első byte-al (0. cím), kiolvasom az ott található számot. Előre ugrok a memória címben annyit, amennyi a byte tartalma volt plusz egyet. Itt található vagy egy nulla, ha az adott rekor az utolsó volt, vagy egy nullánál nagyobb szám, ami a következő szöveg hosszúsága. Ha nullánál nagyobb számot találok, akkor tovább növelem a címet az ott talált számmal plusz eggyel, és mindezt addig csinálom, amig meg nem találtam a nullát, ami az utolsó szöveget jelzi. Ha meg van a nulla, akkor az felülírom az aktuálisan tárolni kívánt szöveg hosszával, byte-onként tárolom a karaktereket, és lezárom az egészet egy nullával. Hát ennyi az egész! A könnyebb értehetőség kedvéért íme egy két szavas példa, az első szöveg „AAA” betű (ASCII 65), a második szó „BBBBB” betű (ASCII 66):

Kiolvasáskor természetesen meg kell adni a kiolvasni kívánt szöveg sorszámát (indexét), és annyiszor ugrani előre a memória címben, amennyi az index értéke. Ha elértük, byte-onként kiolvasható a szöveg az első byte-ban megadott hosszúságban. Az algoritmus szövegenként egy byte-ot pazarol, ami elviselhető, ha a szavak száma 100 alatt marad.

A fenti algoritmust négy függvénnyel valósítottam meg:

eeprom_txt_ir(szöveg, index);   Beír egy szöveget az adatbázisba. A szöveg mellett paraméterként meg kell adni egy index értéket. Ha ez 0, akkor utolsó rekord mögé írja a szöveget, azaz hozzáfűzi az adatbázishoz. Ha konkrét értéket adunk meg, akkor arra az index értékre írja be a szöveget, de minden későbbi szöveg elveszik. Így pl. teljesen új adatbázist lehet kezdeni, ha az index érték 1.

eeprom_txt_olvas(index); A megadott indexű (sorszámú) szöveget adja vissza

eeprom_txt_torol(index);  A megadott indexű szöveget törli az adatbázisból, a többi szöveg megmarad csak eggyel előrébb lép és mindegyiknek az indexe kisebb lesz eggyel.

eeprom_txt_hely(); Visszaadja a szövegek által elfoglalt helyet byte-okban, valamint visszaadja a maximális szöveg indexet, vagyis azt, hogy hány szöveg található az adatbázisban.

A függvények használatához létre kell hozni egy struktúrát:

struct eeprom {               
  int eeprom_meret=500; //ebben a konstansban tartjuk az adatbázis kezelésre fenntartott eeprom terület maximális méretét
  int foglalt_hely;    //ebben a változóban kapjuk meg a foglalt helyek számát byte-ban
  byte rekord_szam;     //az eddig beírt szavak száma
  bool sikeres;         //értéke 1, ha sikeres volt a tárolás, vagy lekérdezés, és 0, ha nem tudta beírni a megadott szót
};

Látható, hogy nem kell a teljes eeprom-ot elhasználni. Ha csak néhány szót szeretnénk tárolni, akkor az eeprom_meret változót állítsuk kisebbre. A példában 500 byte lett a maximális 1024 helyett (ATmega328). Fontos tudnivaló még, hogy az ékezetes betűket az Arduino IDE fordítója a stringekben két karakteren tárolja UTF8 kódolással. Ha tehát valahol egy szövegben ékezetes betűt használunk, az rögtön két byte helyet fog foglalni. Lehetne itt is spórolni, ha tárolás előtt az ékezetes betűket valamilyen nem használt ASCII tartományba helyezzük, azaz, a két byte-ot egy-re cseréljük. Pl. jó tartomány lehet az 1-31-ig tartó kódtartomány, itt nincsenek betűk vagy számok. Persze ekkor az olvasáskor is kódcserét kell alkalmazni, és az egy byte-ot visszacserélni kettőre. Én ezzel nem vacakoltam, bár a magyar szavakban sok az ékezet, az 1kbyte-hoz képest sokat lehetne megtakarítani. Ha ez a lehetőség valaki érdekel, akkor ajánlom figyelmébe az „Ékezetes betűk írása LCD-re kényelmesen” cikkemet, mert abban lényegileg ugyanezt kellett megvalósítani, csak ott az LCD kijelző miatt kellett a két byte-os ékezetes betűket egy byte-os kódra cserélni az LCD kijelző kedvéért! No persze előtte a gyárilag kijelölt kódokra le kellett tölteni a z LCD-re a magyar ékezetes betűk karakterképét, így ott a fő feladat nem a karakter kód konverzió volt!

Írtam egy példa programot, ami bemutatja a függvények működését. A gyakorlatban eddig még jómagam is csak úgy használtam, hogy egy külön ideiglenes programmal feltöltöttem a szövegekkel az eeprom-ot, egy másik „valamit csináló” programban pedig csak olvasgattam a szövegeket. Bár a távlati terveimben nem ilyen felhasználás szerepel! Dinamikusan, működés közben szeretnék szavakat (címkéket) készíteni, de a program még nem készült el. A program egy “emlékeztető” gép lenne, ami megtanulja, hogy mikor szoktam pl. virágot locsolni, és ha letelt a szokásos idő, akkor villogó led-el és szöveges kiírással is figyelmeztet a feladatra (feladatokra). Nem konkrét dátumokkal fog működni, hanem a két esemény közötti időtartamot állapítja meg és figyeli. Persze legalább a két legelső végrehajtást jelezni kell, így lehet, hogy magamat ismerve mégis el fognak száradni a virágok! Azonban az adatbáziskezelő programmodul már készen van hozzá!

Íme a példaprogram a fenti függvényekkel. A kommentekből sok részlet kiderül, de használathoz nem kell feltétlenül megérteni a működést. A példa programban a setup()-ban, minden lehetséges szituációt bemutatok.

#include <EEPROM.h> 

struct eeprom {               //Ebben a struktúrában adja vissza az adatokat az eeprom_txt..() függvény függvény csoport, kivéve az eeprom_txt_olvas(), mert az string-et ad vissza.
                              //Az eeprom_txt_ir() függvény egyik paramétere a az a méret, amit elfoglalhatunk az eeprom-ból.
                              //Ennek maxmiális értéke ATmega328 esetén 1024 byte, mert ekkor a az eeprom méret, de használhatunk belőle kevesebbet is.
  int eeprom_meret=500;       //ebben a konstansban tartjuk az adatbázis kezelésre fenntartott eeprom terület maximális méretét
  int foglalt_hely;          //ebben a változóban kapjuk meg a foglalt helyek számát byte-ban
  byte rekord_szam;           //az eddig beírt szavak száma
  bool sikeres;               //értéke 1, ha sikeres volt a tárolás, vagy lekérdezés, és 0, ha nem tudta beírni a megadott szót
};

eeprom x;                     //rögtön létre is hozunk egy adat nevű, és eeprom típusú változót
byte xx;                      //segédváltozó

void setup()
{
  Serial.begin(9600);
  
  //törlöm az eeprom teljes tartalmát. Csak azért, hogy üres legyen és jól lehessen látni mi történik
  //az eeprom_txt_ir() függvény használatához nem kell törölni az eeprom-ot.
  Serial.println("EEPROM törlés...");
  for (int i=0;i<512;i++) {
    EEPROM.write(i,0);
  }
  //beírjuk az első adatot az eeprom-ba
  //Most ez eeprom üres, mert előtte töröltük. A megadott paraméter 0, tehát az eeprom_txt_ir()
  //függvény üres helyet keres, de már rögtön az első is üres, mert a kezdő címen is 0 tartalmat talál.
  Serial.println("Beírjuk az első adatot az EEPROM-ba:");
  x=eeprom_txt_ir("AAA",0);
  //kiírom a visszakapott értékeket, hogy lássuk mi történik, a továbbiakban már nem írom ki
  Serial.print("Állapot->");
  Serial.print("foglalt:");Serial.print(x.foglalt_hely);
  Serial.print(" byte, rekord:");Serial.print(x.rekord_szam);
  Serial.print("db Sikeres:");Serial.println(x.sikeres);
  Serial.println("További rekordokat írunk....");
  x=eeprom_txt_ir("BBBBBBBB",0);
  x=eeprom_txt_ir("CCCCCCCCCCCCCCCCCCCCCCCCCC",0);
  x=eeprom_txt_ir("DDDDDDDDD",0);
  x=eeprom_txt_ir("Ékezetes szavakra is van lehetőség!",0);

  //kiolvasom az eeprom első 96 byte-ját (elég ennyi, mert nem írtuk tele)
  Serial.println("Az EEPROM adattartalma a rekordok beírása után:");
  for (byte i=0;i<6;i++) {
    for (byte j=0;j<16;j++) {
      //Serial.print(i*16+j);
      xx=(byte)EEPROM.read(i*16+j);
      //csak azért, hogy szebben legyen kiírva 
     if (xx<10) {Serial.print("  ");Serial.print(xx);} ;    
      if (xx>9 and xx<100) {Serial.print(" ");Serial.print(xx);};
      if (xx>100) {Serial.print(xx);};
      Serial.print(",");
    }
    Serial.println();         //16 kiírt érték után dobunk egy sort
  }
  //lekérdezzük a eepromban lévő helyet és adatokat
  x=eeprom_txt_hely();
  Serial.print("Állapot->");
  Serial.print("foglalt:");Serial.print(x.foglalt_hely);
  Serial.print(" byte, rekord:");Serial.print(x.rekord_szam);
  Serial.print("db Sikeres:");Serial.println(x.sikeres);
  //Kiírjuk a tárolt szavakat
  Serial.println("Tárolt szavak:");
  for (byte i=1;i<x.rekord_szam+1;i++) {
    Serial.println(eeprom_txt_olvas(i));
  }
  
  //kipróbáljuk, mi történik, ha az eeprom_txt_ir() függvénynek konkrét index értéket adunk meg
  //Arra az index-re fog egy új rekordot beírni, és minden más ami utána jönne eltörlődik (azaz elérhetetlen lesz)
  Serial.println("A harmadik rekordot új tartalommal töltjük fel, és mindent eltörlünk mögötte:");
  x=eeprom_txt_ir("Ez lett az utolsó!",3);
  //Kiírjuk a tárolt szavakat
  Serial.println("Tárolt szavak:");
  for (byte i=1;i<x.rekord_szam+1;i++) {
    Serial.println(eeprom_txt_olvas(i));
  }
  x=eeprom_txt_hely();
  Serial.print("Állapot->");
  Serial.print("foglalt:");Serial.print(x.foglalt_hely);
  Serial.print(" byte, rekord:");Serial.print(x.rekord_szam);
  Serial.print("db Sikeres:");Serial.println(x.sikeres);
 
  //kipróbáljuk a törlést is
  Serial.println("Újra töltjük az adatbázist új tartalommal");
  x=eeprom_txt_ir("1111111111111111",1);                        //újra töltjük az adatbázis adatokkal, mert indexnek 1-et adtunk meg. 
                                                                   //Példa arra, hogyan lehet eeprom törlés nélkül teljesen újra kezdeni a szövegek tárolását
  x=eeprom_txt_ir("2222222222",0);
  x=eeprom_txt_ir("33333333333333333333333333",0);
  x=eeprom_txt_ir("444444444444444",0);
  x=eeprom_txt_ir("5555555555555555555555555555",0);
  Serial.println("Tárolt szavak:");
  for (byte i=1;i<x.rekord_szam+1;i++) {
    Serial.println(eeprom_txt_olvas(i));
  }
  Serial.print("Állapot->");
  Serial.print("foglalt:");Serial.print(x.foglalt_hely);
  Serial.print(" byte, rekord:");Serial.print(x.rekord_szam);
  Serial.print("db Sikeres:");Serial.println(x.sikeres);
  Serial.println("A harmadik rekord törlésének bemutatása:");
  x=eeprom_txt_torol(3);                                         //töröljük a 3. rekordot
  //Kiírjuk a tárolt szavakat
  Serial.println("Tárolt szavak:");
  for (byte i=1;i<x.rekord_szam+1;i++) {
    Serial.println(eeprom_txt_olvas(i));
  }
  Serial.print("Állapot->");
  Serial.print("foglalt:");Serial.print(x.foglalt_hely);
  Serial.print(" byte, rekord:");Serial.print(x.rekord_szam);
  Serial.print("db Sikeres:");Serial.println(x.sikeres);
}


void loop()
{

}


eeprom eeprom_txt_ir(String szoveg,int index) 
/*********************************************************************************************
 * Ez a függvény a paraméterként átadott string-et beírja az eeprom-ba. Minden alkalommal    *
 * amikor meghívjuk, megkeresi a következő üres helyet az "adatbázisban". Egy szöveg elé     *
 * letárolja a szöveg karakterekben mért hosszát (az ékezetes betűk 2 byte-osak) és egy       *
 * 0-val zárja le a szöveget. A 0 azért kell a végére, mert a következő szöveg beírásakor    *
 * ez a 0 jelzi, hogy innen lehet írni, vagyis nincs több szöveg a sorban (az adott 0-val    *
 * lezárt szöveg az utolsó a sorban). Egy következő beíráskor azt a 0-át felülírja a         *
 * következő szöveg hosszával. A szövegek kiolvasásakor ezeknek a hosszoknak a               *
 * segítségével keresi mega  következő szöveget. A kiolvasás kizárólag elölről kezdve        *
 * sorrendben lesz lehetséges.                                                               *
 * A függvény paraméterei:                                                                   *
 *  szoveg       - az eepromba beírandó szting, maximum 255 byte hosszú lehet                *
 *  index        - egy olyan érték, ami lehetőséget ad az eepromba írás elkezdésére,         *
 *                 folytatására, illetve egy adott ponttól történő felülírására.             *
 *                 ha index=0, akkor folytatja a szöveg beírást a következő szabad           *
 *                 területtől. Ha az eeprom-ot előtte töröltük (vagy csak az első byte-ot)   *
 *                 akkor az adott szöveg lesz sorrendben az első, és innen folytatja a       *
 *                 többivel. Ha a megadott érték nagyobb mint nulla, akkor a megadott        *
 *                 értéknek megfelelő helyre írja a szöveget. Ha ez 1, akkor rögtön          *
 *                 legelsőnek. Így lehet egy meglévő szöveges adatbázis törölni, mert        *
 *                 elsőnek írja be a szöveget, és ezzel minden más előzményt eltüntet.       *
 *                 Ha pl 3, akkor ez a harmadik szövegnek írja be, és ha több szöveg         *
 *                 is volt, azok már nem lesznek elérhetők.                                  *
 *********************************************************************************************/
{
  eeprom adat;                   //ezt a változó struktúrát fogjuk visszaadni amikor befejeztük az írást
  adat.foglalt_hely=0;           //kezdetben a foglalt hely 0, ezt növelni fogjuk, ahogyan haladunk előre a következő rekord
                                 //keresésekor. Ez egyben a memória cím is, ahonnan adatokat olvasunk, vagy ahová adatoka írunk. 
                                 //Amikor beírtuk a szöveget és a lezáró nullát, értéke éppen az elfoglalt mennyisége byte-okban.
  adat.rekord_szam=0;            //ez jelzi, hogy éppen hányadik rekordnál járunk. A beírást követően ebben adjuk 
                                 //vissza, hogy éppen hány rekord van az adatbázisban
  adat.sikeres=0;                //ez is visszaadásra kerül a beírást követően, ha értéke 1, akkor sikeres volt a szöveg beírása
                                 //he nem sikerült beírni a szöveget, akkor 0.
  byte ertek;                    //ebbe olvassuk ki a szöveget megelőző egy byte-ot, ez lesz az aktuális szöveg hossza.
  byte meret=szoveg.length();    //a beírásra átadott szöveg hossza byte-okban. Ékezetes betűk 2 byte-ot foglalnak
  if (index!=1) {                //ha index nagyobb mint 1, akkor meg lett adva, hogy hányadik rekordnak írjuk be a szöveget
                                 //ha index=1, akkor kihagyjuk a keresést, mert rögtön az elsőnek kell beírni. 
                                 //ha index=0, akkor utolsónak kell beírni, tehát kell a keresés
    do  {
      ertek=EEPROM.read(adat.foglalt_hely);         //ez az aktuális szöveg hossza, ezzel növeljük majd a címet, ha tovább keressük a következő szöveget
      if (ertek==0) { break;}                       //megtaláltuk az utolsó szöveget, mert 0-val van lezárva, kiugrunk a ciklusból, mert ide lehet írni a szöveget
      adat.foglalt_hely=adat.foglalt_hely+ertek+1;  //a következő szöveg hosszát megadó byte címe
      adat.rekord_szam++;                           //a rekordszámot is növeljük, az első megtalált rekord után pont 1
      if (index==adat.rekord_szam) {break;}         //mivel meg lett adva beírási sorszám, és éppen annál járunk, kiugrunk a ciklusból, és 
                                                    //az adat.foglalt_hely változó által kijelölt címre fogjuk beírni a szöveget.
    } while (adat.foglalt_hely<adat.eeprom_meret);       //akkor is kiugrunk a ciklusból, ha elértük a kijelölt terület végét
  }
  
  if (adat.foglalt_hely+3>adat.eeprom_meret) {      //ha már 3 byte-nál kevesebb a szabad hely, akkor kilépünk sikertelen jelzéssel.
                                                    //ekkor előfordulhat, hogy nem tudjuk kiírni a teljes szöveget, hiszen csak 2 byte maradt.
    adat.sikeres=0;return(adat);
  }

  //elkezdjük beírni az adatot az eepromba
  EEPROM.write(adat.foglalt_hely,meret);            //első byte a szöveg mérete byte-okban (max. 255 lehet)
  adat.foglalt_hely++;                              //növeljük a kiírás címét, innen fogjuk írni a tényleges szöveget
  for(byte i=0;i<meret;i++)                         //sorban elővesszük a szöveg karaktereit
  {
    if (adat.foglalt_hely>adat.eeprom_meret) {      //itt is nézzük, hogy nem telt-e meg. Ha igen, akkor sikertelen jelzéssel kilépünk
      adat.sikeres=0;return(adat);
    }
    EEPROM.write(adat.foglalt_hely,szoveg[i]);     //ez itt a soron következő karakter beírása (ékezetes betűk két byte-ot foglalnak két lépésben)
    adat.foglalt_hely++;
  }
  EEPROM.write(adat.foglalt_hely,0);                //ezt azért nullázzuk, mert innen tudjuk legközelebb, hogy ez volt az utolsó rekord
                                                    //így nem kell törölni a teljes eeprom-ot, ha valahová középre írunk adatot
                                                    //az itt következő rekordok viszont automatikusan elvesznek
  adat.rekord_szam++;                               //rekordszám visszatérési érték növelése 1-el, hiszen hozzáírtunk egyet a meglévő szövegekhez
  adat.sikeres=1;                                   //sikeres írás jelzése
  return(adat);
}

eeprom eeprom_txt_hely() 
/************************************************************************************
 * Ez a függvény paraméter nélkül működik. Megkeresi az utolsó rekordot és          *
 * visszaadja a szavak számát, az elfoglalt és a még rendelkező helyet byte-okban.  *
 ************************************************************************************/
{
  eeprom adat;
  adat.foglalt_hely=0;           //Kezdetben a foglalt hely 0, ezt növelni fogjuk, ahogyan haladunk előre a következő rekord
                                 //keresésekor. Ez egyben a memória cím is, ahonnan adatokat olvasunk. Az utolsó rekordnál 
                                 //értéke éppen az elfoglalt mennyisége byte-okban.
  adat.rekord_szam=0;            //Ez jelzi, hogy éppen hányadik rekordnál járunk. A beírást követően ebben adjuk 
                                 //vissza, hogy éppen hány rekord van az adatbázisban
  adat.sikeres=0;                //Ennek az értéke csak 1 lehet, mert a lekérdezés nem tud nem sikeres lenni
  byte ertek;                    //ebbe olvassuk ki a szöveget megelőző egy byte-ot, ez lesz az aktuális szöveg hossza.
  do  {
    ertek=EEPROM.read(adat.foglalt_hely);            //Kiolvassuk az aktuális szöveg hosszát byte-okban
    if (ertek==0) { break;}                          //Ha nulla, akkor elértük az utolsó rekordot
    adat.foglalt_hely=adat.foglalt_hely+ertek+1;     //Ha nem nulla volt az értek, akkor kiszámoljuk a következő rekord kezdőcímét
    adat.rekord_szam++;                              //Növeljük a rekordok darabszám számlálóját
  } while (adat.foglalt_hely<adat.eeprom_meret);     //Akkor is kiugrunk a ciklusból, ha elértük a tárolásra használt epprom terület legvégét
  adat.sikeres=1;                                    //Nem tud nem sikeres lenni
  return(adat);                                      //Visszaadjuk a megállapított adatokat
}

eeprom eeprom_txt_torol(int index) 
/*******************************************************************************************
 * Ez a függvény kitörli a paraméterben megkapott sorszámon tárolt szöveget. A szöveget *
 * az eeprom megfelelő pontjainak végig olvasásával keresi meg. Amikor megtalálta, megkeresi 
 * a következőnek szöveg kezdőcímét, és byte-onként előre másol                            *
 * Ha az utolsó rekord sorszámát adtuk meg, vagy nagyobb sorszámot mint az összes szöveg 
 * darabszáma, akkor nem történik törlés. Törlés után visszaadja a szabd helyet, foglalt 
 * helyet, a szövegek darabszámát, és a törlés sikerességét.
 *******************************************************************************************/
{
  eeprom adat;
  adat.foglalt_hely=0;           //Kezdetben a foglalt hely 0, ezt növelni fogjuk, ahogyan haladunk előre a következő rekord
                                 //keresésekor. Ez egyben a memória cím is, ahonnan adatokat olvasunk. Az utolsó rekordnál 
                                 //értéke éppen az elfoglalt mennyisége byte-okban.
  adat.rekord_szam=0;            //Ez jelzi, hogy éppen hányadik rekordnál járunk. A beírást követően ebben adjuk 
                                 //vissza, hogy éppen hány rekord van az adatbázisban
  adat.sikeres=0;                //Ennek az értéke csak 1 lehet, mert a lekérdezés nem tud nem sikeres lenni
  byte ertek;                    //ebbe olvassuk ki a szöveget megelőző egy byte-ot, ez lesz az aktuális szöveg hossza.
  int kov_cim=0;                 //A következő szöveg kezdőcíme, innen fogunk másolni addig, amíg nullát nem találunk, mert az a szövegek vége
  do  {
    ertek=EEPROM.read(adat.foglalt_hely);                //Kiolvassuk a szöveg hosszát
    if (ertek==0) {                                      //ha ez nulla, akkor az utolsó rekordhoz értünk, és nem tudtunk törölni.
                                                         //Ez csak akkor fordulhat elő, he a paraméterben megadott sorszám nagyobb mint a rekordok száma.
      adat.sikeres=0;return(adat);                       //beállítjuk a sikerességet 0-ra, mert nem volt sikeres a törlés, és visszatérünk
    }                                       
    adat.rekord_szam++;                             //Növeljük a darabszámot, mert érvényes szót találtunk
    if (adat.rekord_szam==index) {                  //Ha a paraméterben megkapott darabszám megegyezik az aktuális szöveg sorszámával, akkor ezt kerestük, ezt kell törölni
       kov_cim=adat.foglalt_hely+ertek+1;           //ez a következő szöveg kezdőcíme, innen fogunk egyenként másolni
       do {
        ertek=EEPROM.read(kov_cim);                 //Kiolvassuk a következő másolandó byte tartalmát
        EEPROM.write(adat.foglalt_hely,ertek);      //Átírjuk a kiolvasott byte-ot a törlendő szöveg első byte-jától kezdve
        kov_cim++;                                  //tovább lépünk eggyel a másolandó címmel
        adat.foglalt_hely++;                        //tovább lépünk eggyel azzal a címmel, ahová másolunk
      } while (ertek!=0 and kov_cim<adat.eeprom_meret);        //akkor ugrunk ki a ciklusból, ha megtaláltuk az utolsó szó lezáró 0 byte-ját, 
                                                    //vagy elérték a tárolásra szolgáló eeprom terület végét
      break;                                        //befejeztük a másolást, mehetünk megszámolni az eeprom terület adatait a normál visszatéréshez
    }
    adat.foglalt_hely=adat.foglalt_hely+ertek+1;
  } while (adat.foglalt_hely<adat.eeprom_meret);               //úgy értük el az eeprom terület végét, hogy nem találtuk meg a törlendő rekordot
                                                    //ez csak akkor fordulhat elő, ha meg volt telve az eeprom, és a megadott törlendő sorszám
                                                    //nagyobb, mint az összes rekord darabszáma

  //a visszaadott paraméterekhez újra végig kell olvasni, mert másolás közben nem figyeltük, hogy hány szöveget másoltunk  
  //A legegyszerűbb megoldással idemásoltam a szabad terület megadó függvény programsorait
  adat.foglalt_hely=0;           
  adat.rekord_szam=0;            
  adat.sikeres=0;           
  do  {
    ertek=EEPROM.read(adat.foglalt_hely);            //Kiolvassuk az aktuális szöveg hosszát byte-okban
    if (ertek==0) { break;}                          //Ha nulla, akkor elértük az utolsó rekordot
    adat.foglalt_hely=adat.foglalt_hely+ertek+1;     //Ha nem nulla volt az értek, akkor kiszámoljuk a következő rekord kezdőcímét
    adat.rekord_szam++;                              //Növeljük a rekordok darabszám számlálóját
  } while (adat.foglalt_hely<adat.eeprom_meret);     //Akkor is kiugrunk a ciklusból, ha elértük a tárolásra használt epprom terület legvégét
  adat.sikeres=1;                                    //Sikeres volt a törlés
  return(adat);                                      //Visszatérési érték a törlés utáni adatokkal.
}


String eeprom_txt_olvas(int index) 
/*********************************************************************************************
 * Ez a függvény visszaadja a paraméterben megkapott sorszámon tárolt szöveget. A szöveget   *
 * az eeprom megfelelő pontjainak végig olvasásával keresi meg. Minél nagyobb a paraméterben *
 * magadott sorszám, annál lassabban találja meg a keresett szöveget. Ha nagyobb sorszámot   *           
 * adunk meg paraméterként mint a szövegek darabszáma, akkor üres stringet ad vissza         *
 *********************************************************************************************/
{
  eeprom adat;
  String szo="";                       //Ebbe a változóba olvassuk vissza szöveget, ha megtaláltuk
  int akt_cim=0;                       //Ebben a változóban tároljuk az aktuális olvasási címet
  int akt_index=0;                     //Ebben a változóban számoljuk a rekordokat, folyamatosan növekszik.
                                       //Ha értéke megegyezik a paraméterben megkapott index-el (sorszámmal)
                                       //akkor megtaláltuk a szöveget
  byte ertek;                          //Ebbe olvassuk be a szövegek hosszának étékét a rekordok legelejéről
  do  {
    ertek=EEPROM.read(akt_cim);          //Kiolvassuk a szöveg hosszát
    if (ertek==0) {return("");}          //ha ez nulla, akkor az utolsó rekordhoz értünk, és üres stringet adunk vissza.
                                         //Ez csak akkor fordulhat elő, he a paraméterben megadott sorszám nagyobb, mint a rekordok száma.
    akt_index++;                         //Növeljük a darabszámot, mert érvényes szót találtunk
    if (akt_index==index) {              //Ha a paraméterben megkapott darabszám megegyezik az aktuális szöveg sorszámával, akkor ezt kerestük
    for (byte i=0;i<ertek;i++) {         //A kezdő byte-on megadott karakterszámot olvassuk végig
        szo=szo+" ";                     //Növeljük a szo nevű string változó hosszát azzal, hogy hozzáadunk egy karaktert
        szo[i]=EEPROM.read(akt_cim+1+i); //A szo nevű stringünk i-dik karakterére úgy tudunk hivatkozni, mintha egy tömb lenne, és így rögtön bele is tudjuk 
                                         //olvasni a tárolt számot, ami a karakter kódja
      }
      return(szo);                       //Az utolsó byte kiolvasása után visszatérünk a string-el 
    }
    akt_cim=akt_cim+ertek+1;             //Ha sorszám még kisebb volt mint a paraméterben kapott kiolvasandó sorszám, akkor kiszámítjuk a következő szó kezdő címét
  } while (akt_cim<adat.eeprom_meret);        //Akkor is kiugrunk a ciklusból, ha a tárolásra rendelkezésre álló eeprom terület végére értünk. Ez akkor fordulhat elő,
                                         //ha olyan nagy értéket adtunk meg a paraméterben, ami nagyobb, mint a tárolt szavak száma, és az eeprom is tele van.
  return("");                            //Visszatérési érték, ha nem találtuk meg a szöveget.
}

Ez pedig a példa program futási eredménye. Azért használtam a szavakban „A”, „B” stb. betűket, mert ezek ASCII kódját ismerem, (pl. az „A” betű kódja 65, a B betű 66 és így tovább) és a memória tartalom kiíratása után az értelmezésben könnyebb dolgom volt!

EEPROM törlés...
Beírjuk az első adatot az EEPROM-ba:
Állapot->foglalt:4 byte, rekord:1db Sikeres:1
További rekordokat írunk....
Az EEPROM adattartalma a rekordok beírása után:
  3, 65, 65, 65,  8, 66, 66, 66, 66, 66, 66, 66, 66, 26, 67, 67,
 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67,
 67, 67, 67, 67, 67, 67, 67, 67,  9, 68, 68, 68, 68, 68, 68, 68,
 68, 68, 38,195,137,107,101,122,101,116,101,115, 32,115,122, 97,
118, 97,107,114, 97, 32,105,115, 32,118, 97,110, 32,108,101,104,
101,116,197,145,115,195,169,103, 33,  0,  0,  0,  0,  0,  0,  0,
Állapot->foglalt:89 byte, rekord:5db Sikeres:1
Tárolt szavak:
AAA
BBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDD
Ékezetes szavakra is van lehetőség!
A harmadik rekordot új tartalommal töltjük fel, és mindent eltörlünk mögötte:
Tárolt szavak:
AAA
BBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCC
Ez lett az utolsó!
Állapot->foglalt:60 byte, rekord:4db Sikeres:1
Újra töltjük az adatbázist új tartalommal
Tárolt szavak:
1111111111111111
2222222222
33333333333333333333333333
444444444444444
5555555555555555555555555555
Állapot->foglalt:100 byte, rekord:5db Sikeres:1
A harmadik rekord törlésének bemutatása:
Tárolt szavak:
1111111111111111
2222222222
444444444444444
5555555555555555555555555555
Állapot->foglalt:73 byte, rekord:4db Sikeres:1

Mennyire volt hasznos amit olvastál?

Kattints egy csillagra az értékeléshez!

Szövegesen is leírhatod véleményedet!