Akkumulátor vizsgáló

#include <EEPROM.h>     //eeprom kezelő könyvtár
#include<Wire.h>        //I2C kommunikáció kezelő könyvtár
#include <LiquidCrystal_I2C.h>  //I2C LCD kezelő könyvtár
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  //LCD paraméterek megadása
    
//******************************INA226 paraméterek, kezeléshez szükséges változók
int i2c_cim=0x44;               //az INA226 
unsigned int fesz;              //a buszfeszültség, ahol egy bit változás 1,25 mV PL. ha ennek értéke 4000, akkor a feszültség 5V
int sont_fesz;                  //a sönt feszültsége, ahol egy bit változás 2,5 mikroV Pl. ha ennek értéke 4000, akkor a söntfesz 0,01V
byte msByte,lsByte;             //segédváltozók a két byte 16 bites számmá alakításához
//******************************az aktuális mérési eredmények változói
long akku_kapacitas=0;          //Az eltelt idő (1sec) és az akkori áram szorzata ebben összegződik a mérés teljes 
                                //időtartamában. A pillanatnyi áramot megszorzom 10-el, hogy egy tizedes pontossággal
                                //összegezzek. Nyilván kijelzéskor osztani fogom 10-el. Ráadásul másodpercenként összegzem 
                                //az áramot, azért ahhoz, hogy mAh-ban kapjam meg az értékét még 3600-al is osztani kell.
                                //Ha nem így tennék, akkor gondot okozhatna a nagyon kicsi mennyiségek összegzése (pl. 1mA/3600=0,0002777)
int pill_fesz;                  //ebben tárolom az aktuális akku feszültséget (INA226 Vbus feszültség). Mivel ez integer, a valós feszültség 1000 szerese
int pill_aram;                  //ebben tárolom az aktuális töltő vagy merítő áramot (előjeles érték),
                                //(INA226 sönt feszültség szorozva a sönt ellenállással, esetünkben 0,1 ohm). Mivel ez integer, a valós feszültség 1000 szerese
float nullazas;                 //ebben tárolom az áram korrekciót, nullára tolja az áramot, ha nincs töltés vagy merítés. 
                                //azt tapasztaltam, hogy ha nincs töltés, akkor egy kicsit eltér a nullától a kijelzett áram. 
                                //Jelenleg -0.15mA áramot akkor is mér, ha nem folyik áram, ezért +0.15mA nullázást kellett beállítani.
int fesz_felbontas;             //a teljes mérési tartományt (max és min kikapcsolási feszültség különbsége) ennyi részre osztom fel. 
                                //Pl. 2.5V-4.2V-ig töltök illetve merítek, és a feszültséget 20 részre osztom, akkor 
                                //(4.2-2.5)/20=0.085V Vagyis 85mV változás esetén regisztrálom az eltelt időt másodpercekben, 
                                //a pillanatnyi áramot, feszültséget és kapacitást
int fesz_lepeskoz;              //ekkora feszültség változáskor történik regisztrálás ((fesz_max-fesz_min)/fesz_felbontás) 
                                //integer értéket tárolok, ezért a kiszámolt érték 1000 szeresét tárolom (fesz_min és fesz_max is integer és 1000szeres érték)
int fesz_min;                   //ennél a feszültségnél kapcsol ki a merítés (lithium aksinál 2,5V), értéke ezerszeres (pl. 2500)
int fesz_max;                   //ennál a feszültségnél kapcsol ki a töltés (lithium aksinál 4,2V), értéke ezerszeres (pl. 4200)
//******************************segédváltozók a működéshez                           
float mAh=0;                    //Az akku kapacitás kijelzéshez segéd változó
unsigned int ido;               //idő múlása másodpercekben. Csak akkor számolok előre másodpercenként, ha rögzítés történik
unsigned int ido_tmp,ora,perc,masodperc; //segédváltozók az eltelt idő kijelzéséhez
long millis_tmp=millis();       //segédváltozó az egy másodperces időzítéshez
long sw1_time;                  //1-es nyomógomb lenyomás idejének figyeléséhez segédváltozó
long sw2_time;                  //2-es nyomógomb lenyomás idejének figyeléséhez segédváltozó
bool sw1_allapot=0;             //1-es nyomógomb lenyomott állapota esetén 1
bool sw2_allapot=0;             //1-es nyomógomb lenyomott állapota esetén 1
long vissza_time;               //visszakapcsolás kijelzés üzemmódba segédváltozója (10 sec időzítéséhez használom)
bool rogzites=0;                //ha adatrögzítés van folyamatban, akkor 1
bool modvalt=0;                 //a kijelző üzzemmódjának változtatását jelzi, ha hosszan nyomom meg a 2-es nyomógombot
bool leptet_fel=0;              //röviden nyomta a nyomógombot, léptetni kell felfele. (a változó értéke a gombnyomáskor 1 lesz, 
                                //amit a szükséges funkció végrehajtása után azonnal 0-ra állítok)
bool leptet_le=0;               //röviden nyomta a nyomógombot, léptetni kell lefele. (a változó értéke a gombnyomáskor 1 lesz, 
                                //amit a szükséges funkció végrehajtása után azonnal 0-ra állítok)
bool ism_tilt1=0;               //1-es gombon a hosszan nyomvatartás ismétlésének akadályozására. Akkor lesz 1, ha még nem engedte el a nyomógombot, de már egyszer letelt a 800msec
bool ism_tilt2=0;               //2-es gombon a hosszan nyomvatartás ismétlésének akadályozására. Akkor lesz 1, ha még nem engedte el a nyomógombot, de már egyszer letelt a 800msec
byte uzemmod=0;                 //kijelző üzemmódjai: 0 foyamtos kijelzés, 1 adatkiolvasás, 2 adatttörlés 3 kikapcsolási feszültség minimum beállítása
                                //4 kikapcsolási feszültség maximum beállítása, 5 feszültség korrekció beállítása, 6 áram korrekció beállítása
                                //7 nullázási érték beállítása, 8 feszültség felbontás darabszám beállítása 
bool frissit=0;                 //Ha értéke 1, akkor frissítjük a képernyőt. Frissítést indíthat a másodpercenkénti mérés, és a nyomógombok rövid,
                                //vagy hosszú lenyomása. A frissítés teendői után értékét 0-ra állítom vissza, így várakozik a program a következő eseményre
int xadat_int;                  //eeprom-ba íráshoz és kiolvasáshoz segéd változó
int xfesz,xaram,xmAh,xido;      //eeprom-ba íráshoz és kiolvasáshoz segéd változók
int yfesz,yaram,ymAh,yido;      //eeprom-ba íráshoz és kiolvasáshoz segéd változók
int kiolv_sorsz=0;              //adat kiolvasáskor annak az adatnak a sorszáma, amit szeretnék kiolvasni és képernyőn megjeleníteni
int akt_sorsz=0;                //mivel mindig végig olvasom az eeprom tartalmat, az aktuális, éppen olvasott rekord sorszámát mutatja
int akt_cim=16;                 //Ez a változó tárolja az éppen aktuálisan olvasott adatrekord címét az eeprom-ban
int elozo_sorsz=0;              //ahhoz kell, hogy ne írogasson folyton a képernyőre adat kiolvasáskor
byte torl_kesl=6;               //adat törléskor ezzel számlálunk a törlés előtt, hogy meggondolhassa magát (véletlen törlés megakadályozása véletlen rövid gombnyomás esetére
                                //6 a nyugalmi állapot, ha egy gombot megnyom, akkor értékét 0-ra állítjuk, ekkor indul a számlálás 5-ig, amikor bekövetkezik a törlés.
                                //Ha közben nyomógombot nyom, akkor értékét újra 6-ra állítjuk.
int utolso_fesz;                //ha van már tárolt adat, vagy épp tárolás folyik, ehhez képest nézi a feszültség változást, és ha az több mint fesz_lepeskoz, 
                                //akkor tárolja az akt adatot
byte fo_uzemmod=0;              //a töltés, merítés és ciklikus töltés merítés üzemmódja (0=töltés, 1=merítés, 2=ciklikus)
bool sorosport=0;               //ezzel jelezzük, hogy a sorosportra is ki kell küldeni a regisztrált adatokat
byte ciklus_fazis=0;            //ciklikus vizsgálat egyes lépéseinek elkülönítésére
int varakozas=0;                //segédváltozó ahhoz, hogy a ciklikus vizsgálat esetén 10 percet (600másodpercet) várakozzak a töltés illetve merítés után
long vilagitas_ido;             //a háttérvilágítás lekapcsolásához szükséges időt méri (1perc)

//eeprom térkép
//Cím     Adat funkciója
//-----   -------------------------
//14,15 - aktuális rögzítési idő sec-ben (int), max. 18 óra rögzítési idő
//16-19 - az aktuális rögzített akku kapacitás (hogy folytatni lehessen az összegzést
//20,21 - leállítási minimum (0.0-tól 36.0-ig azaz 0-360-ig)
//22,23 - leállítási maximum (0.0-tól 36.0-ig azaz 0-360-ig)
//24,25 - korrekciós tényező feszültség méréshez (int)
//26,27 - korrekciós tényező sönt feszültséghez (int)
//28,29 - nullázási eltolás (int)
//30,31 - regisztrációs felbontás (int)5-40
// adatrekordok felépítésé
//a 0. rekord kezdőcíme 32 (a megadott adat címek relatív címek pl. az első adat a 32 címen kezdődik és 39-en van vége)
//Cím   Adat funkciója
//---   ---------------------------
//0,1 - rögzítés kezdete óta eltelt idő másodpercben (unsigend int azaz 65535/3600-> kb 18 óra max rögzítési idő töltés merítés esetén külön külön ciklikus vizsgálatnál)
//2,3 - ektuális feszültség mV-ban (max 65V)
//4,5 - aktuális áram 0,1mA felbontásban (max. 3200.0mA)
//6,7 - aktuáis töltési kapacitás szint mAh-ban (max. 65000mAh)


