Áramkör és Arduino szimulátor

#include <EEPROM.h>
#define tombmeret 10		//mekkora legyen a ramban tárolt adaok mennyisége
#define eepromkimeles 0   //ha értéke egy, akkor csak minde 5. indítás után tárolunk az eepromban, ha 0 akkor minden indításkor
#define felejtes_ido 86100  //ennyi idon belüli szivattyú indítások számát jelezzük ki. 86100sec=24 óra
byte hossz=0;
long kijelzes=millis();
byte lekerdezes_fazis=0; //lekérdezést indítottak ha nagyoibb mint nulla. egyben a lekérdezés fázisait is jelzi
byte lekerdezes_tipus=0; //darablekérdezés jelzésére
char szamjegy_db[]={'0','0','0','0'};
byte szamjegy_db_num[]={0,0,0,0};
char szamjegy_ido[]={'0','0','0','0'};
byte l=0;
byte motor_on=0;
byte motor_on_state=0;
byte szintjelzes=0;
long s1=0;	//eeprom-ból kiolvasottértékek átmeneti tárolása
long s2=0;	//eeprom-ból kiolvasottértékek átmeneti tárolása
long s3=0;	//eeprom-ból kiolvasottértékek átmeneti tárolása
byte k=0;
int inditas_db=0;
int korrekcio=0;
long ido_tmp=millis();	//a másodpercenkénti figyeléshez
long ido_tmp2=millis();	//a 100msec-es figyeléshez
long ido_tmp3=millis();	//a 100msec-es figyeléshez
long ido_tmp4=millis();	//a 100msec-es figyeléshez
long bekapcs_ido=0;	//az aktuális szivattyú működés időtartama
long ido[tombmeret]; 	//ebben mérjük a bekapcsolások között eltelt időt
long bekapcsolva[tombmeret];  //az egyes bekapcsolások ideje (szivattyú működési idő
byte tarolasjelzes[tombmeret]; //a tartalmában levo 1-es hatasara taroljuk az adatokat az epromban
byte sw_elozo_allapot=LOW;  //szivattyú működés előző ciklusban érzékelt állapota
long o_ido=0;		//tömb elemek összeadásakor használt változó
int tombindex=0;
byte villogas=0;
byte veszjelzesmemo=0;
long veszjelz_ido=millis();
byte veszjelz_tmp=0;
byte motor_megy=LOW; //szivattyú működéseklor HIGH, ha nem működik, akkor LOW
int aram_kuszob=0; //szivattyú áramküszöb értéke, mely felett működőnek tekintjük (áramváltó alap feszültsége+3+alapfesz/5)
byte motor_tularam=LOW; //szivattyú tuláram esetén HIGH, alatta LOW, Bármilyen lekérdezés LOW-ba billenti
byte szintjelzo_alapertek=0;  //ha nincs vészjelzés, akkor LOW vagy HIGH értéket vesz fel.
byte szintjelzo_on=0;

//hétszegmenses kijlző kimenetek
// szegmens betüjele:            A,  F,   B,  G,  E,  C , D
//ATmega328chip kivezetés:       13, 14,  15, 16, 17, 18, 19 
//Arduino kivezetés:             7,  8,   9,  10, 11, 12, 13
//   -       A       Szegmensek: 1   -  B,C
//  | |   F     B                2   -  A,B,G,E,D 
//   -       G                   3   -  1,3,4,6,7
//  | |   E     C                4   -  F,B,G,C
//   -       D                   5   -  A,F,G,C,D
//                               6   -  A,F,G,E,C,D
//                               7   -  A,B,C
//                               8   -  A,F,B,G,E,C,D
//                               9   -  A,F,B,G,C,D
//                               0   -  A,F,B,E,C,D
//                               forgas1   -  G
//                               forgas2   -  C
//                               forgas3   -  D
//                               forgas4   -  E
//                               telijelzés1   -  D
//                               telijelzés2   -  G
//                               telijelzés3   -  A
//                A F B G E C D 
byte szegmens[]= {0,0,0,1,0,0,0,   //0, 0
                  1,1,0,1,1,0,1,    //1, 7
                  0,1,0,0,0,1,0,    //2, 14
                  0,1,0,0,1,0,0,    //3, 21
                  1,0,0,0,1,0,1,    //4, 28
                  0,0,1,0,1,0,0 ,    //5, 35
                  0,0,1,0,0,0,0,    //6, 42
                  0,1,0,1,1,0,1,    //7, 49
                  0,0,0,0,0,0,0,    //8, 56
                  0,0,0,0,1,0,0,    //9, 63
                  1,1,1,0,1,1,1,    //f1, 70
                  1,1,1,1,1,0,1,    //f2, 77
                  1,1,1,1,1,1,0,    //f3, 84
                  1,1,1,1,0,1,1,    //f3, 91
                  1,1,1,1,1,1,0,    //s1, 98
                  1,1,1,0,1,1,1,    //s2, 105
                  0,1,1,1,1,1,1,    //s3, 112
                  1,1,1,1,1,1,1};   //ures, 119

byte pin_szegmens[] = {7,  8,  9, 10, 11, 12, 13};
// szegmens betüjele:  A,  F,  B,  G,  E,  C , D
//chip kivezetés:     13, 14, 15, 16, 17, 18, 19 



void setup()
{
  //tömbök indulú értékének feltöltése
  for (byte i=0;i<5;i++) {	ido[i]=0;bekapcsolva[i]=0;tarolasjelzes[i]=0;}
  tarolasjelzes[0]=1;
  pinMode(2,INPUT); //motor működés érzékelő bemenet //4. chip kivezetés
  pinMode(3,INPUT); //"teli" szintjelző érzékelő bemenet //5. chip kivezetés
  pinMode(4,INPUT); //indításszám lekérdezés gomb //6. chip kivezetés
  pinMode(5,INPUT); //működési idő lekérdezés gomb //11. chip kivezetés
  pinMode(6,OUTPUT);  // kijelző tizedespont 12. chip kivezetés
  pinMode(7,OUTPUT);  //13. chip kivezetés
  pinMode(8,OUTPUT);  //14. chip kivezetés
  pinMode(9,OUTPUT);  //15. chip kivezetés
  pinMode(10,OUTPUT);  //16. chip kivezetés
  pinMode(11,OUTPUT);  //17. chip kivezetés
  pinMode(12,OUTPUT);  //18. chip kivezetés
  pinMode(13,OUTPUT);  //19. chip kivezetés
  digitalWrite(6,HIGH);
  digitalWrite(7,HIGH);
  digitalWrite(8,HIGH);
  digitalWrite(9,HIGH);
  digitalWrite(10,HIGH);
  digitalWrite(11,HIGH);
  digitalWrite(12,HIGH);
  digitalWrite(13,HIGH);
  pinMode(0,INPUT);  //2. chip kivezetés gyári alapbeállítás, ha lenyomjuk a gombot, törlődnek az eeprom tartalmak 
  if (digitalRead(0)==LOW) {
    //eeprom törlés, gyári alapbeállítás
    EEPROM.write(0,0);
    EEPROM.write(1,0);
    EEPROM.write(2,0);
    EEPROM.write(3,0);
    EEPROM.write(4,0);
    EEPROM.write(5,0);
    EEPROM.write(6,0);
    EEPROM.write(7,0);
    EEPROM.write(9,digitalRead(3));       //szintjelző alapállapotának lekérdezése
    szintjelzo_alapertek=digitalRead(3);  //szintjelző alapállapot változó feltöltése
    for (byte i=0;i<10;i++) 
    {
      aram_kuszob=aram_kuszob+analogRead(A2);  //összegezzük a 10 mérés eredményét
      delay(500);
    }
    aram_kuszob=aram_kuszob/10;               //egyenirányitó átlagos nyugalmi offszet feszültségének számítása  
    aram_kuszob=aram_kuszob+3+(aram_kuszob/5);//nyugalmi offszetnél kicsival nagyobb áramküszöb számítása
    EEPROM.write(8,aram_kuszob);  //áramküszöb tárolása
    //tizedespont villogtatás, ami a gyári alapbeállítást jelzi
    digitalWrite(6,LOW);
    delay(200);
    digitalWrite(6,HIGH);
    delay(200);
    digitalWrite(6,LOW);
    delay(200);
    digitalWrite(6,HIGH);
    delay(200);
    digitalWrite(6,LOW);
    delay(200);
    digitalWrite(6,HIGH);
  }
  else
  {
    digitalWrite(6,LOW);
    delay(1000);
    digitalWrite(6,HIGH);
    aram_kuszob=EEPROM.read(8);  //tárolt áramküszöb kiolvasása
    szintjelzo_alapertek=EEPROM.read(9);  //tárolt szintjelző alapállapot kiolvasása
  }

}