void setup() {
  Wire.begin();                       // I2C kommunikáció inicializálása, nincs cím, ezért master
  Serial.begin(9600);                 //soros port inicializálása
  Serial.println(F("Indul..."));      
  lcd.begin(20,4);                    //LCD inicializálása
  lcd.backlight();                    //háttérvilágítás bekapcsolása
  lcd.setCursor(0,0);
  lcd_uniprint((String)"");           //ékezetek feltöltése a képernyőre
  
  //INA226 modul beállítása (nem használok kész könyvtárat, elemi parancsokkal állítom be)
  Wire.beginTransmission(i2c_cim);
  if(Wire.endTransmission()){
    Serial.println(F("INA226 nincs jelen"));
  }
  //configurációs regiszter bitek
  //D15-reset
  //D11-D9 - átlagolásszám, Értékek: 1=0b00,4=0b001,16=0b010,64=0b011,128=0b100,256=0b101,512=0b110,1024=0b111
  //D8-D6 - Vbus konv. idő, Értékek: 140us=0b000,204us=0b001,332us=0b010,588us=0b011,1100us=0b100,2116us=0b101,4156us=0b110,8244us=0b111
  //D5-D3 - Shönt konv. idő, Értékek: 140us=0b000,204us=0b001,332us=0b010,588us=0b011,1100us=0b100,2116us=0b101,4156us=0b110,8244us=0b111
  //D2-D0 - Működési mód: folyamatos mérés=0b111, indított mérés=0b011,
  //chip alaphelyzetbe állítása
  Wire.beginTransmission(i2c_cim);  //megszólítjuk az eszközt
  Wire.write(0x00);                 //a státus regisztert fogjuk írni
  Wire.write(0x80);                 //beállítjuk a D15 reset bitet 1-re, többi bit közömbös
  Wire.write(0x00);                 //a státus regiszter 16 bites, ezért kell egy következő byte-ot is írni
  Wire.endTransmission();           //vége a kommunikációnak
  //Beállítjuk a chip mérési paramétereit: (jelen esetben folyamatos mérés, átlagolás 4, mérési idő 1,1ms)
  Wire.beginTransmission(i2c_cim);  //megszólítjuk az eszközt
  Wire.write(0x00);                 //a státus regisztert fogjuk írni
  //segéd ábra a paraméter bitek megtalálásához
  //0b0000aaav     a-átlagolási idő bitek, v-Vbus konverziós idő
  //0bvvsssmmm     v-Vbus konverziós idő, s-sönt konverziós idő, m-működési mód
  Wire.write(0b00000011);           //két byte-on küldünk ki minden adatot, pont a Vbus konv. időnél
  Wire.write(0b00100111);           //törte ketté
  Wire.endTransmission();
  delay(20);                        //hagyunk időt eg mBgzltn58#érésre, különben a legelső eredmény kiolvasás eredménye 0-lesz

  pinMode(2,INPUT);                 //A 2-es kivezetést bemenetnek fogjuk használni, ez lesz az 1-es kapcsoló (+ illetve STAR/STOP)
                                    //1-es kapcsoló hosszan nyomva (0,8sec) start illetve stop, klikkre lépteti a regisztrált adatokat időben visszavefé
  digitalWrite(2,HIGH);             //felhúzó ellenállás be
  pinMode(3,INPUT);                 //A 3-es kivezetést bemenetnek fogjuk használni, ez lesz az 2-es kapcsoló (- illetve MÓD választó)
                                    //2-es kapcsoló hosszan nyomva (0,8 sec) megjelenítésbe léptet, klikkre lépteti a regisztrált adatokat időben előre 
  digitalWrite(3,HIGH);             //felhúzó ellenállás be
  pinMode(4,OUTPUT);                //Relé kimenet, ami a töltést, vagy a merítést ki és bekapcsolja 
  digitalWrite(4,HIGH);             //a relé így nincs meghúzva
  pinMode(5,OUTPUT);                //Relé kimenet, ami a töltő feszültséget, vagy a terhelést üzemmódot állítja be 
  digitalWrite(5,LOW);              //a relé így nincs meghúzva (töltés)
  pinMode(6,INPUT);                 //viágítás kapcsoló, felkapcsolja a kijelző háttérvilágítást (a többi is felkapcsolja, de ez nem változtat semmin) 
  digitalWrite(6,HIGH);             //felhúzó ellenállás be
  if (digitalRead(2)==LOW) {             //alapértékek beállítása
    //tárolt működési paraméterek alapértékre állítása
    EEPROM.put(14,(unsigned int)0);      //aktuális rögzítési idő 0 (ha a töltést vagy a merítés leállítjuk, akkor inen lehet folytatni (ciklikus vizsgálatot nem lehet folytatni)
    EEPROM.put(16,(long) 0);             //aktuális akku kapacitás 0 (ha a töltést vagy a merítés leállítjuk, akkor inen lehet folytatni (ciklikus vizsgálatot nem lehet folytatni)
    EEPROM.put(20,(unsigned int) 2500);  //feszültség minimum (ennél a feszültségnél leáll a merítés)
    EEPROM.put(22,(unsigned int) 4200);  //feszültség maximum (ennél a feszültségnél leáll a töltés)
    EEPROM.put(24,(unsigned int) 9526);  //feszültség korrekció (a mért feszültséget ezzel a számmal szorozzuk, ezzel hitelesíthetjük a mért feszültséget)
    EEPROM.put(26,(unsigned int) 11900); //áram korrekció (a mért sönt feszültséget ezzel a számmal szorozzuk, ezzel hitelesíthetjük a mért sönt feszültséget)
    EEPROM.put(28,(unsigned int) 0);     //nullázás (-1mA-től +1mA-i század pontossággal)
    EEPROM.put(30,(unsigned int) 20);    //feszültség felbontás (a min és max értékek között ennyi pontra bontja fel a regisztrálandó pontokat)
    //adatrekord kezdeti beállítása
    EEPROM.put(32,(unsigned int) 0);              //az adatterület 0. rekordja 0, azaz nincs adat, mert már az első rekord 0
    EEPROM.put(34,(int) 0);
    EEPROM.put(36,(int) 0);
    EEPROM.put(38,(int) 0);
    //ciklikus vizsgálatnál az egyes töltések és merítések során regisztrált akkumulátor kapacitás értékek törlése
    EEPROM.put(1010,(int) 0);   //töltés adatok ciklikus vizsgálat esetén
    EEPROM.put(1012,(int) 0);
    EEPROM.put(1014,(int) 0);
    EEPROM.put(1016,(int) 0);   //merítés adatok ciklikus vizsgálat esetén
    EEPROM.put(1018,(int) 0);
    EEPROM.put(1020,(int) 0);

    lcd.clear();
    lcd.setCursor(0,0);                        
    lcd_uniprint((String)F("Alapérték beállítva!"));
    delay(3000);
    lcd.clear();
  }

  //tárolt működési paraméterek kiírása a képernyőre
  EEPROM.get(20,xadat_int);           //feszültség minimum aktuális értékének kiolvasása
  fesz_min=xadat_int;
  EEPROM.get(22,xadat_int);           //feszültség maximum aktuális értékének kiolvasása
  fesz_max=xadat_int;
  lcd.setCursor(0,0);
  lcd.print(F("Fesz:"));
  lcd.print((float)fesz_min/1000,3);  //a feszültség minimum 1000 szeresét tároljuk, így osztani kell ezerrel
  lcd.print("-");
  lcd.print((float)fesz_max/1000,3);  //a feszültség maximum 1000 szeresét tároljuk, így osztani kell ezerrel
  EEPROM.get(30,xadat_int);           //feszültség felbontás aktuális értékének kiolvasása
  fesz_felbontas=xadat_int;
  lcd.print(" V");
  lcd.setCursor(0,1);                        
  lcd_uniprint((String)F("Lépés:"));
  lcd.print(xadat_int);
  fesz_lepeskoz=(fesz_max-fesz_min)/fesz_felbontas; //feszültség lépésköz kiszámítása (ezt minden töltés vagy merítés 
                                                    //indításakor újra számoljuk, mert a feltöltött vagy lemerített akkumulátor 
                                                    //pihentetés után kisebb illetve nagyobb feszültségre áll be, és azt tekintjük alapnak
  lcd.print("(");
  lcd.print((float)fesz_lepeskoz/1000,3);           //aktuális feszültség lépésköz 1000 szeresét tároltuk, ezért osztani kell ezerrel
  lcd.print("V)");
  EEPROM.get(24,xadat_int);                         //feszültség szorzó kiolvasása
  lcd.setCursor(0,2);                        
  lcd_uniprint((String)F("V szorzó:"));
  lcd.print((float)xadat_int/10000,4);              //a feszültség szorzó értéke egy 1 körüli szám, és ennek 10000 szeresét tároljuk, így kijelzéshez osztani kell 10000-el
  EEPROM.get(26,xadat_int);
  lcd.setCursor(0,3);                        
  lcd_uniprint((String)F("A szorzó:"));
  lcd.print((float)xadat_int/10000,4);              //a sönt feszültség (áram) szorzó értéke egy 1 körüli szám, és ennek 10000 szeresét tároljuk, így kijelzéshez osztani kell 10000-el
  delay(5000);
  
  lcd.clear();
  EEPROM.get(28,xadat_int);                         //nullázás tárolt értékének kiolvasása
  nullazas=(float)xadat_int/100;                    //ezt az értéket mindig hozzáadjuk a mért és számított áram értékhez. Mivel 100 szorost tároltunk, 
                                                    //ezért kell 100-al osztani és float-ra alakítani
  lcd.setCursor(0,0);                        
  lcd_uniprint((String)F("Nullázás:"));
  lcd.print(nullazas,2);
  lcd.print(" mA");
  akt_cim=32;   //ez a legelső adatrekord kezdete
  xadat_int=0;
  utolso_fesz=0;
  //megszámoljuk a tárolt adat rekordok számát
  do {
    EEPROM.get(akt_cim,xfesz);
    EEPROM.get(akt_cim+2,xaram);
    EEPROM.get(akt_cim+4,xmAh);
    EEPROM.get(akt_cim+6,xido);
    if (xfesz!=0) {utolso_fesz=xfesz;}  //a ciklus végén megkapjuk az utolsó tárolt feszültség adatot
    akt_cim=akt_cim+8;
    xadat_int++;
    if (akt_cim>1008) {break;}
  } while (xfesz!=0 or xaram !=0 or xmAh!=0 or xido!=0);  //akkor értünk az utolsó rekordhoz, ha mind a négy érték 0
  
  lcd.setCursor(0,1);                        
  lcd.print("Reg.adat:");lcd.print(xadat_int-1);lcd.print(" db");
  delay(5000);

  lcd.clear();
  vilagitas_ido=millis();
}


void loop() {
  if (vilagitas_ido+60000<millis()) {lcd.noBacklight();}             //Kikapcsoljuk a kijelző háttérvilágítását, ha egy perce nem 
                                                                     //lett nyomógomb megnyomva (nyomógomb lenyomása vilagitas_ido=millis())
  if (digitalRead(6)==LOW) {lcd.backlight();vilagitas_ido=millis();} //megnyomtuk a világítás felkapcsoló nyomógombot
  if (digitalRead(2)==LOW and sw1_allapot==0) {                      //megnyomtuk az 1-es gombot, indul az időzítés, hogy megtudjuk rövid vagy hosszú lenyomás lesz
    ism_tilt1=0;sw1_allapot=1;sw1_time=millis();
    vissza_time=millis();lcd.backlight();vilagitas_ido=millis();
  }   
  if (digitalRead(2)==LOW and sw1_time+800<millis() and sw1_allapot==1 and ism_tilt1==0) {      //ha hosszan nyomvatartotta, 
                                                                                                //indítjuk vagy leállítjuk a fő üzemmeód által beállított
                                                                                                //töltést, merítést vagy ciklikus vizsgálatot
    lcd.backlight();vilagitas_ido=millis();
    ism_tilt1=1;
    //**************************** ez egyszeri töltés üzemmód *******************************  
    if (fo_uzemmod==0) {             
      if (rogzites==0) {                 //indítjuk a rögzítést, mert jelenleg áll     
        EEPROM.get(14,ido);              //kiolvassuk az eddigi rögzítési időt (ha 0 akkor új rögzítés lesz, ha nem nulla, folytatjuk a töltést)
        EEPROM.get(16,akku_kapacitas);   //kiolvassuk az eddigi töltéskor tárolt akku kapacitást
        rogzites=1;                      //ez fogja indítani a töltést
        if (ido==0) {                    //most kezdjük a töltést, újra kell számolni a pillanatnyi feszültség alapján a felosztást
          fesz_lepeskoz=(fesz_max-pill_fesz)/fesz_felbontas;
          adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk a kezdeti adatokat (mielőtt rákapcsoljuk az akkura a töltőt)
          utolso_fesz=pill_fesz;
        }
      } 
      else {                             //leállítjuk a töltést
        EEPROM.put(14,ido);              //tároljuk az aktuális töltési időt
        EEPROM.put(16,akku_kapacitas);   //tároljuk az aktuális kapacitást
        rogzites=0;                      //ez állítja le a rögzítést
      }
    }
    //**************************** ez egyszeri merítés üzemmód *******************************  
    if (fo_uzemmod==1) {           
      if (rogzites==0) {                 //indítjuk a rögzítést, mert jelenleg áll
        EEPROM.get(14,ido);              //kiolvassuk az eddigi rögzítési időt (ha 0 akkor új rögzítés lesz, ha nem nulla, folytatjuk a merítést)
        EEPROM.get(16,akku_kapacitas);   //kiolvassuk az eddigi merítéskor tárolt akku kapacitást
        rogzites=1;                      //ez fogja indítani a merítést
        if (ido==0) {                    //most kezdjük a merítést, újra kell számolni a pillanatnyi feszültség alapján a felosztást
          fesz_lepeskoz=(pill_fesz-fesz_min)/fesz_felbontas;
          adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/36000),ido);   //tároljuk a kezdeti adatokat (mielőtt rákapcsoljuk az akkura a terhelést)
          utolso_fesz=pill_fesz;
        }
      } 
      else {                            //leállítjuk a merítést
        EEPROM.put(14,ido);             //tároljuk az aktuális merítési időt
        EEPROM.put(16,akku_kapacitas);  //tároljuk az aktuális kapacitást
        rogzites=0;                     //ez állítja le a rögzítést
      }
    }
    
    //**************************** ez egy ciklikus vizsgálat üzemmód *******************************  
    if (fo_uzemmod==2) {           
      if (rogzites==0) {                   //indítjuk a rögzítést, mert jelenleg áll (törlünk minden adatot)
        EEPROM.put(14,(unsigned int)0);    //ido törlése
        EEPROM.put(16,(long)0);            //akku kapacitás törlése
        EEPROM.put(32,(unsigned int) 0);   //az adatterület 0. rekordja 0, azaz nincs adat
        EEPROM.put(34,(unsigned int) 0);
        EEPROM.put(36,(unsigned int) 0);
        EEPROM.put(38,(unsigned int) 0);
        EEPROM.put(1010,(int) 0);         //töltés adatok ciklikus vizsgálat esetén
        EEPROM.put(1012,(int) 0);
        EEPROM.put(1014,(int) 0);
        EEPROM.put(1016,(int) 0);         //merítés adatok ciklikus vizsgálat esetén
        EEPROM.put(1018,(int) 0);
        EEPROM.put(1020,(int) 0);
        fesz_lepeskoz=(fesz_max-fesz_min)/fesz_felbontas;  //itt a min és max. határok között fogunk mozogni
        ciklus_fazis=0;                                    //a ciklikus vizsgálatnak 12 fázisa van: (0) kezdeti teljes feltöltés
                                                           //(1) teljes merítés1, (2) szünet, (3) teljes töltés1, (4) szünet
                                                           //(5) teljes merítés2, (6) szünet, (7) teljes töltés2, (8) szünet
                                                           //(9) teljes merítés3, (10) szünet, (11) teljes töltés3 (12)
        akku_kapacitas=0;                                  //akku kapacitást töröljük (minden ciklus végén)
        rogzites=1;                                        //ezzel indul a rögzítés
        varakozas=0;                                       //a következő szünetnél ez fog 600-ig számolni
      }
      else {                              //leállítottuk a ciklikus vizsgálatot. Nem lehet újra indítani, csak újra kezdeni
        rogzites=0;                       //ezzel áll le a rögzítés
        digitalWrite(4,HIGH);             //kikapcsoljuk a relét, amin keresztül eddig töltöttük vagy merítettük az akkut (meghúzva földre kötötte a nagatív pontját)
      }
    }

  }
  if (digitalRead(2)==HIGH and sw1_allapot==1) {                     //már nem nyomja az 1-es nyomógombot
    sw1_allapot=0;
    if (millis()-sw1_time<800 and millis()-sw1_time>20) {            //ha 20ms-nél tovább nyomta, de kevesebb mint 800msec-ig, akkor léptetni kell
      leptet_fel=1;frissit=1;lcd.backlight();vilagitas_ido=millis(); //frissíteni kell, leptetni kell, bekapcsoljuk a háttérvilágítást, elindítjuk a világítás kikapcsolás időzítést
    }
  }  

  if (digitalRead(3)==LOW and sw2_allapot==0) {                      //megnyomtuk az 2-es gombot, indul az időzítés, hogy megtudjuk rövid vagy hosszú lenyomás lesz
    ism_tilt2=0;sw2_allapot=1;
    sw2_time=millis();vissza_time=millis();
  }                                        
  if (digitalRead(3)==LOW and sw2_time+800<millis() and sw2_allapot==1 and ism_tilt2==0) {      //ha hosszan nyomvatartotta, akkor üzemmódot váltunk, vagy üzemmódból visszalépünk
    lcd.backlight();vilagitas_ido=millis();                                                     //bekapcsoljuk a háttérvilágítást
    ism_tilt2=1;uzemmod=uzemmod+1;frissit=1;                                                    //üzemmód változót növeljük
    if (rogzites==1 and uzemmod>1) {uzemmod=0;}                                                 //ha rögzítésben vagyunk, akkor nem lehet törölni, paraméter állítani stb.
                                                                                                //csak az adatlekérdezést engedjük meg (1-es üzemmód)
    if (uzemmod==9) {uzemmod=0;}                                                                //8. üzemmód után újra 0 jön
    if (uzemmod==1) {leptet_le=1;kiolv_sorsz=1;sorosport=1;}                                    //ha adatlekérdezésbe kapcsoltunk, akkor kell egyetléptetni is, 
                                                                                                //ki kell küldeni a sorosportra az eddig rögzített adatokat (sorosport=1)
  }   
  if (digitalRead(3)==HIGH and sw2_allapot==1) {             //már nem nyomja a 2-es nyomógombot
    sw2_allapot=0;
    if (millis()-sw2_time<800 and millis()-sw2_time>20) {    //ha 20ms-nél tovább nyomta, de kevesebb mint 800msec-ig,
      lcd.backlight();vilagitas_ido=millis();                //bekapcsoljuk a háttérvilágítást
      leptet_le=1;frissit=1;                                 //leptetni kell és frissíteni a képernyőt
    }
    if (rogzites==0 and uzemmod==0) {                        //épp nem rögzítünk és 0. (aktuális mérési eredmények kijelzése)üzemmódban vagyunk
      fo_uzemmod++; if (fo_uzemmod>2) {fo_uzemmod=0;}        //váltani foguk minden gombnyomással a fő üzemmódot
      switch (fo_uzemmod) {
        case 0:                   //töltés
          digitalWrite(5,LOW);    //a relé így meg van húzva (töltés)
          break;
        case 1:                   //merítés
          digitalWrite(5,HIGH);   //a relé így nincs meghúzva (merítés)
          break;
        case 2:                   //ciklikus vizsgálat
          digitalWrite(5,LOW);    //a relé így meg van húzva (töltéssel kezdődik a ciklus)
          break;
      }
      leptet_le=0;frissit=1;      //végrehajtottuk amit kell töröljük a frissites és a leptet_le változót, hogy érzékelhessük a következő gombnyoást
    }
  }  

  if (millis()>vissza_time+10000 and uzemmod>1) {uzemmod=0;frissit=1;}   //legalább 10 másodperce nem nyúltunk nyomógombhoz, és nem 0 vagy 1 üzemmódban vagyunk
                                                                         //paraméter beállításból így 10 másodperc tétlenség után visszajutunk a folyamatos mérésbe
  if (millis()>vissza_time+20000 and uzemmod==1) {uzemmod=0;frissit=1;}   //legalább 20 másodperce nem nyúltunk nyomógombhoz, és nem 1-es üzemmódban vagyunk
                                                                         //adat megjelenítésből így 20 másodperc tétlenség után visszajutunk a folyamatos mérésbe

  if (rogzites==1 and fo_uzemmod!=2) {digitalWrite(4,LOW);}                     //elindítottuk a rögzítést, bekapcsoljuk a relét, mert nem ciklikus vizsgálat van
  if (rogzites==0 and fo_uzemmod!=2) {digitalWrite(4,HIGH);}                    //leállítottuk a rögzítést, bekapcsoljuk a relét, mert nem ciklikus vizsgálat van
  if (rogzites==1 and fo_uzemmod==2 and ciklus_fazis==0) {digitalWrite(4,LOW);} //ciklikus vizsgálat 0. fázisában a rögzítés indításakor bekapcsoljuk a relét 
                                                                                //(további fázisok majd kapcsolgatják amikor kell)

  //egy másodpercenként mérünk egyet, és növeljük a mérési időt
  if (millis()>millis_tmp+1000) {   //csak 1000ms után csinálunk mérést és kijelző frissítést
    millis_tmp=millis();
    //***************** Kiolvassuk az INA226-ból a sönt feszültség értéket *****************************
    Wire.beginTransmission(i2c_cim);  //megszólítjuk az eszközt
    Wire.write(0x01);                 //a sönt feszültség regisztert fogjuk olvasni
    Wire.endTransmission();           //kommunikáció lezárása
    Wire.requestFrom(i2c_cim,2);      //2 byte-ot várunk az INA226-tól (16 bites a regiszter)
    if(Wire.available()){             
      msByte=Wire.read();             //kiolvassuk az első byte-ot
      lsByte=Wire.read();             //kiolvassuk a második byte-ot
      sont_fesz=(msByte<<8)+lsByte;   //a két byte-ból csinálunk egy 16 bites számot, és ez az eredmény
      if (sont_fesz>=65530) {sont_fesz=0;}  //időnként hatalmas negatív értékeket adott vissza, ezt kiszűrtem, mert nyilván valamilyen rossz mérés eredménye
    }
    //***************** Kiolvassuk az INA226-ból a feszültség értéket *****************************
    Wire.beginTransmission(i2c_cim);  //megszólítjuk az eszközt
    Wire.write(0x02);                 //a Vbus feszültség regisztert fogjuk olvasni
    Wire.endTransmission();           //kommunikáció lezárása
    Wire.requestFrom(i2c_cim,2);      //2 byte-ot várunk az INA226-tól (16 bites a regiszter)
    if(Wire.available()){
      msByte=Wire.read();             //kiolvassuk az első byte-ot
      lsByte=Wire.read();             //kiolvassuk a második byte-ot
      fesz=(msByte<<8)+lsByte;        //a két byte-ból csinálunk egy 16 bites számot, és ez az eredmény
    }
    
    if (uzemmod==0 or uzemmod==2) {frissit=1;}                        //frissíteni kell a képernyőt, mert új adatok vannak csak ha az uzemmód 0 (kijelezzük a mért eredményt)
                                                                      //vagy ha az uzemmód 2 (törlés), mert utóbbi esetben másodperces visszaszámláláshoz kell a frissítés
    EEPROM.get(24,xadat_int);                             //feszültségszorzó (korrekció) tárolt értékének kiolvasása az eeprom-ból

    pill_fesz=round(((float)fesz*1.25*xadat_int)/10000);  //három tizedesjegy pontosságra kerekítem, és szorzom 1000-el, 
                                                          //így egy integer-ben kapom meg a feszültséget. Megjelenítés előtt 
                                                          //1000-el osztani kell majd, tároláshoz pont megfelelő

    EEPROM.get(26,xadat_int);                                                //áramszorzó (korrekció) tárolt értékének kiolvasása az eepromból
    pill_aram=round((float)sont_fesz*0.00025*(xadat_int/10)+(nullazas*10));  //pillanatnyiáram mA tízszeresében, hogy egy tizedesjegy pontossággal
                                                                             //tároljam. Megjelenítéskor 10-el osztani kell

    //**************************** teendők rögzítés alatt *********************************************
    if (rogzites==1) {                                    
      ido=ido+1;                                          //csak rögzítéskor növeljük az eltelt időt
      akku_kapacitas=akku_kapacitas+(long)(pill_aram);    //itt osztani kellene az áram mA értéket 3600-al (így lenne mAh a mértékegység) 
                                                          //de a float pontossága miatt nem itt célszerű, hanem a kijelzésnél illetve a tárolásnál, hogy 
                                                          //nagyobb számokkal dolgozzak és ne okozzon hibát. Az akku kapacitást double típusban gyűjtöm, 
                                                          //mert így igen nagy értékeket is kaphatok
                                          
      if (abs(utolso_fesz-pill_fesz)>fesz_lepeskoz) {
        adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat mert a lépésköznél nagyobb mértékben változott a feszültség
        utolso_fesz=pill_fesz;
      }
      if (pill_fesz>fesz_max and fo_uzemmod==0) {                        //kilépünk a töltésből, ha a feszültség nagyobb mint a megengedett maximum
        adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat, mert vége a töltésnek
        utolso_fesz=pill_fesz;
        rogzites=0;                                                      //leállítjuk a töltést
      }   
      if (pill_fesz<fesz_min and fo_uzemmod==1) {                        //kilépünk a merítésből, ha a feszültség kisebb mint a megengedett minimum
        adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat, mert vége a merítésnek
        utolso_fesz=pill_fesz;
        rogzites=0;                                                      //leállítjuk a merítést
      }   
      //************** ciklikus töltés teendői rögzítés alatt (fázisok váltása, relék vezérlése, várakozások ********************************
      if (fo_uzemmod==2 and (ciklus_fazis==1 or ciklus_fazis==3 or ciklus_fazis==5 or ciklus_fazis==7 or ciklus_fazis==9 or ciklus_fazis==11)) {   //varakozási cilusban vagyunk, várjuk a végét
        varakozas++;
        if (varakozas>600) {                                               //vége a várakozásnak, letelt a 10 perc akku pihentetés
          adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat, mert vége a töltésnek
          utolso_fesz=pill_fesz;
          ciklus_fazis++;
          digitalWrite(4,LOW);
          varakozas=0;
          ido=0;
        }
      }

      if (pill_fesz>fesz_max and fo_uzemmod==2 and (ciklus_fazis==0 or ciklus_fazis==4 or ciklus_fazis==8)) {    //kilépünk a töltési ciklusból, ha a feszültség nagyobb mint a megengedett maximum
        adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat, mert vége a töltésnek
        utolso_fesz=pill_fesz;
        switch (ciklus_fazis) {
          case 4:
            EEPROM.put(1010,(int)(akku_kapacitas/3600));   //töltési szumma adat regisztrálása
            break;
          case 8:
            EEPROM.put(1012,(int)(akku_kapacitas/3600));   //töltési szumma adat regisztrálása
            break;
        }
        digitalWrite(5,HIGH);   //a relé így meghúzva (merítés)
        ciklus_fazis++;
        akku_kapacitas=0;
        ido=0;
        digitalWrite(4,HIGH);
      }   
      if (pill_fesz<fesz_min and fo_uzemmod==2 and (ciklus_fazis==2 or ciklus_fazis==6 or ciklus_fazis==10)) {    //kilépünk a merítési ciklusból, ha a feszültség kisebb mint a megengedett minimum
        adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat, mert vége a merítésnek
        utolso_fesz=pill_fesz;
        switch (ciklus_fazis) {
          case 2:
            EEPROM.put(1016,(int)(akku_kapacitas/3600));   //töltési szumma adat regisztrálása
            break;
          case 6:
            EEPROM.put(1018,(int)(akku_kapacitas/3600));   //töltési szumma adat regisztrálása
            break;
          case 10:
            EEPROM.put(1020,(int)(akku_kapacitas/3600));   //töltési szumma adat regisztrálása
            break;
        }
        digitalWrite(5,LOW);                               //a relé így nincs meghúzva (töltés)
        ciklus_fazis++;
        akku_kapacitas=0;
        ido=0;
        digitalWrite(4,HIGH);
      }   
      if (pill_fesz>fesz_max and fo_uzemmod==2 and ciklus_fazis==12) {   //kilépünk a töltésből, ha a feszültség nagyobb mint a megengedett maximum
        adat_iras(pill_fesz,pill_aram,(int)(akku_kapacitas/3600),ido);   //tároljuk az adatokat, mert vége a töltésnek
        utolso_fesz=pill_fesz;
        EEPROM.put(1014,(int)(akku_kapacitas/3600));                     //töltési szumma adat regisztrálása
        rogzites=0;
        digitalWrite(4,HIGH);
      }   
    } 
  }
  /*****************************************************************************************************************************
   *  Ebben a programrészben a frissit változó egy értéke esetén újra írjuk a képernyőre az aktuális adatokat.                 *
   *  Az aktulális adat minden üzemmódban más. 0. üzemmódban a mérési eredményeket frissítjük                                  *
   *                                           1. üzemmódban fel le léptethetjük a rögzített adatokat (eeprom-ból)             *
   *                                           2. üzemmódban törölhetjük az adatokat (5 másodperc biztonsági várakozással      *
   *                                           3. üzemmódban beállíthatjuk a merítés minimális akku feszültségét (minden       *
   *                                                                  gombnyomással változik a feszültség értéke)              *
   *                                           4. üzemmódban beállíthatjuk a töltés maximális akku feszültségét (minden        *
   *                                                                  gombnyomással változik a feszültség értéke)              *
   *                                           5. üzemmódban beállíthatunk egy feszültség szorzót, amivel hitelesíthetjük      *
   *                                                                  a mért akkumulátor feszültséget. Megmérjük a             *
   *                                                                  tényleges feszültséget, és az INA226 által mért          *
   *                                                                  feszültséget szorozhatjuk az itt beállított számmal      *
   *                                           6. üzemmódban beállíthatunk egy áram szorzót, amivel hitelesíthetjük            *
   *                                                                  a mért áramot. Megmérjük a tényleges áramot, és az       *
   *                                                                  INA226 által mért söntfeszültség és sötellenállás        *
   *                                                                  szorzatából számolt feszültséget ezzel a számmal         *
   *                                                                  szorozhatjuk, hogy a mért és számított áram megegyezzen  *
   *                                           7. üzemmódban beállíthatunk egy nulla áramot. Azt tapasztaltam, hogy amikor     *
   *                                                                  nem folyik át áram a söntellenálláson, akkor is mér az   *
   *                                                                  INA226 egy kicsi söntfeszültséget, ami esetemben kb.     *
   *                                                                  -0.15mA-nek adódott. Ezt lehet egy itt beállítható       *
   *                                                                  értékkel nullázni működés közben                         *
   *                                           8. üzemmódban beállíthatjuk, hogy hány részre bontsuk fel az akku induló        *
   *                                                                  feszültsége és a végfeszültsége közötti tartományt. Ha   *
   *                                                                  mérünk, és az előző regisztrált adat óta nagyobb volt    *
   *                                                                  a feszültség változás, akkor újra regisztrálunk.         *
   *  Az üzemmódok a 2-es nyomógomb hosszú megnyomásával lehet váltani. Az üzemmódokban csak akkor 0kerül a program ezekre     *
   *  a programrészekre, ha a frissit változót 1-re állítja egy gombnyomás, vagy egy mérés. A 0. üzemmódban a mérés            *
   *  generálja a frissítést, a többi üzemmódban a gombnyomások. Az egyszerűség érdekében a gombnyomások az adott értéket      *
   *  Azonnal meg is növelik vagy csökkentik, és az új érték kijelzésre kerül. Tehát az adott EEPROM cellákat minden           *
   *  paraméter állítás írja, az érték azonnal tárolódik is. Egy paramétert csak 100.000-szer változtathatunk meg!             *
   *  Az adat törlés üzemmód kicsit más, mert itt a rövid gombnyomásból eredő véletlen törlést egy visszaszámlálással          *
   *  akadályoztam meg. A visszaszámlálás alatt megszakítható a törlés. A visszaszámláláshoz az egy másodperces mérés          *
   *  időpontjai indítanak a frissit változó 1-re állításával, tehát itt nem csak a gombnyomás akciózik.                       *
   *  A mérések és az esetleges adat regisztrálás az 1-es üzemmódban történő regisztrált adat megtekintés közben is            *
   *  zavartalanul folyik tovább, mert a loop folyamatosan fut, nincs sehol delay().                                           *
   *****************************************************************************************************************************/
  
  if (frissit==1) {
   frissit=0;  //akkor frissítünk, ha mérés történik, vagy lenyomtuk valamelyik nyomógombot (a frissit változót méréskor vagy gombnyomáskor 1-re állítjuk)
   switch (uzemmod) {
      case 0:
        frissit=0;                                      //miután megtörtént a kijelzés frissítése vagy a paraméter változtatása, ezzel akadályozzuk meg, 
                                                        //hogy a következő loop ciklusban újra elinduljon 
//        if (leptet_le==1) {uzemmod=1;break;}           //Ha röviden megnyomta 
        if (leptet_fel==1) {uzemmod=1;break;}            //Ha röviden megnyomta a 1-es nyomógombot (Start), akkor átváltunk regisztrált adat megtekintés üzemmódba
                                                        //(a 2-es a nyomógombnak (Mód) a hosszú lenyomása is ugyanebbe az üzemmódba visz)
        lcd.setCursor(0,0);
        switch (fo_uzemmod) {                           //kijelezzük, hogy milyen fő üzemmódban vagyunk (töltés, merítés, ciklikus vizsgálat)
          case 0:
            lcd_uniprint((String)F("Töltés              "));break;
          case 1:
            lcd_uniprint((String)F("Merítés             "));break;
          case 2:
            lcd_uniprint((String)F("Ciklikus vizsgálat  "));break;
        }
        //kezelési segtség egy sorban, illetve státus kijelzés
        lcd.setCursor(0,1);
        if (fo_uzemmod==2) {
          if (rogzites==0) {lcd_uniprint((String)F("Indít:+ Mód:- (1sec)"));}
          else {
            lcd_uniprint((String)F("Ciklus:             "));
            lcd.setCursor(8,1);
            lcd.print(ciklus_fazis);
          }
        }
        else {
          if (rogzites==0) {lcd_uniprint((String)F("Indít:+ Mód:- (1sec)"));}
          else {lcd_uniprint((String)F("Elindítva:          "));}
        }
        //idő átszámítása másodpercről óra, percre másodperc-re
        ido_tmp=ido;
        ora=ido_tmp/3600;
        ido_tmp=ido_tmp-ora*3600;
        perc=ido_tmp/60;
        masodperc=ido_tmp-perc*60;
        lcd.setCursor(0,2);
        if (ora<10) {lcd.print("0");lcd.print(ora);} else {lcd.print(ora);};lcd.print(":");
        if (perc<10) {lcd.print("0");lcd.print(perc);} else {lcd.print(perc);};lcd.print(":");
        if (masodperc<10) {lcd.print("0");lcd.print(masodperc);} else {lcd.print(masodperc);};lcd.print(" ");
        mAh=(float)akku_kapacitas/36000;  //mivel mA-másodperc mértékegységben van, osztani kell 3600-al, hogy mAh-ban legyen
                                          //és még 10-el, mert egy tizedes pontossággal összegeztem az áramot, így ez is 10-szeres érték
        lcd_uniprint(mAh,7,0);                       //akku kapacitás kijelzése
        lcd.print("mAh");  
        lcd.setCursor(0,3);                                       
        lcd_uniprint((float)pill_fesz/1000,6,3);     //Vbusz feszültség kiírása
        lcd.print("V");            
        lcd_uniprint((float)pill_aram/10,10,1);      //söntáram kijelzése 
        lcd.print("mA");  
        leptet_fel=0;leptet_le=0;
        break;
    case 1:
      if (sorosport==1) {           //ha hosszú gombnyomással (Mód gomb) léptünk a regisztrált adatok megjelenítésébe
                                    //akkor a soros portra is kiírjuk a regisztrált adatokat. Innen tovább lehet másolni pl. excel-be.
                                    //Az adatok ";"-vel vannak elválasztva, ez CSV formátum, amit az Exvel meg tud nyitni.
        sorosport=0;
        akt_sorsz=0;
        //az adot kiírásakor nem használok ékezetes betűket, mert az Excel nem tudja helyesen beolvasni alapból
        Serial.println(F("Beallitasok:"));
        Serial.print(F("Feszultseg hatar:"));
        Serial.print((float)fesz_min/1000,1);
        Serial.print(F(" - "));
        Serial.print((float)fesz_max/1000,1);
        Serial.println(" V");
        Serial.print(F("Feszultseg felbontas (reg. szint):"));
        Serial.print((float)fesz_lepeskoz/1000,3);
        Serial.println(" V");
        Serial.println(F("Vizsgalati osszefoglalo adatok (csak ciklikus vizsgalatnal):"));
        //ezekt az adatokat csak ciklikus vizsgálatnál töltöm fel, így csak egy teljesen végigfuttatott
        //ciklikus vizsgálatnál van bennük helyes adat, egyébként nem szabad vele foglalkozni.
        EEPROM.get(1016,xadat_int);
        Serial.print("Merites (1):");Serial.print((float)xadat_int/10,1);Serial.println("mAh");
        EEPROM.get(1010,xadat_int);
        Serial.print("Toltes (1):");Serial.print((float)xadat_int/10,1);Serial.println("mAh");
        EEPROM.get(1018,xadat_int);
        Serial.print("Merites (2):");Serial.print((float)xadat_int/10,1);Serial.println("mAh");
        EEPROM.get(1012,xadat_int);
        Serial.print("Toltes (2):");Serial.print((float)xadat_int/10,1);Serial.println("mAh");
        EEPROM.get(1020,xadat_int);
        Serial.print("Merites (3):");Serial.print((float)xadat_int/10,1);Serial.println("mAh");
        EEPROM.get(1010,xadat_int);
        Serial.print("Toltes (3):");Serial.print((float)xadat_int/10,1);Serial.println("mAh");
        Serial.println(F("Regisztralt adatok:"));
        Serial.println(F("Ido (perc);Feszultseg (V);Aram (mA);Kapacitas (mAh);"));
        do {
          EEPROM.get(akt_sorsz*8+32,xfesz);
          EEPROM.get(akt_sorsz*8+34,xaram);
          EEPROM.get(akt_sorsz*8+36,xmAh);
          EEPROM.get(akt_sorsz*8+38,xido);
          if (xfesz!=0 or xaram!=0 or xmAh!=0 or xido!=0) {   //az utolsó 0-as rekordot nem kell megjeleníteni
            Serial.print(xido/60);Serial.print(";");
            Serial.print((float)xfesz/1000,3);Serial.print(";");
            Serial.print((float)xaram/10,1);Serial.print(";");
            Serial.print((float)xmAh/10,1);Serial.println(";");
          }
          akt_sorsz++;
        } while (xfesz!=0 or xaram!=0 or xmAh!=0 or xido!=0);
      }
      
      /******************** Ezek a részek már nem a sorosportra íráshoz tartoznak, ezek az adatmegjelenítést, léptetést végzik *************/
      if (leptet_fel==1 and kiolv_sorsz<121) {      //Az 1-es gombot (Start) nyomta meg röviden, kijelezzük a következő kiolvasott adatot.
                                                    //Maximum 121 adatrekord lehet, ennél nem lehet több a kiolvasandó rekord sorszáma
        kiolv_sorsz++;                              //növeljük az aktuális adatrekord sorszámát (amit ki szeretnénk jelezni)
      }
      if (leptet_le==1 and kiolv_sorsz>=1) {        //Az 2-es gombot (Mód) nyomta meg röviden, kijelezzük a következő kiolvasott adatot
        if (kiolv_sorsz>1) {kiolv_sorsz--;}         //csökkentjük az aktuális adatrekord sorszámát (amit ki szeretnénk jelezni)
      }
      if (leptet_fel==1 or leptet_le==1) {          //mivel gombnyomás történt, változott a kiolv_sorsz változó (fentebb), frissítjük a képernyőt
        
        //megkeressük a szükséges rekordot és kiolvassuk az adatait
        //A kiolv_sorsz változót növelik vagy csökkentik a gombnyomások
        //és a ciklus megáll annál a rekordnál, aminek a sorszáma egyezik ezzel a változóval.
        akt_sorsz=0;
        do {
          EEPROM.get(akt_sorsz*8+32,xfesz);
          EEPROM.get(akt_sorsz*8+34,xaram);
          EEPROM.get(akt_sorsz*8+36,xmAh);
          EEPROM.get(akt_sorsz*8+38,xido);
          if (xfesz==0 and xaram==0 and xmAh==0 and xido==0) {kiolv_sorsz=akt_sorsz;break;}
          akt_sorsz++;
          if (akt_sorsz==kiolv_sorsz) {break;}
          yfesz=xfesz;yaram=xaram;ymAh=xmAh;yido=xido;
        } while (xfesz!=0 or xaram!=0 or xmAh!=0 or xido!=0);
        
        //kiírjuk a képernyőre a megtalált rekord adatait
        lcd.clear();
        lcd.setCursor(0,0);                        
        lcd_uniprint((String)F("Adatok lekérdezése: "));

        if (akt_sorsz==0) {             //ha rögtön az első rekord négy 0-át tartalmaz, akkor nincsenek adatok
          lcd.setCursor(0,2);                        
          lcd_uniprint((String)F("Nincs rögzített adat!"));
        }
        else {
          //itt következik egy adatrekord megjelenítése a képernyőn
          ido_tmp=yido;
          ora=ido_tmp/3600;
          ido_tmp=ido_tmp-ora*3600;
          perc=ido_tmp/60;
          ido_tmp=ido_tmp-perc*60;
          masodperc=ido_tmp;
          lcd.setCursor(0,1);                        
          lcd_uniprint((String)F("Sorszám:"));lcd.print(kiolv_sorsz);lcd.print(" ");
          if (ora<10) {lcd.print("0");lcd.print(ora);} else {lcd.print(ora);};lcd.print(":");
          if (perc<10) {lcd.print("0");lcd.print(perc);} else {lcd.print(perc);};lcd.print(":");
          if (masodperc<10) {lcd.print("0");lcd.print(masodperc);} else {lcd.print(masodperc);};lcd.print("  ");
          lcd.setCursor(0,2); 
          lcd.print((float)yfesz/1000,3);lcd.print("V ");lcd.print((float)yaram/10,1);lcd.print("mA");
          lcd.setCursor(0,3); 
          lcd.print((float)ymAh/10,1);lcd.print("mAh");
        }
      }
      leptet_fel=0;leptet_le=0;              //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 2:
      frissit=0;                             //akkor frissítünk, ha újra lezajlik egy mérés! Ha az üzemmód 0 vagy 2, 
                                             //akkor a méréskor (másodpercenként) 1-re állítjuk a frissit változót
      lcd.setCursor(0,0);                        
      lcd_uniprint((String)F("Tárolt adat törlés! "));
      if (torl_kesl==6) {
        lcd.setCursor(0,1);                        
        lcd_uniprint((String)F("   Gombnyomással    "));
        lcd.setCursor(0,2);                        
        lcd_uniprint((String)F("     Indítható!     "));
        lcd.setCursor(0,3);                        
        lcd_uniprint((String)F("                    "));
      }
      if (leptet_fel==1 or leptet_le==1) {    //megnyomtuk valamelyik nyomógombot
        //leptet_fel=0;leptet_le=0;
        if (torl_kesl<5) {                    //meg visszaszámlálás közben vagyunk, tehát a gombnyomás megszakítja a törlést
          lcd.setCursor(0,1);                        
          lcd_uniprint((String)F("                    "));
          lcd.setCursor(0,2);                        
          lcd_uniprint((String)F("Nem történt törlés! "));
          lcd.setCursor(0,3);                        
          lcd_uniprint((String)F("                    "));
          delay(3000);
          lcd.clear();
          torl_kesl=6;uzemmod=0;leptet_fel=0;leptet_le=0;break;
        }
        torl_kesl=0;                          //meg nem indult el a visszaszámlálás, tehát elindítjuk (törlést akarunk 5 sec meggondolási idővel)
      }
      if (torl_kesl<6) {                      //elindult a törlési visszaszámlálás (mert a változó kisebb mint 6)
        lcd.setCursor(0,1);                        
        lcd_uniprint((String)F("Törlés "));lcd.print(5-torl_kesl);lcd_uniprint((String)F(" sec múlva! "));
        lcd.setCursor(0,2);                        
        lcd_uniprint((String)F("Dombnyomással       "));
        lcd.setCursor(0,3);                        
        lcd_uniprint((String)F("      megszakítható!"));
        torl_kesl++;
        if (torl_kesl==5) {                   //5-ig elszámolt, közben nem volt gombnyomás, tehát törlünk
          EEPROM.put(14,(unsigned int) 0);    //töltés vagy merítés eddig regisztrált ideje (sec)
          EEPROM.put(16,(long) 0);            //törlés vagy merítés eddig regisztrált kapacitása (mAh)
          ido=0;akku_kapacitas=0;
          EEPROM.put(32,(unsigned int) 0);    //az adatterület 0. rekordja 0, azaz nincs adat
          EEPROM.put(34,(unsigned int) 0);
          EEPROM.put(36,(unsigned int) 0);
          EEPROM.put(38,(unsigned int) 0);
          lcd.setCursor(0,1);                        
          lcd_uniprint((String)F("                    "));
          lcd.setCursor(0,2);                        
          lcd_uniprint((String)F("   Adatok törölve!  "));
          lcd.setCursor(0,3);                        
          lcd_uniprint((String)F("                    "));
          delay(3000);
          utolso_fesz=0;                      //így a regisztrálás indításakor biztosan rögzít egyet.
          lcd.clear();
          torl_kesl=6;uzemmod=0;leptet_fel=0;leptet_le=0;break;
        }
      }
      leptet_fel=0;leptet_le=0;               //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 3:
      //ennnél a feszültségnél fog kikapcsolni a berendezés merítés közben, ha az akku feszültsége ennél kissebbé válik.
      //Merítés üzemmódban ez a vizsgálat végét jelenti (megszakítjuk az akku áramkörét egy relével)
      //Ciklikus vizsgálat esetén ekkor várunk 10 percet, és a következő töltési ciklussal folytatjuk.
      //Egy lithium akkunál ez kb. 2.5V feszültséget jelent. Pl. egy ólomakkumulátornál 6V (6 cellás autó akkumulátor)
      lcd.setCursor(0,0); 
      lcd_uniprint((String)F("A merítés kikapcso- "));
      lcd.setCursor(0,1);                        
      lcd_uniprint((String)F("lási végfeszültsége."));
      lcd.setCursor(0,2);                        
      lcd_uniprint((String)F("                    "));
      lcd.setCursor(0,3);                        
      lcd_uniprint((String)F("+,-  tovább:1sec (-)"));
      EEPROM.get(20,xadat_int);
      if (leptet_fel==1 and xadat_int<30000) {EEPROM.put(20,xadat_int+100);}
      if (leptet_le==1 and xadat_int>500) {EEPROM.put(20,xadat_int-100);}
      EEPROM.get(20,xadat_int);
      fesz_min=xadat_int;
      lcd.setCursor(15,2);                        
      lcd.print((float)fesz_min/1000,2);
      lcd.print("V");
      leptet_fel=0;leptet_le=0;               //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 4:
      //ennnél a feszültségnél fog kikapcsolni a berendezés töltés közben, ha az akku feszültsége ennél nagyobbá válik.
      //Töltés üzemmódban ez a vizsgálat végét jelenti (megszakítjuk az akkui áramkörét egy relével)
      //Ciklikus vizsgálat esetén ekkor várunk 10 percet, és a következő merítési ciklussal folytatjuk.
      //Egy lithium akkunál ez kb. 4.2V feszültséget jelent. Pl. egy ólomakkumulátornál 14.4V (6 cellás autó akkumulátor)
      lcd.setCursor(0,0);                        
      lcd_uniprint((String)F("A töltés kikapcso-  "));
      lcd.setCursor(0,1);                        
      lcd_uniprint((String)F("lási végfeszültsége."));
      lcd.setCursor(0,2);                        
      lcd_uniprint((String)F("                    "));
      lcd.setCursor(0,3);                        
      lcd_uniprint((String)F("+,-  tovább:1sec (-)"));
      EEPROM.get(22,xadat_int);
      if (leptet_fel==1 and xadat_int<30000) {EEPROM.put(22,xadat_int+100);}
      if (leptet_le==1 and xadat_int>1000) {EEPROM.put(22,xadat_int-100);}
      EEPROM.get(22,xadat_int);
      fesz_max=xadat_int;
      lcd.setCursor(15,2);                        
      lcd.print((float)fesz_max/1000,2);
      lcd.print("V");
      leptet_fel=0;leptet_le=0;              //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 5:
      //Feszültség korrekció.
      //a mért buszfeszültségből (akku feszültsége) kiszámított feszültséget lehet ezzel a számmal korrigálni.
      //Értéke 8000-13000-ig állítható, ami 0,8-1,3-al történő szorzást jelent. 
      //Az én INA226 példányom esetén ~5V USB tápfesznél 0,9526-al kellett szorozni.
      //Úgy számoltam ki, hogy megmértem a legpontosabb műszeremmel az akku feszültségét (nem töltöttem és nem is merítettem közben az akkut)
      //és a kijelző által mutatott feszültség értéket elosztottam a valós mért feszültséggel. Persze úgy is lehet, hogy addig állítgatjuk ennek 
      //a paraméternek az értékét amíg a mért és mutatott feszültség megegyezik!
      lcd.setCursor(0,0);                        
      lcd_uniprint((String)F(" A feszültségmérés  "));
      lcd.setCursor(0,1);                       
      lcd_uniprint((String)F(" hiteles értékéhez  "));
      lcd.setCursor(0,2);                        
      lcd_uniprint((String)F(" szüks. korrekció!  "));
      lcd.setCursor(0,3);                        
      lcd_uniprint((String)F("                    "));
      EEPROM.get(24,xadat_int);
      if (leptet_fel==1 and xadat_int<13000) {EEPROM.put(24,xadat_int+1);}
      if (leptet_le==1 and xadat_int>8000) {EEPROM.put(24,xadat_int-1);}
      lcd.setCursor(0,3);                        
      EEPROM.get(24,xadat_int);
      lcd_uniprint((float)xadat_int/10000,6,4);lcd.print("*V   +,-,1sec-");
      leptet_fel=0;leptet_le=0;              //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 6:
      //Áram korrekció.
      //a mért söntfeszültségből kiszámított áramot lehet ezzel a számmal korrigálni.
      //Értéke 8000-13000-ig állítható, ami 0,8-1,3-al történő szorzást jelent. 
      //Az én INA226 példányom esetén ~5V USB tápfesznél 1,19-el kellett szorozni.
      //Úgy számoltam ki, hogy megmértem a legpontosabb műszeremmel az áramot (sorba kötve az akkuval töltés közben, áramgenerátoros töltési állapotban)
      //és a kijelző által mutatott áram értéket elosztottam a valós mért árammal. Persze úgy is lehet, hogy addig állítgatjuk ennek a paraméternek az értékét
      //amíg a mért és mutatott áram megegyezik!
      lcd.setCursor(0,0);                        
      lcd_uniprint((String)F("   Az árammérés     "));
      lcd.setCursor(0,1);                       
      lcd_uniprint((String)F(" hiteles értékéhez  "));
      lcd.setCursor(0,2);                        
      lcd_uniprint((String)F(" szüks. korrekció!  "));
      lcd.setCursor(0,3);                        
      lcd_uniprint((String)F("                    "));
      EEPROM.get(26,xadat_int);
      if (leptet_fel==1 and xadat_int<13000) {EEPROM.put(26,xadat_int+1);}
      if (leptet_le==1 and xadat_int>8000) {EEPROM.put(26,xadat_int-1);}
      EEPROM.get(26,xadat_int);
      lcd.setCursor(0,3);                        
      lcd_uniprint((float)xadat_int/10000,6,4);lcd.print("*mA  +,-,1sec-");
      leptet_fel=0;leptet_le=0;               //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 7:
      //áram nullázás beállítása (-200 és 200 között állítható, ami +/- 2mA korrekciót eredményez)
      //Az én INA226 példányomnak +0,15mA korrekcióra volt szüksége (~5V USB-ről kapott tápfeszültség esetén)
      lcd.setCursor(0,0);                        
      lcd_uniprint((String)F("Árammentes állapot- "));
      lcd.setCursor(0,1);                       
      lcd_uniprint((String)F("ban 0 áramhoz szüks."));
      lcd.setCursor(0,2);                        
      lcd_uniprint((String)F("előjeles áram korr.!"));
      lcd.setCursor(0,3);                        
      lcd_uniprint((String)F("                    "));
      EEPROM.get(28,xadat_int);
      if (leptet_fel==1 and xadat_int<200) {EEPROM.put(28,xadat_int+1);}
      if (leptet_le==1 and xadat_int>-200) {EEPROM.put(28,xadat_int-1);}
      EEPROM.get(28,xadat_int);
      lcd.setCursor(0,3);                        
      lcd.print((float)xadat_int/100,2);lcd.print("mA     +,-,1sec-");
      nullazas=(float)xadat_int/100;
      leptet_fel=0;leptet_le=0;                //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    case 8:
      //töltés közbeni regisztrálások száma (5 és 40 között beállítható)
      lcd.setCursor(0,0);    
      lcd_uniprint((String)F("Töltés vagy merítés "));
      lcd.setCursor(0,1);   
      lcd_uniprint((String)F(" közben regisztrált "));
      lcd.setCursor(0,2); 
      lcd_uniprint((String)F(" adatok darabszáma. "));
      lcd.setCursor(0,3);                        
      EEPROM.get(30,xadat_int);
      if (leptet_fel==1 and xadat_int<40) {EEPROM.put(30,xadat_int+1);}
      if (leptet_le==1 and xadat_int>5) {EEPROM.put(30,xadat_int-1);}
      EEPROM.get(30,xadat_int);
      lcd.setCursor(0,3);                        
      lcd.print(xadat_int);lcd_uniprint((String)"db       +,-,1sec-");
      fesz_felbontas=xadat_int;
      fesz_lepeskoz=(fesz_max-fesz_min)/fesz_felbontas;
      leptet_fel=0;leptet_le=0;                //így gombnyomásonként csak egyszer megyünk bele ebbe a programrészbe
      break;
    }
  }
}