void loop()
{
  if (motor_tularam==HIGH) {digitalWrite(6,LOW);} else {digitalWrite(6,HIGH);}
  //lenyomták a db lekérdezést és éppen nem fut db vagy ido lekérdezés
  if (digitalRead(4)==LOW && lekerdezes_fazis==0) {lekerdezes_fazis=1;lekerdezes_tipus=1;motor_tularam=LOW;kijelzes=millis();}
  //lenyomták az ido lekérdezést és éppen nem fut db vagy ido lekérdezés  
  if (digitalRead(5)==LOW && lekerdezes_fazis==0) {lekerdezes_fazis=1;lekerdezes_tipus=2;motor_tularam=LOW;kijelzes=millis();}
  //lenyomták az gyári alapbeállítás gombot és éppen nem fut db vagy ido lekérdezés  
  if (digitalRead(0)==LOW && lekerdezes_fazis==0) {lekerdezes_fazis=1;lekerdezes_tipus=3;motor_tularam=LOW;kijelzes=millis();}
  //lenyomták a db lekérdezést és éppen nem fut db vagy ido lekérdezés  
  if (lekerdezes_fazis>0 && millis()>kijelzes) {lekerdezes(lekerdezes_tipus);}
  //egy másodpercenként ellenőrizzuk, hogy megy e a motor és adminisztrálunk
  if (millis()>ido_tmp+1000) {inditas_szamlalo();ido_tmp=millis();}
  //1,2 másodpercre beállítjuk a vizszint vészjelzést ha bekapcsolt a vész vizszintjelző
  if (millis()>ido_tmp3+1200) {if (motor_on!=1) {szintjelzes=1;}}
  if (millis()>ido_tmp3+2400) {	ido_tmp3=millis();szintjelzes=0;k=0;}
  //Szintjelző tárolt alapértéke alapján a vészjelzés detektálása szintjelzo_on=HIGH jelzi a magas folyadékszintet 
  szintjelzo_on=LOW;
  if (szintjelzo_alapertek==LOW) {if (digitalRead(3)==HIGH) {szintjelzo_on=HIGH;}} 
  else {if (digitalRead(3)==LOW) {szintjelzo_on=HIGH;}}
  //bekapcsolt a vész szintjelző kapcsoló, sorban villogtatjuk a függőleges pálcikákat 3 másodpercenként
  if (szintjelzes==1 && szintjelzo_on==HIGH && lekerdezes_fazis==0)  
  {
    if (millis()>ido_tmp2+200) 
    {
      for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[98+(k*7)+i]);}
      k++;if(k==3) {k=0;}
      ido_tmp2=millis();
    }
  }
  //éppen működik a motor, sorban körbe villogtajuk az alsó 4 szegmenst
  if (motor_on==1 && szintjelzes==0 && lekerdezes_fazis==0) 
  {
    if (millis()>ido_tmp2+200) 
    {
      //motor működik	
      for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[70+(motor_on_state*7)+i]);}
      motor_on_state++;if (motor_on_state==4) {	motor_on_state=0;}
      ido_tmp2=millis();
    }			
  }
  //sem a motor nem működik, sem vész vizszint kijelzés nincs
  //kijelezzük az utolsó 24 óra indításainak számát
  if (motor_on==0 && szintjelzes==0 && lekerdezes_fazis==0) 
  {
    if (millis()>ido_tmp2+200) 
    {
      if (inditas_db==8) {villogas++;} else {villogas=1;}
      if (villogas==2) {for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);}}
      if (villogas==1) {for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[inditas_db*7+i]);}}
//      for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[inditas_db*7+i]);}
      if (villogas==2){villogas=0;}
      ido_tmp2=millis();
    }
  }
}	


void lekerdezes(byte lek_tip)
{
  lekerdezes_fazis++;
  veszjelzesmemo=0;
  if (lekerdezes_fazis==11) {lekerdezes_fazis=0;}
  //10.fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==10) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);} kijelzes=kijelzes+1000;}
  //9.fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==9) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[szamjegy_db_num[3]+i]);}kijelzes=kijelzes+600;}
  //8.fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==8) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);} kijelzes=kijelzes+300;}
  //7.fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==7) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[szamjegy_db_num[2]+i]);}kijelzes=kijelzes+600;}
  //6. fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==6) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);} kijelzes=kijelzes+300;}
  //5. fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==5) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[szamjegy_db_num[1]+i]);}kijelzes=kijelzes+600;}
  //4. fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==4) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);} kijelzes=kijelzes+300;}
  //3. fazis kikapcsoljuk a szegmenseket
  if (lekerdezes_fazis==3) 	{for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[szamjegy_db_num[0]+i]);}kijelzes=kijelzes+600;}
  //első fázis, kiolvassuk az értéket és előkészítjük a megjelenítés változóit
  if (lekerdezes_fazis==2) 	
  {
    for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);} 
    kijelzes=kijelzes+1000;
    o_ido=0;
    l=0;
    if (eepromkimeles==1)
    {
      for (byte i=0;i<10;i++)
      {
        if (bekapcsolva[i]>0) {o_ido=o_ido+bekapcsolva[i];l++;}
      }
    }		
    if (lekerdezes_tipus==1) {s2=EEPROMReadlong(4);s2=s2+l;}
    if (lekerdezes_tipus==2) {s2=EEPROMReadlong(0);s2=(s2+o_ido)/60;}
    if (lekerdezes_tipus==3) {s2=analogRead(A2);s2=s2*488;s2=s2/100;}
    char_konv(s2);
    for (byte i=0;i<4;i++)
    {
      if (szamjegy_db[i]=='0'){szamjegy_db_num[i]=0;}
      if (szamjegy_db[i]=='1'){szamjegy_db_num[i]=7;}
      if (szamjegy_db[i]=='2'){szamjegy_db_num[i]=14;}
      if (szamjegy_db[i]=='3'){szamjegy_db_num[i]=21;}
      if (szamjegy_db[i]=='4'){szamjegy_db_num[i]=28;}
      if (szamjegy_db[i]=='5'){szamjegy_db_num[i]=35;}
      if (szamjegy_db[i]=='6'){szamjegy_db_num[i]=42;}
      if (szamjegy_db[i]=='7'){szamjegy_db_num[i]=49;}
      if (szamjegy_db[i]=='8'){szamjegy_db_num[i]=56;}
      if (szamjegy_db[i]=='9'){szamjegy_db_num[i]=63;}
    }
  } 
}