int adat_iras(int xfesz, int xaram, int xmAh, unsigned int xido)
{
  //első üres hely keresése (mind a négy cella 0
  byte rekordszam=0;
  int akt_cim=24;                         //ez a legelső adatrekord kezdetéhez
  int akt_fesz,akt_aram,akt_mAh;  //csak azért kellenek, hogy megkeressük a legutolsó adatrekordot
                                          //ha mind a négy változóba 0 érték kerül, akkor ez előző volt az utolsó adatrekord
  unsigned int akt_ido;
  do {
    akt_cim=akt_cim+8;
    EEPROM.get(akt_cim,akt_fesz);
    EEPROM.get(akt_cim+2,akt_aram);
    EEPROM.get(akt_cim+4,akt_mAh);
    EEPROM.get(akt_cim+6,akt_ido);
    if (akt_cim>992) {return 0;}          //ha megtelt az EEPROM, akkor 0-val térünk vissza
                                          //Jelenleg a programban nem kezelem azt az esetet, ha megtelt az EEPROM
                                          //lehetne ezt is figyelni, de nem volt lényeges, mert a ciklikus vizsgálatnál
                                          //is elférek, ha 13-ra állítom a felbontást. Tapasztalatom szerint a 13 bővenelegendő
                                          //egy látványos Excel grafikon rajzolásához. 
    rekordszam++;
  } while (akt_fesz!=0 or akt_aram !=0 or akt_mAh!=0 or akt_ido!=0);
  EEPROM.put(akt_cim,xfesz);
  EEPROM.put(akt_cim+2,xaram);
  EEPROM.put(akt_cim+4,xmAh);
  EEPROM.put(akt_cim+6,xido);
  akt_cim=akt_cim+8;
  EEPROM.put(akt_cim,0);
  EEPROM.put(akt_cim+2,0);
  EEPROM.put(akt_cim+4,0);
  EEPROM.put(akt_cim+6,0);
  Serial.print("Tárolás (");Serial.print(rekordszam);Serial.print("):");Serial.print(ido);Serial.print("sec ");
  Serial.print((float)xfesz/100,3);Serial.print("V ");
  Serial.print((float)xaram/100,1);Serial.print("mA ");
  Serial.print((float)akku_kapacitas/36000,1);Serial.println("mAh");   //mivel integerként kapom meg ezt az adatot és mAh/másodperc mértékegységben,
                                                                       //kijelzés előtt osztani kell 3600-al, hogy mAh legyen, és még 10-el, hogy
                                                                       //egy tizedes pontossággal lehessen kijelezni
  return rekordszam;                      //ha sikerült az írás, akkor a rekord sorszámmal térünk vissza
}



/**************************************************************************************************************************************************************************
 * lcd_uniprint() függvény:                                                                                                                                               *
 *   Az alább részletezett függvény formázottan ír ki adatok lcd kijelzőre. Az lcd kijelzőt a programban a megszokott módon kell inicializálni, a kijelző hivatkozási     *
 *   neve kötelezően "lcd". Ha más névre van szükség, akkor a legutolsó függvény változatban át kell írni az lcd.print() függvényben az előtagot.                         *
 *   Két LCD kijelzőt nem kezel, ahhoz vagy a függvényeket kell megduplázni más néven, vagy új paramétert kell bevezetni, és belül kiválasztani a kijelzőt.               *
 *                                                                                                                                                                        *
 * Ékezetes szöveg írása LCD kijelzőre: lcd_uniprint( (String) szöveg);                                                                                                   *
 *    - Paraméter egy tetszőlegesen ékezetes betűket is tartalmazó string típusú változó, vagy szöveg "" között                                                           *
 *      Sajnos ha idézőjelek között direktben adjuk meg a stringet, akkor azt nem String-nek tekinti, és rossz függvény változatot hív meg, ezért konvertálni kell        *
 *      a (String) konverzióval, amit az időzőjelekkel megadott string elé kell beírni. Ha string típusú változót adunk meg paraméterként, akkor rendesen működik         *
 *      pl.:lcd_uniprint((String)"Nagy:ÁÉÍÓÖŐÚÜŰ");                                                                                                                       *
 * Float típusú számadat, beállítható tizedesjegy számmal és minimális hosszal: lcd_uniprint( (float) szám, minimális hossz, tizedesek száma);                            *
 *    - Az első paraméter egy float típusú, tizedes jegyeket tartalmazó szám. Amennyiben nem float típusú, akkor elé kell írni (float), hogy mindenképpen float legyen    *
 *      különben nem tudja meghívni a hozzá tartozó lcd_uniprint() függvényt meghívni, ami float típusú paramétert vár.                                                   *
 *    - Második paraméter a megjelenített szám minimális hossza a tizedesjegyekkel és a tizedesponttal együtt. Ha nem kell tizedespont, akkor (long)-ot kell elé írni     *
 *      és az előző függvényváltozat fogja kiírni az adatot. Ha a számadat hosszabb mint ez a megadott érték, akkor a kiírt adat is több helyet igényel.                  *
 *      Ha a minimális hossz értéke 0, akkor pont annyi helyre fogja kiírni a számot, amennyit igényel.                                                                   *
 *    - harmadik paraméter a tizedesjegyek száma.                                                                                                                         *
 *      pl.:lcd_uniprint(float_ertek_minusz,8,4);                                                                                                                         *
 *                                                                                                                                                                        *
 *Szükséges könyvtárak és beállítások a programban:                                                                                                                       *
 * #include <Wire.h>    //I2C library                                                                                                                                     *
 * #include <LiquidCrystal_I2C.h>                                  //I2C LCD kezelő könyvtár                                                                              *
 * LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);  //LCD paraméterek megadása, ez most 2x16 karakteres kijelző                                            *
 **************************************************************************************************************************************************************************/