void inditas_szamlalo()
{
  //idő számlálók növelése. Másodperc alapon mérünk időt
  bekapcs_ido++;ido_tmp=millis();
  ido[0]=ido[0]+1;
  o_ido=0;
  s3=0;
  // sorban összeadjuk a tömbben tárolt időt, ha elértük a 24 órát (86400 másodperc), akkor megállunk
  //az utolsó 24 óra szivattyú indításainak számára vagyunk kíváncsiak
  while (o_ido<felejtes_ido && s3<tombmeret-1 && ido[s3]!=0)
  {
    o_ido=o_ido+ido[s3];
    s3++;
  }		
  inditas_db=s3-1;
  if (inditas_db==8) {veszjelzesmemo=1;}
  if (tarolasjelzes[tombmeret-1]==1 && eepromkimeles==1) //tarolásjelzés, tehát az utolsó 5 adatot összgezni és tárolni kell
                                                         //de csak akkor, ha az eeprom kimélés be van kapcsolva
  {
    //Összeadjuk a tömbben tárolt bekapcsolási időket, és közben töröljük az összeadottakat
    //a törlés csak a működés nyomnkövethetősége miatt lett beépítve
    o_ido=0;
    for (byte j=0;j<5;j++) {	o_ido=o_ido+bekapcsolva[tombmeret-j-1];bekapcsolva[tombmeret-j-1]=0;}
      //osszes szivattyú működési idő kiolvasása az eeprom-ból és hozzáadjuk az utóbbi tárolt bekapcsolási időket
    s1=EEPROMReadlong(0);
    s1=s1+o_ido;
      //Összes eddigi indításszám kiolvasása eeprom-ból és hozzáadjuk az utóbbi tárolt indítás számot
    s2=EEPROMReadlong(4);
    EEPROMWritelong(0,s1);
    EEPROMWritelong(4,s2+5); //értékek írása az eeprom-ba
    tombindex=0;
    tarolasjelzes[tombmeret-6]=1;
    tarolasjelzes[tombmeret-1]=0;
  } //if vége
  motor_lekerdezes();
    //a szivattyú indítás felfutó éle, tároljuk a tömbb 0-as indexén az utolsó indítás óta 
    //eltelt időt és tároljuk ennek változóját, töröljuk a bekapcsolási idő változóját
  if (motor_megy && !sw_elozo_allapot) {  bekapcs_ido=0;motor_on=1;}
    //szivattyú kikapcsolása (lefutó él). Minden értéket lejjebb másolunk a tömbben és
    //tároljuk a bekapcsolási idő számlálást
  if (!motor_megy && sw_elozo_allapot) 
  {
    bekapcsolva[0]=bekapcs_ido;
    motor_on=0;
    for (byte j=tombmeret-1;j>0;j--)
    {
      bekapcsolva[j]=bekapcsolva[j-1];
      ido[j]=ido[j-1];
      tarolasjelzes[j]=tarolasjelzes[j-1];
    }
    bekapcsolva[0]=0;ido[0]=0;tarolasjelzes[0]=0;
    if (eepromkimeles==0) //eeprom kimélés kikapcsolva, így minden motor működés után beírjuk az adatokat az eeprom-ba
    {
      //Összes eddigi működési idő kiolvasása eeprom-ból és hozzáadjuk a legutóbbi működési időt
      s1=EEPROMReadlong(0);
      s1=s1+bekapcs_ido;
      EEPROMWritelong(0,s1);
      //Összes eddigi indításszám kiolvasása eeprom-ból és hozzáadunk egyet
      s2=EEPROMReadlong(4);
      EEPROMWritelong(4,s2+1); //értékek írása az eeprom-ba
    }
  }
  sw_elozo_allapot=motor_megy; //fel és lefutó él érzékeléséhez
}


//Ez a funkció kiír egy 4 byte (32bit) long változót az eeprom-ba
void EEPROMWritelong(int address, long value)
{
	//szétszedjük byte-okra a long-ot
	byte four = (value & 0xFF);
	byte three = ((value >> 8) & 0xFF);
	byte two = ((value >> 16) & 0xFF);
	byte one = ((value >> 24) & 0xFF);
	//A 4 byte-os adat epromba �r�sa
	EEPROM.write(address, four);
	EEPROM.write(address + 1, three);
	EEPROM.write(address + 2, two);
	EEPROM.write(address + 3, one);
}