void lcd_uniprint(long szam, byte min_fix_hossz) {
/*************************************************************************************************  
Ez a függvény akkor hívódik meg, ha az első paraméter Long típusú és még egy Byte típusú         *
paraméter lett megadva. A megkapott Long típusú számot a Byte típusú változóval megadott         *
minimális hosszban megadott karakterszámon írja ki. Ha a második paraméter nulla, akkor a        *
számjegyek igényelt hosszának megfelelő helyet fog foglalni. Ha a számjegyek száma nagyobb, mint *
a megadott minimum, akkor hosszabb helyet fog elfoglalni a kiíráskor a megadott szám.            *  
**************************************************************************************************/
  if (min_fix_hossz==0) {lcd_uniprint(String(szam));}                    //a megadott minimális hossz 0, annyi helyet foglal amennyi kell
  else {
    String str_tmp=String(szam);                                         //betöltjük egy string típusú változóba
    byte hossz=str_tmp.length();                                         //megállapítjuk a hosszát
    if (min_fix_hossz>hossz) {                                           //rövidebb mint a minimum
      for (byte i=0;i<(min_fix_hossz-hossz);i++) {str_tmp=" "+str_tmp;}  //amennyivel rövidebb, annyi szóközt teszünk elé
    }
    lcd.print(str_tmp);                                                  //nincsenek ékezetek lehet használni az lcd.print()-et
  }
}

void lcd_uniprint(float szam,byte min_fix_hossz,byte tizedes) {
/**************************************************************************************************  
Ez a függvény akkor hívódik meg, ha az első paraméter Float típusú és még két Byte típusú         *
paraméter lett megadva. A megkapott Float típusú számot az első paraméterben megadott             *
karakterszám hosszban írja ki, ha ez a paraméter nulla, akkor a számjegyek igényelt hosszának     *
megfelelő helyet fog foglalni. Ha a számjegyek száma nagyobb, mint a megadott minimum, akkor      *
hosszabb helyet fog elfoglalni a kiíráskor a megadott szám. A tizedes jegyek száma a harmadik     *
paraméterrel állítható be                                                                         *
***************************************************************************************************/
  if (min_fix_hossz==0) {lcd_uniprint(String(szam,tizedes));}           //a megadott minimális hossz 0, annyi helyet foglal amennyi kell
  else {
    String str_tmp=String(szam,tizedes);                                //betöltjük egy string típusú változóba, megadjuk a String()-nek a tizedesjegyek számát
    byte hossz=str_tmp.length();                                        //megállapítjuk a hosszát
    if (min_fix_hossz>hossz) {                                          //rövidebb mint a minimum
      for (byte i=0;i<(min_fix_hossz-hossz);i++) {str_tmp=" "+str_tmp;} //amennyivel rövidebb, annyi szóközt teszünk elé
    }
    lcd.print(str_tmp);                                                 //nincsenek ékezetek lehet használni az lcd.print()-et
  }
}