//Ez a funkció visszaolvas 4 byte (32bit) long változót az eeprom-ból
long EEPROMReadlong(long address)
{
	//4 bytes olvasása az eeprom-ból.
	long four = EEPROM.read(address);
	long three = EEPROM.read(address + 1);
	long two = EEPROM.read(address + 2);
	long one = EEPROM.read(address + 3);
	//4 byte long változóvá alakítása
	return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

void char_konv(int szam)
{
	String konv_string=String(szam);
	hossz=konv_string.length();
	for (byte j=0;j<4;j++) {szamjegy_db[j]='0';}
	for (byte i=0;i<hossz;i++) {szamjegy_db[4-hossz+i]=konv_string.charAt(i);}
}

void motor_lekerdezes()
{
if (!digitalRead(2) || analogRead(A2)>aram_kuszob) {motor_megy=HIGH;}  else {motor_megy=LOW;}
if (analogRead(A2)>analogRead(A1)) {motor_tularam=HIGH;}
}

#include <Soft_LCD-I2C.h>
uint8_t address = 80;
uint8_t sda = 18;
uint8_t scl = 19;
Soft_Lcd_I2C lcd( address, 16, 2, sda, scl );

#include <EEPROM.h>
#include <Wire.h>          //I2C library 

#include <Soft_LCD-I2C.h>
uint8_t address = 80;
uint8_t sda = 18;
uint8_t scl = 19;
Soft_Lcd_I2C lcd( address, 16, 2, sda, scl );

#define tombmeret 10		 //mekkora legyen a ramban tárolt adaok mennyisége
#define eepromkimeles 0     //ha értéke egy, akkor csak minde 5. indítás után tárolunk az eepromban, ha 0 akkor minden indításkor
#define felejtes_ido 86100  //ennyi idon belüli szivattyú indítások számát jelezzük ki. 86100sec=24 óra
byte hossz=0;
long kijelzo_frissites=millis();
long lcd_vilagitas=millis();
char szamjegy_db[]={'0','0','0','0'};
byte szamjegy_db_num[]={0,0,0,0};
char szamjegy_ido[]={'0','0','0','0'};
byte l=0;
byte motor_on=0;
byte motor_on_state=0;
byte szintjelzes=0;
long s1=0;					//eeprom-ból kiolvasottértékek átmeneti tárolása
long s2=0;					//eeprom-ból kiolvasottértékek átmeneti tárolása
long s3=0;					//eeprom-ból kiolvasottértékek átmeneti tárolása
byte k=0;
int inditas_db=0;
int korrekcio=0;
long ido_tmp=millis();	//a másodpercenkénti figyeléshez
long ido_tmp2=millis();	//a 100msec-es figyeléshez
long ido_tmp3=millis();	//a 100msec-es figyeléshez
long bekapcs_ido=0;		//az aktuális szivattyú működés időtartama
long ido[tombmeret]; 			//ebben mérjük a bekapcsolások között eltelt időt
long bekapcsolva[tombmeret];		//az egyes bekapcsolások ideje (szivattyú működési idő
byte tarolasjelzes[tombmeret]; //a tartalmában levo 1-es hatasara taroljuk az adatokat az epromban
byte sw_elozo_allapot=LOW;	//szivattyú működés előző ciklusban érzékelt állapota
long o_ido=0;				//tömb elemek összeadásakor használt változó
int tombindex=0;
byte villogas=0;
byte veszjelzesmemo=0;
long veszjelz_ido=millis();
byte veszjelz_tmp=0;
byte motor_megy=LOW; //szivattyú működéseklor HIGH, ha nem működik, akkor LOW
int aram_kuszob=0;  //szivattyú áramküszöb értéke, mely felett működőnek tekintjük (áramváltó alap feszültsége+3+alapfesz/5)
byte motor_tularam=LOW; //szivattyú tuláram esetén HIGH, alatta LOW, Bármilyen lekérdezés LOW-ba billenti
byte szintjelzo_alapertek=0;  //ha nincs vészjelzés, akkor LOW vagy HIGH értéket vesz fel.
byte szintjelzo_on=0;
int aram_offset=0;
int motoraram=0;
int aramlimit=0;
int uts_max_motoraram=0;

//prellmentesítés segédváltozói
byte in_prev_state=0;     //bemenet előző állapota segéd változó
byte in_prell_tmp=0;      //bemenet prell figyeléshez segéd változó
long in_prell_time=0;     //bemenet prellmentesítéshez eltelt idő az első kontaktus óta, segéd változó
long out_setup_time_tmp=0;//kimenet kikapcsolási időhöz segéd változó
byte in_state=0;          //nyomógomb nyomvatartás alatt értéke 1
byte adat_valaszto=0; //az LCD kijelzett értéket határozza meg
bool k_frissit=LOW;

//hétszegmenses kijlző kimenetek
//   -       A       Szegmensek: 1   -  B,C
//  | |   F     B                2   -  A,B,G,E,D 
//   -       G                   3   -  1,3,4,6,7
//  | |   E     C                4   -  F,B,G,C
//   -       D                   5   -  A,F,G,C,D
//                               6   -  A,F,G,E,C,D
//                               7   -  A,B,C
//                               8   -  A,F,B,G,E,C,D
//                               9   -  A,F,B,G,C,D
//                               0   -  A,F,B,E,C,D
//                               forgas1   -  G
//                               forgas2   -  C
//                               forgas3   -  D
//                               forgas4   -  E
//                               telijelzés1   -  D
//                               telijelzés2   -  G
//                               telijelzés3   -  A
//                A F B G E C D 
byte szegmens[]= {0,0,0,1,0,0,0,   //0, 0
                  1,1,0,1,1,0,1,    //1, 7
                  0,1,0,0,0,1,0,    //2, 14
                  0,1,0,0,1,0,0,    //3, 21
                  1,0,0,0,1,0,1,    //4, 28
                  0,0,1,0,1,0,0 ,    //5, 35
                  0,0,1,0,0,0,0,    //6, 42
                  0,1,0,1,1,0,1,    //7, 49
                  0,0,0,0,0,0,0,    //8, 56
                  0,0,0,0,1,0,0,    //9, 63
                  1,1,1,0,1,1,1,    //f1, 70
                  1,1,1,1,1,0,1,    //f2, 77
                  1,1,1,1,1,1,0,    //f3, 84
                  1,1,1,1,0,1,1,    //f3, 91
                  1,1,1,1,1,1,0,    //s1, 98
                  1,1,1,0,1,1,1,    //s2, 105
                  0,1,1,1,1,1,1,    //s3, 112
                  1,1,1,1,1,1,1};   //ures, 119

byte pin_szegmens[] = {7,  8,  9, 10, 11, 12, 13};
// szegmens betüjele:  A,  F,  B,  G,  E,  C , D
//chip kivezetés:     13, 14, 15, 16, 17, 18, 19 


void setup()
{
  analogReference(DEFAULT);  //A tápfeszt veszi referenciának (5V)
  Wire.begin();              // I2C busz használat indítása
  lcd.init();

  //tömbök indulú értékének feltöltése
  for (byte i=0;i<5;i++) {	ido[i]=0;bekapcsolva[i]=0;tarolasjelzes[i]=0;}
  tarolasjelzes[0]=1;
  pinMode(2,INPUT); //motor működés érzékelő bemenet //4. chip kivezetés
  digitalWrite(2,HIGH);
  pinMode(3,INPUT); //"teli" szintjelző érzékelő bemenet //5. chip kivezetés
  digitalWrite(3,HIGH);
  pinMode(4,INPUT); //Kijelző világítás bekapcsoló gomb. 60 másodpercig világít, 
                    //jelenlegi hardverben nincs funkciója, mert a világítást egy külön nyomógomb direktben kapcsolja a kijelzőn
  digitalWrite(4,HIGH);
  pinMode(5,INPUT); //Kijelzett érték váltása az LCD kijelzőn és gyári alapbeállítás, ha nyomva van bekapcsoláskor
  digitalWrite(5,HIGH);
  
  // led kijelző szegmenseinek vezérlő kimeneteinek beállítása
  for (byte i=6;i<14;i++) {pinMode(i,OUTPUT);digitalWrite(i,HIGH);} //led kijelző szegmenseinek vezérlő kimenetei
  if (digitalRead(5)==LOW)     //gyári alapbeállítás
  {
    lcd.setCursor(0,0);lcd.printstr("Alapertek beall.");
    lcd.setCursor(0,1);lcd.printstr("                ");
    //eeprom törlés, gyári alapbeállítás
    for (byte i=0;i<20;i++) {EEPROM.write(i,0);}
    EEPROM.write(9,digitalRead(3));       //szintjelző alapállapotának lekérdezése
    //tizedespont villogtatás, ami a gyári alapbeállítást jelzi
    for (byte i=1;i<5;i++) {digitalWrite(6,LOW);delay(200);digitalWrite(6,HIGH);delay(200);}
  }
  lcd.clear();lcd.setCursor(0,0);lcd.printstr("Offset meres!   ");
  //10x mérünk és átlagoljuk, így megkapjuk a nyugalmi feszültségét az áramváltó egyenirányítójának
  //fontos, hogy bekapcsoláskor ne működjön a szvattyú
  for (byte i=0;i<10;i++) {aram_offset=aram_offset+analogRead(A2);delay(60);}
  aram_offset=aram_offset/10;   //egyenirányitó átlagos nyugalmi offszet átlagos feszültségének számítása
  aram_kuszob=aram_offset*10;   //nyugalmi offszetnél tízszerese a működő motor érzékelésének áramküszöbe
  lcd.setCursor(0,1);lcd.printstr("Offset:");
  lcd.setCursor(0,1);
  lcd.print((float) aram_offset*0.017);
  lcd.printstr("A (");
  lcd.print(aram_offset);
  lcd.printstr(")");
  delay(2000);
  szintjelzo_alapertek=EEPROM.read(9);  //tárolt szintjelző alapállapot kiolvasása
  uts_max_motoraram=EEPROMReadlong(15);
  lcd.setCursor(0,0);lcd.printstr("Uts.max.mot.aram");
  lcd.setCursor(0,1);lcd.printstr("torlesehez nyomd");
  delay(3000);
  lcd.setCursor(0,0);lcd.printstr("a nyomogombot!  ");
  lcd.setCursor(0,1);lcd.printstr("                ");
  delay(3000);
  lcd.setCursor(0,0);lcd.printstr("Torleshez       ");
  lcd.setCursor(0,1);lcd.printstr("hatravan:       ");
  for (byte i=5;i>0;i--) 
  {
    lcd.setCursor(9,1);lcd.print(i);
    if (digitalRead(5)==LOW)
    {
      for (byte j=15;j<20;j++) {EEPROM.write(j,0);}
      lcd.setCursor(0,0);lcd.printstr("Max aram torolve");
      lcd.setCursor(0,1);lcd.printstr("================");
      delay(2000); 
      break;
    }
    delay(1000);
  }
}

void loop()
{
  //4-es bemenetre kötött gombnyomásra bekapcsoljuk az lcd háttérvilágítását, és egy perc mulva kapcsoljuk ki
  if (digitalRead(4)==LOW) {lcd.backlight();lcd_vilagitas=millis();}
  //if (lcd_vilagitas+60000<millis()) {lcd.noBacklight();}

  //egy másodpercenként ellenőrizzuk, hogy megy e a motor és adminisztrálunk
  if (millis()>ido_tmp+1000) {inditas_szamlalo();ido_tmp=millis();}

  //1,2 másodpercre beállítjuk a vizszint vészjelzést ha bekapcsolt a vész vizszintjelző
  if (millis()>ido_tmp3+1200) {if (motor_on!=1) {szintjelzes=1;}}
  if (millis()>ido_tmp3+2400) {	ido_tmp3=millis();szintjelzes=0;k=0;}

  //Szintjelző tárolt alapértéke alapján a vészjelzés detektálása szintjelzo_on=HIGH jelzi a magas folyadékszintet 
  szintjelzo_on=LOW;
  if (szintjelzo_alapertek==LOW) {if (digitalRead(3)==LOW) {szintjelzo_on=HIGH;}} 
  else {if (digitalRead(3)==HIGH) {szintjelzo_on=HIGH;}}

  //*******************szintjelző riasztás megjelenítése led kijelzőn***********************************/
  //bekapcsolt a vész szintjelző kapcsoló, sorban villogtatjuk a függőleges pálcikákat 3 másodpercenként
  if (szintjelzes==1 & szintjelzo_on==HIGH)  
  {
    if (millis()>ido_tmp2+200) 
    {
      for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[98+(k*7)+i]);}
      k++;if(k==3) {k=0;}
      ido_tmp2=millis();
    }
  }

  //******************motor működés kelzése a led kijelzőn*******************************************/
  //éppen működik a motor, sorban körbe villogtajuk az alsó 4 szegmenst
  if (motor_on==1 & szintjelzes==0) 
  {
    if (millis()>ido_tmp2+200) 
    {
      //motor működik	
      for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[70+(motor_on_state*7)+i]);}
      motor_on_state++;if (motor_on_state==4) {	motor_on_state=0;}
      ido_tmp2=millis();
    }			
  }
  
  //********************indításszám kijelzése a led kijelzőn****************************************/
  //sem a motor nem működik, sem vész vizszint kijelzés nincs
  //kijelezzük az utolsó 24 óra indításainak számát, villogtatjuk ha több mint 8
  if (motor_on==0 & szintjelzes==0) 
  {
    if (millis()>ido_tmp2+200) 
    {
      if (inditas_db==8) {villogas++;} else {villogas=1;}
      if (villogas==2) {for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[119+i]);}}
      if (villogas==1) {for (byte i=0;i<7;i++) {digitalWrite(pin_szegmens[i],szegmens[inditas_db*7+i]);}}
      if (villogas==2){villogas=0;}
      ido_tmp2=millis();
    }
  }

  /**************prellmentesítés a nyomógombon, és kijelzett érték paraméterének változtatása*****************/
  //első lenyomás érzékelése
  if (in_state==0 and digitalRead(5)==LOW and in_prell_tmp==0)
    {in_prell_tmp=1;in_prell_time=millis();} 
  // már 50msecv óta nyomva van, most már biztos, hogy lenyomták és nem prellezik
  if (in_state==0 and digitalRead(5)==LOW and in_prell_tmp==1 and millis()>in_prell_time+50) 
    {
      in_state=1;in_prell_tmp=0;
      //növeljük a kijelzett érték változóját, ciklikuan 0-ha, elértük a legnagyobb értéket
      adat_valaszto++;if (adat_valaszto==9){adat_valaszto=0;}
      k_frissit=HIGH; //ennek hatására azonnal ki fogja írni a kiválasztott adot (frissíti a kijelzőt)
      digitalWrite(6,HIGH);  //kikapcsoljuk a tizedespontot (túláram jelzés törlése)
    } 
  //első elengedés érzékelése
  if (in_state==1 and digitalRead(5)==HIGH and in_prell_tmp==0)
    {in_prell_tmp=1;in_prell_time=millis();} 
  // már 50msecv óta elengedve, most már biztos, hogy elengedték és nem prellezik
  if (in_state==1 and digitalRead(5)==HIGH and in_prell_tmp==1 and millis()>in_prell_time+50) 
    {in_state=0;in_prell_tmp=0;} 
        
  //***********************************kijelző frissítés******************************************/
  //Serial.println(k_frissit);
  if (millis()>kijelzo_frissites+1000 or k_frissit==HIGH)  //egymásodpercenként frissítjük a kijelzésre kerülő értéket
                                                           //vagy ha megnyomta a nyomógombot
  {
    k_frissit=LOW;
    //lcd.setCursor(0,1);lcd.printstr("                ");
    switch (adat_valaszto)
    {
      case 0:   //24 óra indításszáma
        lcd.setCursor(0,0);lcd.printstr("24H inditasszam:");
        lcd.setCursor(0,1);
        lcd.print(inditas_db);
        lcd.printstr(" db            ");break;
      case 1:   //Összes motor működési idő
        lcd.setCursor(0,0);lcd.printstr("Ossz.muk.ido:   ");
        lcd.setCursor(0,1);
        lcd.print(EEPROMReadlong(0)/60);
        lcd.printstr(" perc       ");break;
      case 2:   //Összes motor indításszám
        lcd.setCursor(0,0);lcd.printstr("Ossz.mot.indit:");
        lcd.setCursor(0,1);
        lcd.print(EEPROMReadlong(4));
        lcd.printstr(" db            ");break;
      case 3:   //árammérő offszet értéke
        lcd.setCursor(0,0);lcd.printstr("Arammero offset:");
        lcd.setCursor(0,1);
        lcd.print((float) aram_offset*0.017);
        lcd.printstr("A (");
        lcd.print(aram_offset);
        lcd.printstr(") ");break;
      case 4:   //motor működés érzékelési küszöb
        lcd.setCursor(0,0);lcd.printstr("Mot.erz.kuszob: ");
        lcd.setCursor(0,1);
        lcd.print((float)aram_kuszob*0.017);
        lcd.printstr("A (");
        lcd.print(aram_kuszob);
        lcd.printstr(") ");;break;
      case 5:   //motor túláram risztási küszöb (potméter beállított értéke)
        lcd.setCursor(0,0);lcd.printstr("Tularam.kuszob: ");
        lcd.setCursor(0,1);
        lcd.print((float) aramlimit*0.017);
        lcd.printstr("A (");
        lcd.print(aramlimit);
        lcd.printstr(") ");break;
      case 6:   //motor túláram risztási küszöb (potméter beállított értéke)
        lcd.setCursor(0,0);lcd.printstr("Tularamok szama: ");
        lcd.setCursor(0,1);
        lcd.print(EEPROMReadlong(10));
        lcd.printstr(" db            ");break;
      case 7:   //motor áramának értéke (offszet éték kivonásával)
        lcd.setCursor(0,0);lcd.printstr("Uts.max.mot.aram:");
        lcd.setCursor(0,1);
        lcd.print((float)uts_max_motoraram*0.017);
        lcd.printstr("A (");
        lcd.print(uts_max_motoraram);
        lcd.printstr(") ");break;
      case 8:   //motor áramának értéke (offszet éték kivonásával)
        lcd.setCursor(0,0);lcd.printstr("Motoraram:      ");
        lcd.setCursor(0,1);lcd.print((float) (motoraram-aram_offset)*0.017);
        lcd.printstr("A (");
        lcd.print(motoraram);
        lcd.printstr(") ");break;
    }
    kijelzo_frissites=millis();
  }
}	