void lcd_uniprint(String szoveg) {
/*******************************************************************************************
Ez a függvény képes feltölteni a magyar ékezetes betűk (csak kis betűk, mert többre nincs  *
memória hely) karakterképét az LCD kijelzőre, ha üres String paraméterrel hívjuk meg. Ha a *
paraméter nem egy üres string, akkor megkeresi az ékezetes betűket (2 byte-on kerülnek a   *
stringbe), eltávolítja az egyik felesleges byte-ot, a másikat pedig arra a kódra cseréli,  *
amit a kijelzőnek kell küldeni az adott user karakter megjelenítéséhez (0-7 kódok).        *
********************************************************************************************/
String kiir="";
byte karakter;
byte j=0;
byte hossz=szoveg.length();                //az átvett string hossza
if (hossz==0) {                            //üres karakterrel hívtuk meg a függvényt, ez azt jelenti, hogy feltöltjük a kijelzőt a magyar kerekterek képével
  byte tt[8] = {B10,B100,B1110,B1,B1111,B10001,B1111};                                        //á betű karakterképe
  lcd.createChar(0,tt);
  tt[0]=B10;tt[1]=B100;tt[2]=B1110;tt[3]=B10001;tt[4]=B11111;tt[5]=B10000;tt[6]=B1110;        //é betű karakterképe
  lcd.createChar(1,tt);
  tt[0]=B10;tt[1]=B100;tt[2]=B0;tt[3]=B1110;tt[4]=B100;tt[5]=B100;tt[6]=B1110;                //í betű karakterképe
  lcd.createChar(2,tt);
  tt[0]=B10;tt[1]=B100;tt[2]=B0;tt[3]=B1110;tt[4]=B10001;tt[5]=B10001;tt[6]=B1110;            //ó betű karakterképe
  lcd.createChar(3,tt);
  tt[0]=B00101;tt[1]=B01010;tt[2]=B0;tt[3]=B1110;tt[4]=B10001;tt[5]=B10001;tt[6]=B1110;       //ő betű karakterképe
  lcd.createChar(4,tt);
  tt[0]=B10;tt[1]=B100;tt[2]=B10001;tt[3]=B10001;tt[4]=B10001;tt[5]=B10011;tt[6]=B1101;       //ú betű karakterképe
  lcd.createChar(5,tt);
  tt[0]=B00101;tt[1]=B01010;tt[2]=B0;tt[3]=B10001;tt[4]=B10001;tt[5]=B10011;tt[6]=B1101;      //ű betű karakterképe
  lcd.createChar(6,tt);
  return;
}
for (byte i=0;i<hossz;i++) {                             //minden karakteren sorban végig megyünk
  if ((byte) szoveg[i]==195 or (byte) szoveg[i]==197)    //ha a kerekter 195 vagy 197, akkor azt kihagyjuk az eredmény stringből és vesszük a következő karaktert
  {
    i++;
    karakter=(byte) szoveg[i];
    kiir.concat(" ");                                    //ez a hiányos C++ tudásom miatt van, mivel nem tudtam hozzáfűzni a 0-7 ASCII kódot, ezért hozzáfüzük egy szóközt, 
                                                         //amit a switch-ben lecserélek a megfelelő feltöltött karakter kódjára, illetve a karakterkészletben meglévő 
                                                         //ö és ü betű kódjára
    switch (karakter) {
      case 129: kiir.setCharAt(j,0);break;    //Á        //a j. pozicióban (utolsó hozzáfűzött karaktert cserélem a feltöltött karakter kódjára
      case 161: kiir.setCharAt(j,0);break;    //á
      case 137: kiir.setCharAt(j,1);break;    //É
      case 169: kiir.setCharAt(j,1);break;    //é
      case 141: kiir.setCharAt(j,2);break;    //Í
      case 173: kiir.setCharAt(j,2);break;    //í
      case 147: kiir.setCharAt(j,3);break;    //Ó
      case 179: kiir.setCharAt(j,3);break;    //ó
      case 150: kiir.setCharAt(j,239);break;  //Ö
      case 182: kiir.setCharAt(j,239);break;  //ö
      case 144: kiir.setCharAt(j,4);break;    //Ő
      case 145: kiir.setCharAt(j,4);break;    //ő
      case 154: kiir.setCharAt(j,5);break;    //Ú
      case 186: kiir.setCharAt(j,5);break;    //ú
      case 156: kiir.setCharAt(j,245);break;  //Ü
      case 188: kiir.setCharAt(j,245);break;  //ü
      case 176: kiir.setCharAt(j,6);break;    //Ű
      case 177: kiir.setCharAt(j,6);break;    //ű
    }
  }
  else {kiir.concat(szoveg[i]);}                       //ez egy kijelzőn is megtalálható karakter, simán csak másoljuk
  j++;                                                 //egy karakterrel több van a kijelzőre irandó stringben
}
//SimulIde áramkör szimulátorban csak karakterenként lehet kiírni, mert ott
//az lcd.print() függvény valamilyen okból stringet nem képes kiírni csak az első
//karakterét. Ezt a három sort csak akkor használom, ha SimulIde-ben akarom futtatni 
//for (byte i=0;i<j;i++) {
//  lcd.print(kiir[i]);    
//}
lcd.print(kiir);                                       //..és akkor kiírjuk a kijelzőre az ékezetes kódokra cserélt szöveget
}