void inditas_szamlalo()
{
  //idő számlálók növelése. Másodperc alapon mérünk időt
  bekapcs_ido++;ido_tmp=millis();
  ido[0]=ido[0]+1;
  o_ido=0;
  s3=0;
  // sorban összeadjuk a tömbben tárolt időt, ha elértük a 24 órát (86400 másodperc), akkor megállunk
  //az utolsó 24 óra szivattyú indításainak számára vagyunk kíváncsiak
  while (o_ido<felejtes_ido && s3<tombmeret-1 && ido[s3]!=0)
  {
    o_ido=o_ido+ido[s3];
    s3++;
  }		
  inditas_db=s3-1;
  if (inditas_db==8) {veszjelzesmemo=1;}
  if (tarolasjelzes[tombmeret-1]==1 && eepromkimeles==1) //tarolásjelzés, tehát az utolsó 5 adatot összgezni és tárolni kell
                                                         //de csak akkor, ha az eeprom kimélés be van kapcsolva
  {
    //Összeadjuk a tömbben tárolt bekapcsolási időket, és közben töröljük az összeadottakat
    //a törlés csak a működés nyomnkövethetősége miatt lett beépítve
    o_ido=0;
    for (byte j=0;j<5;j++) {	o_ido=o_ido+bekapcsolva[tombmeret-j-1];bekapcsolva[tombmeret-j-1]=0;}
      //osszes szivattyú működési idő kiolvasása az eeprom-ból és hozzáadjuk az utóbbi tárolt bekapcsolási időket
    s1=EEPROMReadlong(0);
    s1=s1+o_ido;
      //Összes eddigi indításszám kiolvasása eeprom-ból és hozzáadjuk az utóbbi tárolt indítás számot
    s2=EEPROMReadlong(4);
    EEPROMWritelong(0,s1);
    EEPROMWritelong(4,s2+5); //értékek írása az eeprom-ba
    tombindex=0;
    tarolasjelzes[tombmeret-6]=1;
    tarolasjelzes[tombmeret-1]=0;
  } //if vége
  motor_lekerdezes();
  
  //a szivattyú indítás felfutó éle, tároljuk a tömbb 0-as indexén az utolsó indítás óta 
  //eltelt időt és tároljuk ennek változóját, töröljuk a bekapcsolási idő változóját
  if (motor_megy && !sw_elozo_allapot) {  bekapcs_ido=0;motor_on=1;}
  
  //szivattyú kikapcsolása (lefutó él). Minden értéket lejjebb másolunk a tömbben és
  //tároljuk a bekapcsolási idő számlálást
  if (!motor_megy && sw_elozo_allapot) 
  {
    if (motor_tularam==HIGH) 
    {
      //ha a motor áramfelvétele nagyobb volt a működés alatt mint a potival beállított limit, akkor kigyúllad a tizedespont. 
      //Az5-os bemenetre kötött gomb lenyomása kikapcsolja
      digitalWrite(6,LOW);
      motor_tularam=LOW;
      int ta=EEPROMReadlong(10);
      ta++;
      EEPROMWritelong(10,ta);
    }
    EEPROMWritelong(15,uts_max_motoraram);
    bekapcsolva[0]=bekapcs_ido;
    motor_on=0;
    for (byte j=tombmeret-1;j>0;j--)
    {
      bekapcsolva[j]=bekapcsolva[j-1];
      ido[j]=ido[j-1];
      tarolasjelzes[j]=tarolasjelzes[j-1];
    }
    bekapcsolva[0]=0;ido[0]=0;tarolasjelzes[0]=0;
    if (eepromkimeles==0) //eeprom kimélés kikapcsolva, így minden motor működés után beírjuk az adatokat az eeprom-ba
    {
      //Összes eddigi működési idő kiolvasása eeprom-ból és hozzáadjuk a legutóbbi működési időt
      s1=EEPROMReadlong(0);
      s1=s1+bekapcs_ido;
      EEPROMWritelong(0,s1);
      //Összes eddigi indításszám kiolvasása eeprom-ból és hozzáadunk egyet
      s2=EEPROMReadlong(4);
      EEPROMWritelong(4,s2+1); //értékek írása az eeprom-ba
    }
  }
  sw_elozo_allapot=motor_megy; //fel és lefutó él érzékeléséhez
}


//Ez a funkció kiír egy 4 byte (32bit) long változót az eeprom-ba
void EEPROMWritelong(int address, long value)
{
	//szétszedjük byte-okra a long-ot
	byte four = (value & 0xFF);
	byte three = ((value >> 8) & 0xFF);
	byte two = ((value >> 16) & 0xFF);
	byte one = ((value >> 24) & 0xFF);
	//A 4 byte-os adat epromba írása
	EEPROM.write(address, four);
	EEPROM.write(address + 1, three);
	EEPROM.write(address + 2, two);
	EEPROM.write(address + 3, one);
}

//Ez a funkció visszaolvas 4 byte (32bit) long változót az eeprom-ból
long EEPROMReadlong(long address)
{
	//4 bytes olvasása az eeprom-ból.
	long four = EEPROM.read(address);
	long three = EEPROM.read(address + 1);
	long two = EEPROM.read(address + 2);
	long one = EEPROM.read(address + 3);
	//4 byte long változóvá alakítása
	return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

void char_konv(int szam)
{
	String konv_string=String(szam);
	hossz=konv_string.length();
	for (byte j=0;j<4;j++) {szamjegy_db[j]='0';}
	for (byte i=0;i<hossz;i++) {szamjegy_db[4-hossz+i]=konv_string.charAt(i);}
}

void motor_lekerdezes()
{
motoraram=analogRead(A2);
if (uts_max_motoraram<(motoraram-aram_offset)) {uts_max_motoraram=motoraram-aram_offset;}
aramlimit=analogRead(A1);
if (!digitalRead(2) || (motoraram-aram_offset)>aram_kuszob) {motor_megy=HIGH;}  else {motor_megy=LOW;}
if ((motoraram-aram_offset)>aramlimit) {motor_tularam=HIGH;}
}

#include <Wire.h>    //I2C library 

#include <Soft_LCD-I2C.h>
uint8_t address = 80;
uint8_t sda = 18;
uint8_t scl = 19;
Soft_Lcd_I2C lcd( address, 16, 2, sda, scl );

bool elozo;                        //segéd változó előző szélkerék kontaktus állapot tárolására
bool most;                         //segéd változó a pillanatnyi szélkerék kontaktus állapot tárolására        
long ido_tmp=millis();             //segéd változó egy fordulat idejének a méréséhez
long nemforog_ido=millis();        //segéd változó amivel mérjük az időt akkor, ha nincskontaktus, mert nem fúj a szél
long szelkerek_ido=millis();       //segéd változó, amivel a szélkerék pillanatnyi sebesség frissítés 1 másodperces idejét mérem
long ido_tmp_10=millis();          //segéd változó, amivel a 10 másodperces széllökés méréshez használok
long kijelzo_valtas_ido=millis();  //segéd változó, amit a 1 másodperces kijelző tartalom frissítéshez használok
bool frissit=true;                 //true értéke esetén azonnal befrissíti a kijelző érékét, ha false akkor csak másodpercenként
long percidozito=millis();         //segéd változó az egy perces időzítéshez, percenként növeljük az ejfel változó értékét
byte adat_index=0;                 //az éppen aktuálisan kijelzett adat indexe. Minden ciklusban 1-el növelem, 7 után nullázom
byte ora;                          //segéd változó a szeles és szélmentes órák kiírásához, és az idő beállításhoz
byte perc;                         //segéd változó a szeles és szélmentes percek kiírásához, és az idő beállításhoz
long nyomva_ido=millis();          //setup gomb nyomvatartásának figyeléséhez a prellmentesítés érdekében 50msec időzítéshez
long elenged_ido=millis();         //a nyomógomb elengedési idejének figyeléséhez a prellmentesítés érdekében 50msec időzítéshez
bool nyomva;                       //nyomógom nyomva jelzésére, prellmentesítéshez kell
bool elengedve;                    //nyomógomb elengedve jelzésére, prellmentesítéshez kell
bool setup_mod;                    //ezzel jelzem, ha megnyomta a nyomógombot, és elkezdődik a setup folyamat (kijelzett érték beállítás, idő beállítás)
long vilagitas_ido=millis;         //az lcd kijelző háttérvilágításának időzítésére használom. bármilyen gombnyomástól számított
                                   //60 másodperccel kikapcsol a kijelző háttérvilágítása 
bool lcd_vilagitas;                //ez jelzi, hogy az lcd kijelző háttérvilágítása be van kapcsolva, vagy ki van kapcsolva
byte imp=0;                        //ezt a második felfutóél jelzésére használom, hogy egy fordulat idejét tudjam megmérni
int imp_10sec=0;                   //a 10 sec alatt beérkezett impulzusok száma
long imp_atlag=0;                  //az egy nap alatt beérkezett impulzuok száma a napi átlagsebesség méréshez
int ford_ido=0;                    //egy fordulat idejét milisecundumban, pillnatnyi sebesség méréséhez
bool all=false;                    //ez a változó jelzi, ha áll a szélkerék és nem kell kiszámolni a pillanatnyi szélsebességet, mert éppen nulla
float pill_szelseb=0;              //két impulzus közt eltelt időből kiszámított pillanatnyi szélsebességet
float napi_atlag_seb=0;            //napi átlag sebesség, amit a napi impulzusszámból és a szeles idő másodpercekben mért értékéből számolok ki
float szellokes;                   //a széllökés 10 másodpercre számított értéke
float szellokes_max;               //a széllökés maximumát tárolja. Naponta egyszer kel nullázni, és így kezdődik minden nap éjfélkor a maximum meghatározása
                                   //Az éjfélkor történő nullázásról egy ejfel navű változó gondoskodik, ami 1440-nél nullázódik. 1440 perc van egy nap
                                   //ez így nem valódi pontos óra, a processzor kavarcz órajelén alapul, nem túl pontos, időnként be kell állítani
int szeles_ido=0;                  //A szeles idő másodpercben mért értéke a nap során
int szel_mentes_ido;               //a szélmentes idő másodpercben mért értéke a nap során
int ejfel=0;                       //az éjfél óta eltelt idő percekben

void setup() {
  pinMode(2,INPUT);            //2-es kivezetésre kötöttem a kontaktus jelét             
  digitalWrite(2,HIGH);        //felhúzó ellenállás bekapcsolása    
  elozo=digitalRead(2);        //máris vezünk egy mintát a bemenetből
  pinMode(3,INPUT);            //3-es kivezetésre kötötjük a nyomógombot             
  digitalWrite(3,HIGH);        //felhúzó ellenállás bekapcsolása    
  lcd.init();
  lcd.clear();
  lcd.backlight();             //háttérvilágítás bekapcsolása
  lcd_vilagitas=HIGH;          //ezzel jelezzük, hogy világít a háttérvilágítás, csak akkor lépteti a program a kijelzett adatot
                               //a képernyőn, ha világít a háttérvilágítás (az első gombnyomás 60 másodpercre bekapcsolja)
}

void loop() {
  /***********************************************************************************************************
   * Ezek a programrészek a szélsebességmérő kontaktusait figyelik, és mérik a forgási időt, kontaktusszámot *
   * és az eredményeket elhelyezik a megfelelő változókban.                                                  *
   **********************************************************************************************************/
  most=digitalRead(2);             //a pillanatnyi kontaktus állapot beolvasása
  if(elozo==LOW and most==HIGH) {  //felfutó él
    nemforog_ido=millis();         //minden kontaktusnál elindítjuk a nemforgás időzítőt, 5 másodperc múlva tekintjük úgy, hogy áll a szélkerék
    all=false;                     //forog a szélkerék
    imp_10sec++;                   //10 másodperces impulzus számláló növelése
    imp_atlag++;                   //napi impulzusszámláló növelése
    if (imp==0) {imp++;}           //egy fordulat idejének meghatározásához két impulzust kell leszámolni, ez volt az első
    if (imp==1) {ford_ido=millis()-ido_tmp;ido_tmp=millis();imp=0;} //megvolt a második impulzus, az egy fordulat idejének kiszámolása
                                                                    // időpillanat változó törlése következő méréshez
  }
  elozo=most;
  
  if (millis()>nemforog_ido+5000) {                             //ha 5 másodperc alatt sem ad egyetlen impulzust sem, akkor úgy tekintjük nulla a szélsebesség
    imp=0;
    pill_szelseb=0;
    all=true;
  }
  
  if (millis()>ido_tmp_10+10000) {                              // 10 másodpercenként nullázom az imp_10sec változót, kiszámolom a széllökést és tárolom a maximumát
    napi_atlag_seb=(((float)(imp_atlag)/2)*2.5)/szeles_ido;     //napi átlag a napi impulzusszámból és a szeles (amikor forog a kerék akkor növeljük másodpercenként) 
                                                                //másodpercek számából
    szellokes=((float)(imp_10sec)/20)*2.5;                      //10 másodperces széllökés értékének frissítése
    if (szellokes_max<szellokes) {szellokes_max=szellokes;}     //széllökés maximum frissítése
    imp_10sec=0;                                                //újra kezdjük a 10 másodperc alati impulzusok mérését
    ido_tmp_10=millis();                                        //elkezdődik a 10 másodperc mérése ezzel a kezdőértékkel
  }
  
  if (millis()>szelkerek_ido+1000) {                              //egy másodpercenként frissítem a pillanatnyi szélsebesség értékét,  
                                                                //ha éppen az időt állítjuk be, akkor nem  számoljuk az impulzusokat, mert ott delay() van!
    if (!all) {                                                 //nem áll a szélkerék, lehet sebességet számolni
      pill_szelseb=2.5*(1000/(float)ford_ido);                  //pillanatnyi szélsebesség kiszámítás egy körülfordulás idejéből
      szeles_ido++;                                             //növeljük a szeles idő idejét másodperc alapon mérő számlálót az átlag sebesség meghatározáshoz
    }
    else {szel_mentes_ido++;}                                   //növeljük a szélmentes idő értékét 1 másodperccel (áll a szélkerék)
    szelkerek_ido=millis();                                       //innen indul egy új egy másodperces időzítés
  }

   
  if (ejfel>=1440) {imp_atlag=0;szeles_ido=0;ejfel=0;}           //24 óra elteltével nullázzuk a napi impulzusgyüjtőt és a napi szeles idő változóját, és 
                                                                //újra indul az ejfel szamlaló, ami percenként növekszik. 24 óra 1440.

  if (millis()>percidozito+60000) {                             //egy percenként növeljük az ejfel változót
    ejfel++;                                                    
    percidozito=millis();
  }

  /*************************************************************************************************************************************
   * Az itt következő programrészek a nyomógombot figyelik. Megtörténik a prellmentesítés. Mivel a hosszú megnyomásnak                 *
   * szerepe van, a nyomógomb elengedés indítja az akciókat. Egy megnyomás bekapcsolja a háttérvilágítást (ez a nyomógomb lenyomással  *
   * törtéik nem az elengedéssel). Ha már világít a háttérvilágítás, akkor növeljük a kijelzett adat indexértékét. Ha hosszan          *
   * nyomvatartjuk az időkijelzés óra és perc felirattal jelzett állapotában, akkor az óra illetve a perc értékét növeli               *
   * ciklikusan, ha elérte a 23-at (óra) illetve az 59-et (perc), akkor 0-ról indul újra. Ha egy ilyen bállítás után                   *
   * elengedjük a gombot, akkor ezzel be is állítottuk az órát.                                                                        *
   *************************************************************************************************************************************/
  //megnyomta a nyomógombot, de még lehet, hogy prelles
  if (digitalRead(3)==LOW and nyomva==LOW) {    //megynomta a setup gombot
    nyomva_ido=millis();  //prellmentesítéshez ezzel indul az 50msec időzítése
    nyomva=HIGH;  //innen tudjuk, hogy már történt egy kontaktus, 50 msec múlva már biztosan prellmentes
    lcd.backlight();vilagitas_ido=millis();   //bekapcsoljuk a háttérvilágítást, és elindítjuk a kikapcsolási időzítést
                                          //lcd_vilagitas változót még nem billentjük be, az fogja jelezni később, hogy lehet léptetni 
                                          //a kijelzett adat indexét

    }    
  //ha 50msec mulva is nyomva tartja,akkor ez már nem prelles, biztosn nyomva van, lehet belépni a setup folyamatba
  if (digitalRead(3)==LOW and millis()>nyomva_ido+50 and nyomva==HIGH) {setup_mod=HIGH;}       //mar itt is lehetne növelni a kijelzett adat index értékét
                                                                                               //de az óra beállítás miatt az elengedéskor növelek (ha már 
                                                                                               //bilágít a háttérvilágitás, mert ha nem akkor csak azt bekapcsolom)
                                                                                               //ha 1 másodpercnél tovább nyomom, és nem az órabeállításban vagyok
                                                                                               //akkor nem fog történni semmi
  //elengedte a nyomógombot, de még lehet, hogy prelles
  if (digitalRead(3)==HIGH and elengedve==LOW and nyomva==HIGH) {elenged_ido=millis();elengedve=HIGH;}
  //már 50msec óta elenged, biztosan nem prelles, beállítási értéket váltunk, lehet várni az új megnyomásra
  if (digitalRead(3)==HIGH and elengedve==HIGH and millis()>elenged_ido+50)                    //amikor elengedjük a nyomógombot, akkor váltjuk a kijelzett értéket
                                                                                               //Ha azonban nem világított a háttérvilágítás, akkor ez a gombnyomás
                                                                                               //csak bekapcsolja azt, és nem léptet 
  {
    nyomva=LOW;
    elengedve=LOW;
    Serial.println(lcd_vilagitas);
    if (lcd_vilagitas==LOW) {lcd_vilagitas=HIGH;}  //ezzel elnyeljük az első nyomógomb lenyomást, ha nem világított a háttérvilágítás (csak bekapcsoljuk azt)
    else {                     //már világit a háttérvilágítás, lehet az adatindexet növelni
      adat_index++;
      if (adat_index>7) {adat_index=0;}            //a legutolsó adat után újra a legelső adatot fogjuk kiírni
      frissit=true;                                //azonnal frissíteni kell a képernyőt, mert gombnyomás történt
      vilagitas_ido=millis();                          //innen indul a 60 másodperc időzítés a háttérvilágítás kikapcsolására
    }
  } 

  if (millis()>vilagitas_ido+60000)   //ha 60 másodperce nem nyúlt a nyomógombhoz akkor a háttérvilágítást kikapcsoljuk 
  {
    lcd_vilagitas=LOW;
    lcd.noBacklight();
  }

  if (digitalRead(3)==LOW and setup_mod==HIGH and nyomva==HIGH and millis()>nyomva_ido+1000)   //egy másodpercig nyomvatartotta, változtatjuk az óra vagy a perc értékét
                                                                                               //elengedéskor az éjfél óta eltelt időt már be is állítottuk 
  {
    ora=ejfel/60;                               //ejfel változóból kiszáítjuk az óra értékét
    perc=ejfel-(ora*60);                        //ejfel változóból kiszámítjuk perc értékét
    if (adat_index==6) {                      //ha az éppen kijelzett adat az óra volt, akkor óra értékét fogjuk növelni
      do {
        ora++;if (ora>23) {ora=0;}
        lcd.setCursor(11,1); 
        lcd.print(ora);lcd.print("  ");       //kiírjuk az óra aktuális értékét
        ejfel=ora*60+perc;                    //minden növelési ciklusban kiszámítjuk ejfel értékét
        delay(700);
      } while (digitalRead(3)==LOW);          //addig fut a ciklus, amíg nyomjuk a gombot
    }
    if (adat_index==7) {
      do {
        perc++;if (perc>59) {perc=0;}
        lcd.setCursor(12,1); 
        lcd.print(perc);lcd.print("  ");
        ejfel=ora*60+perc;
        delay(700);
      } while (digitalRead(3)==LOW);
    }
    setup_mod=LOW;                             //kilépünk a setup módból, gombnyomás mentes álapot jut érvénre, frissül a képernyő másodpercenként az aktuálisn kijelzett adattal
    frissit=true;                              //azonnal frissíteni kell a képernyőt, mert változtattunk az idő értékén
    nyomva=LOW;                                //elengedtük a nyomógombot
    percidozito=millis();                      //innen indítjuk az egy perc időzítését az éjfel szamlaló növeléséhez
    vilagitas_ido=millis();                    //innen indul a 60 másodperc időzítés a háttérvilágítás kikapcsolására
  }

  /*******************************************************************************************************************************
   * Ebben a részben a kijelzőn megjelenő adatot frissítjük másodpercenként. Hogy mit lehet látni a kijelzőn azt az adat_index   *
   * változó dönti el, amit a nyomógomb lenyomásokkal tudunk változtatni, növelni 0 és 7 között. A 6. és 7. index érték          *
   * esetén az időt jelezzük ki, és ha ekkor megnyomjuk hosszan a nyomógombot, akkor a perc illetve az óra értéke változtatható  *
   * amit a nyomógomb elengedésekor azonnal frissítünk is.                                                                       *
   *******************************************************************************************************************************/
  if (millis()>kijelzo_valtas_ido+1000 or frissit) {  //két másodpercenként frissítjük a mért értékeket, ha éppen beállítjuk 
                                                                   //az éjfélig hátralévő időt, akkor nem
    frissit=false;  //ettől kezdve már csak másodpercenként frissítünk
    switch (adat_index) {
       case 0:         //pillanatnyi széllsebesség értékének kiírása
        lcd.setCursor(0,0);lcd.printstr("Pill. szelseb:  ");
        lcd.setCursor(0,1);lcd.printstr("            km/h");
        lcd.setCursor(poz_szam(pill_szelseb)+5,1);lcd.print(pill_szelseb,1);  //egy tizedesjegy hosszan kiírjuk a pillanatnyi szélsebességet
                                                                              //a kiírás kezdő pozicióját a szélsebesség nagyságrendje határozza meg,
                                                                              //hogy ne vándoroljon a kiírt szám, így a tizedespont egy helyben marad
        break;
       case 1:         //széllökés értékének kiírása
        lcd.setCursor(0,0);lcd.printstr("Szellokes:      ");
        lcd.setCursor(0,1);lcd.printstr("            km/h");
        lcd.setCursor(poz_szam(szellokes)+5,1);lcd.print(szellokes,1);
        break;
      case 2:         //széllökés maximum értékének kiírása
        lcd.setCursor(0,0);lcd.printstr("Szellokes max.: ");
        lcd.setCursor(0,1);lcd.printstr("            km/h");
        lcd.setCursor(poz_szam(szellokes_max)+5,1);lcd.print(szellokes_max,1);
        break;
      case 3:         //24 órás átlag sebesség (csak a szeles időszakot vesszük figyelmebe)
        lcd.setCursor(0,0);lcd.printstr("24h atlag seb.: ");
        lcd.setCursor(0,1);lcd.printstr("            km/h");
        lcd.setCursor(poz_szam(napi_atlag_seb)+5,1);lcd.print(napi_atlag_seb,1);
        break;
      case 4:         //szeles időszak idejének kiírása óra perc kijelzéssel (ennyi ideig forgott a szélkerék)
        ora=szeles_ido/3600;
        perc=(szeles_ido-ora*3600)/60;
        lcd.setCursor(0,0);lcd.printstr("Szeles idoszak: ");
        lcd.setCursor(0,1);lcd.printstr("                ");
        lcd.setCursor(7,1);lcd.print(ora);lcd.printstr("o ");lcd.print(perc);lcd.printstr("p   ");
        break;
      case 5:         //szelmentes időszak idejének kiírása óra perc kijelzéssel (ennyi ideig ált a szélkerék)
        ora=szel_mentes_ido/3600;
        perc=(szel_mentes_ido-ora*3600)/60;
        lcd.setCursor(0,0);lcd.printstr("Szelmentes ido- ");
        lcd.setCursor(0,1);lcd.printstr("szak:           ");
        lcd.setCursor(7,1);lcd.print(ora);lcd.printstr("o ");lcd.print(perc);lcd.printstr("p   ");
        break;
      case 6:         //idő kijelzése (ha hosszan nyomjuk a gombot, akkor beállíthatjuk az óra értékét)
        ora=ejfel/60;
        perc=ejfel-(ora*60);
        lcd.setCursor(0,0);lcd.printstr("Ido:            ");
        lcd.setCursor(6,0);
        if (ora<10) {lcd.printstr("0");}
        lcd.print(ora);lcd.print(":");
        if (perc<10) {lcd.printstr("0");}
        lcd.print(perc,2);lcd.printstr("  ");
        lcd.setCursor(0,1);lcd.printstr("Ora beall.:     ");
        break;
      case 7:         //idő kijelzése (ha hosszan nyomjuk a gombot, akkor beállíthatjuk a perc értékét)
        ora=ejfel/60;
        perc=ejfel-(ora*60);
        lcd.setCursor(0,0);lcd.printstr("Ido:            ");
        lcd.setCursor(6,0);
        if (ora<10) {lcd.printstr("0");}
        lcd.print(ora);lcd.printstr(":");
        if (perc<10) {lcd.printstr("0");}
        lcd.print(perc);lcd.printstr("  ");
        lcd.setCursor(0,1);lcd.printstr("Perc beall.:     ");
        break;
    }
    kijelzo_valtas_ido=millis();
  }
  
}

/******************************************************************************************
 * Ez a függvény a kijelzés kezdő poziciójához ad vissza egy eltolási értéket a kijelzett *
 * szám nagyságától függően                                                               *
 ******************************************************************************************/
byte poz_szam(byte adat)  //Az adat változóba beolvasott szám nagyságától függően 0,1,2-t ad vissza a kiírás könnyítéséhez
{
    if (adat<100) {                              //ha kisebb mint 10, akkor kettővel vagy eggyel kell eltolni a számot
      if (adat<10) {return 2;} else {return 1;}  //ha tiznél kisebb akkor eggyel kell eltolni
    } else {return 0;}                           //ha 100-nál nagyobb akkor nincs eltolás
}