Magyarul beszélő óra gyengén látóknak

/***********************************
* Ledmatrix kivezetések bekötése:  *
* D3 - CS                          *
* D4 - CLK                         *
* D5 - DIN                         *
* D2 - Nyomógomb                   *
* D6 - Mp3 busy jel bemenet        *
* D10 - RX                         *
* D11 - TX                         *
* A0 - TEKT4400 fototanzisztor     *
************************************/
#include <EEPROM.h>
#include <Wire.h>
#include "Arduino.h"
#include "SoftwareSerial.h"       //használunk egy szoftveres soros portot, hogy megmaradjon a valódi soros port a fejlesztéshez, hibakereséshez
#include "DFRobotDFPlayerMini.h"  //MP3 lejátszó programkönyvtára

SoftwareSerial mySoftwareSerial(10, 11); // RX, TX   //beállítjuk a szoftveres soros portot, csak a TX kimenetet fogjuk használni belőle, mert az mp3 lejátszó nem küld semmit
DFRobotDFPlayerMini myDFPlayer;                      //myDFPlayer néven fogunk hivatkozni erre az mp3 lejátszó példányra

//Az óra használatához szükséges dolgok
#define CLOCK_ADDRESS 0x68  //a modulon található óra IC címe az I2C buszon. 

struct dat_ido {      // a dátum és idő beállításához illetve kiolvasásához létrehozunk egy struktúrát dat_ido néven (változó típus)
  int ev;             //év tárolása a struktúrában (évszázadokkal kell megadni, illetve így kapjuk meg az eredményt a dátum kiolvasásakor)
  byte ho;            //ho tárolása a struktúrában
  byte nap;           //nap tárolása a struktúrában
  byte het_napja;     //hét napja a struktúrában (1-hétfő....7-vasárnap)
  byte ora;           //óra tárolása a struktúrában (24 órás üzemmódot fogunk használni)
  byte perc;          //perc tárolása a struktúrában
  byte masodperc;     //másodperc tárolása a struktúrában
  bool pontos;        //ez a változó fogja megadni az IDO kiolvasását követően, hogy pontos-e a kiolvasott időpont 
                      //(ha elemes működés közben leáll a DS3231 oszcillátora, akkor az "OSF" flag bebillen, és ezt olvassuk ki
};

dat_ido ds3231;  //létrehozzuk az dat_ido típusú változónkat DS3231 változó néven


const byte font[] = {              //karakterképek 8x8 bites karaktertérképen balra rendezve (utolsó két oszlop üres)
                                   //minden byte egy-egy sor egymás alatt, legelső a legfelső
120,204,204,204,204,204,204,120,   //0 karakterkép
48,112,48,48,48,48,48,120,         //1 karakterkép
120,204,12,24,48,96,192,252,       //2 karakterkép
120,204,12,120,12,12,204,120,      //3 karakterkép
28,60,108,204,204,252,12,12,       //4 karakterkép
252,192,192,248,204,12,204,120,    //5 karakterkép
56,96,192,248,204,204,204,120,     //6 karakterkép
252,204,12,24,48,96,192,192,       //7 karakterkép
120,204,204,120,204,204,204,120,   //8 karakterkép
120,204,204,124,12,12,204,120,     //9 karakterkép
0,0,0,0,0,0,0,0};                  //üres karakterkép

const byte honap_font[]= {                                 //A hónap rövidített feliratai 8x16 képpontban (egy sor két egymást követő byte)
0,0,51,34,20,178,20,178,23,170,20,166,148,166,100,162,        //JAN
0,0,238,206,136,169,136,169,204,206,136,169,136,169,142,201,  //FEBR
0,128,136,28,217,146,170,82,138,92,139,210,138,82,138,82,     //MÁR
32,0,7,56,100,164,148,164,151,56,244,36,148,36,148,36,        //ÁPR
0,128,136,6,217,130,170,66,138,66,139,194,138,82,138,76,      //MÁJ
1,0,48,34,20,178,20,178,20,170,20,166,148,166,99,34,          //JÚN
1,0,48,32,20,160,20,160,20,160,20,160,148,160,99,60,          //JÚL
0,0,100,152,148,164,148,160,244,172,148,164,148,164,147,28,   //AUG
0,0,111,118,129,69,129,69,66,118,36,68,40,68,207,116,         //SZEP
0,0,100,190,148,136,149,8,150,8,149,8,148,136,100,136,        //OKT
0,0,137,145,202,81,202,81,170,81,154,74,154,74,137,132,       //NOV
0,0,231,152,148,36,148,32,151,32,148,32,148,36,231,152,       //DEC
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                             //üres

const byte het_font[]= {                                   //hét napjainak rövidített feliratai 8x16 képpontban
1,0,144,62,151,136,148,8,247,8,148,8,148,8,151,136,           //HET
0,0,151,184,148,36,164,36,199,36,164,36,148,36,151,184,       //KED
0,0,119,188,128,160,128,160,97,56,18,32,20,32,231,188,        //SZE
0,36,99,128,148,36,132,36,131,36,128,164,144,164,103,24,      //CSÜ
1,0,224,34,151,178,148,50,231,42,132,38,132,38,135,162,       //PÉN
0,0,119,152,128,164,128,164,97,36,18,36,20,36,231,152,        //SZO
0,0,137,142,138,80,138,80,139,204,82,66,82,66,34,92,          //VAS
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                             //üres

const byte start_font[]= {                                   //START felirat 8x32 képpontban
0,0,0,0,115,231,57,240,128,136,164,64,128,136,164,64,
112,143,184,64,8,136,164,64,8,136,164,64,112,136,164,64};

const byte setup_font[]= {                                   //SETUP felirat 8x32 képpontban
0,0,0,0,115,239,162,240,130,2,34,136,130,2,34,136,
115,194,34,240,10,2,34,128,10,2,34,128,115,226,28,128};

const byte aut_font[]= {                                   //NYÁRI: felirat 8x24 képpontban, és utolsó kijelzőn BE,KI felirat
0,0,0,0,0,0,16,0,231,132,0,0,0,148,148,149,38,64,148,164,
213,85,80,231,196,242,118,64,148,164,178,85,80,148,148,
146,85,64,231,148};

const byte ev_font[]= {                                   //az év beállításhoz használt felirat 8x24 képpontban
0,49,128,64,74,64,0,10,64,212,10,64,                       //ÉV:20
149,18,64,212,34,64,137,66,64,200,121,128};

const byte hang_font[]= {                                   //a hangerő beállításához használt felirat 8x24 képpontban
16,1,0, 48,16,128, 240,136,64, 244,68,64,                       //Hangszóró ikon hanghullámokkal
244,68,64, 240,136,64, 48,16,128, 16,1,0};

const byte bsta_font[]= {                                   //az óránkénti idő bemondás első időpontja (órája)
0,0,0, 16,192,0, 52,193,0, 242,193,128,                       //hangszóró ikon faltól induló nyíl
242,255,192, 242,193,128, 52,193,0, 16,192,0};

const byte bsto_font[]= {                                   //az óránkénti idő bemondás utolsó időpontja (órája)
0,0,0, 16,0,192, 52,4,192, 242,6,192,                       //hangszóró ikon falnak ütköző nyíl 
242,255,192, 242,6,192, 52,4,192, 16,0,192};

const byte ff_no_font[]= {                                   //hangszóró ikon, férfi és nő jel, utolsó kijelzőn FF,NŐ felirat
0,0,0,0,5, 16,112,16,0,5, 52,136,32,0,0, 242,137,192,238,146,
242,82,32,136,213, 242,34,32,204,245, 52,114,32,136,181,
16,33,192,136,146};

const byte cfok_font[]= {0,70,169,72,8,8,9,6,};               //celsius fok karakterképe 8x8 képpontban

const byte ho_tabla[] {  //Március utolsó vasárnapjának dátuma és október utolsó vasárnapjának dátuma 2021-2050-ig 2 byte-on
28,31,27,30,26,29,31,27,30,26,29,25,28,31,26,29,
25,28,31,27,30,26,28,31,27,30,26,29,25,28,30,26,
29,25,28,31,27,30,25,28,31,27,30,26,29,25,27,30,
26,29,25,28,31,27,29,25,28,31,27,30
};

//A MAX7219 chip paramcsai
const byte decode_mode=9;     //MAX7219 beállításakor a decode mód regiszter címe
const byte scan_limit=11;     //MAX7219 beállításakor scan imit regiszter címe
const byte intenzity=10;      //MAX7219 beállításakor intenzitás regiszter címe
const byte shut_down=12;      //MAX7219 beállításakor shut down mód regiszter címe
const byte disp_test=15;      //MAX7219 beállításakor a disp test regiszter címe

//A MAX7219 chip felé menő kivezetések
const byte adat_kimenet=5;     //MAX7219 adat in bemenetének vezérlésére szolgáló Arduino kimenet száma 
const byte cs_kimenet=3;       //MAX7219 CS bemenetének vezérlésére szolgáló Arduino kimenet száma
const byte clk_kimenet=4;      //MAX7219 CLK bemenetének vezérlésére szolgáló Arduino kimenet száma
const byte idozites=10;        //Késleltetetés ideje mikrosec-ben a MAX7219 adat beírás bitjei között
const byte sw=2;

//Fénymérés TEPT4400 fotó tranzisztorral. A rövidebb láb a kollektor, ez megy a tápfesz 5V-ra
//A hosszabb láb az emitter, ez egy 1Kohm ellenálláson keresztül megy a földre. Az emitterből
//vezetem a mérendő feszültséget az A6 bemenetre. Sötétben a mért fesz 0 körül, napsütésben 
//1000 körül. Megvilágítva nyit ki a tranzisztor és felhúzza a jelvezetéket a tápfeszre.
//A méréskor a tápfeszt veszem referenciának! Ez a program egy árnyékos szobában fog órát
//működtetni, ezért soha nem nyit ki a tranzisztor, mert nem süt rá a nap. Ezért 0 és 
//200-300 körüli értékek fordulnak elő. Sötétedéskor 0 és 10 körüli értékek fordulnak elő
//ezért nagyon nem lineárisan lettek elosztva a fényerő szintek.
int mert_fenyero[10]={0,0,0,0,0,0,0,0,0,0}; //az utolsó 10 mért fényerő értéke
int fenyertek=0;                            //az utolsó 10 mért fényerő érték átlaga
int pill_fenyero,elozo_fenyero;

byte aut_atall=1;
byte hang;       //hangerő értéke az idő és dátum kimondásakor
byte bsta;         //óránkénti bemondás első időpontja (órája)
byte bsto;         //óránkénti bemondás utolsó időpontja (órája)
bool ff_no=0;         //ha ennek értéke 1, akkor az mp3 által lejátszandó file indexéhez 95-öt hozzáadok, mert onnan kezdődnek ugyanazok a szavak, csak férfi hangon

bool szoko_ev;  //szökőév jelzéséhez
float homerseklet;

long ido_tmp=millis();    //egy másodperces óra lekérdezéshez segédváltozó, óra setup alatt az állított érték villogtatásához
long ido_tmp1=millis();
bool pont=0;
bool ora_setup=0;  //ha hosszú ideig nyomjuk a gombot, akkor az óra átmegy setup módba, ekkor értéke 1
byte setup_fazis=0;  //az óra beállítás fázisait jelzi 0-év,1-hó,2-nap,3-óra,4-perc,5-aut.nyári átállás, 
                     //6-hangerő, 7-bemondást kezdő időpontja (órája), 8-bemondás záró időpontja (órája), 9-Férfi női hang
bool sw_allapot1;  //nyomógomb állapot ciklus elején
byte lassit;       //segédváltozó ahhoz, hogy setup-ban a nyári óraállítás BE illetve KI felirata ne váltson olyan gyorsan

long sw_time;                  //nyomógomb lenyomás idejének figyeléséhez segédváltozó
bool sw_allapot=0;             //nyomógomb lenyomott állapota esetén 1
long vissza_time;               //visszakapcsolás óra kijelzés üzemmódba segédváltozója (20 sec időzítéséhez használom)
bool ism_tilt1=0;               //1-es gombon a hosszan nyomva tartá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;                 //nyomógomb rövid megnyomásakor lezajló folyamat követésére. 0-időkijelzés,1-dátum kijelzés,2-hőmérséklet kijelzés
byte szamol=0;                  //ezzel lassítom az üzemmód váltást, mert egy adatot 2 sec ideig akarok kint tartani, de a ciklus másodpercenként fut 

byte szo[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //ebben a tömbben gyűjtöm össze a kimondandó szó részek indexeit.
                           //Maximum 15 állományt fogunk tudni lejátszani, ha már nincs több lejátszandó, 
                           //akkor a következő tömbelem 0. Ha van 15 lejátszandó, akkor az index érték lesz
                           //15, és innen tudjuk, hogy le kell állítani a lejátszást
byte index=0;              //ez mondja meg, hogy éppen melyik állományt kell lejátszani. Ha értéke 15, akkor
                           //nincs lejátszás illetve már befejeztük. 15-re állítjuk az utolsó lejátszott állomány esetén is.
                           //A lejátszás indításakor 0-ra kell állítani a kezd nevű változót pedig 1-re.
long varakozas=millis();   //amikor elindítom a lejátszást, a lejátszón a busy jelvezeték nem vált azonnal 1-re, illetve
                           //rövid ideig még változik is. Ezért várok egy kis időt, amíg figyelni kezdem. Ehhez kell!
//ezek a konstansok csak a program könnyebb értelmezése miatt kellenek
const byte januar=60,elso=29,honap=87,hetfo=53,ora=84,perc=85,szunet=95;
const byte minusz=45,nulla=1,egy=2,ketto=3,tiz=11,husz=12,szaz=20,tizen=42,huszon=43,ezer=46,millio=47,milliard=48,egesz=49,ezred=50,szazad=51,tized=52;
byte bemond_fazis=0;
long setup_kilep=millis();

void setup() {
  Wire.begin();
  Serial.begin(115200);
  
  pinMode(6,INPUT);        //ide kötöttem az mp3 lejátszó busy jelét
  
  mySoftwareSerial.begin(9600);               //inicializáljuk a szoftveres soros portot
  if (!myDFPlayer.begin(mySoftwareSerial)) {  //mp3 lejátszó inicializálása. Ha nem sikerült, akkor 0
    //Serial.println("MP3 player hiba!");       //valami hiba volt, nincs jól csatlakoztatva az mp3 lejátszó a 10 és 11-es kimenetekhez, vagy nincs benne sd kártya
                                              //mivel a soros port visszatérő ágát már be sem kötöttem (Arduino RX, ebben a programban 10-es kivezetés), ezért itt már 
                                              //nem igazán várhatok valós hibajelzést :-), ezért nem is kell ez a sor
  }
  //Serial.println("MP3 player OK!");           //mp3 lejátszó kész a működésre, csak fejlesztéskor kell ez a sor

  pinMode(adat_kimenet,OUTPUT);    //MAX7219 adatbemenete felé menő kimenet
  pinMode(cs_kimenet,OUTPUT);      //MAX7219 CS bemenete felé menő kimenet
  pinMode(clk_kimenet,OUTPUT);     //MAX7219 órajel bemenet felé menő kimenet
  digitalWrite(cs_kimenet,1);      //a max7219 CS bemenete 1-en van, amikor nincs kiválasztva, és nem kommunikálunk vele
  //MAX7219 alapértelmezett beállításai
  matrix_setup(disp_test,0);       //Display test kikapcsolva (minden led világítana, ha nem kapcsoljuk ki)
  matrix_setup(decode_mode,0);     //Decode mód kikapcsolása
  matrix_setup(scan_limit,7);      //Scan limit regiszter beállítása (8 számjegy kijelzését kapcsoljuk be)
  matrix_setup(shut_down,1);       //Shutdown kikapcsolva
  matrix_setup(intenzity,15);      //Intenzitás maximum
  //Kijelző törlése
  for (byte sor=0;sor<8;sor++) {   //Minden kijelzőn egyszerre írjuk ugyanazt a led sort
    digitalWrite(cs_kimenet,0);    //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,0);
    kileptet(sor+1,0);
    kileptet(sor+1,0);
    kileptet(sor+1,0);
    digitalWrite(cs_kimenet,1);     //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve 
                                    //ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
  pinMode(sw,INPUT);                //nyomógomb bemenete
  digitalWrite(sw,HIGH);            //felhúzó ellenállás be

 //************* Legelső óra beállítás és eeprom tartalom feltöltés ************************************/
  //EEPROM.put(0,(byte)1);       //alapértelmezetten be van kapcsolva az automatikus nyári óraállítás 
                                 //(és november utolsó vasárnapján a kikapcsolása)
  //EEPROM.put(1,(byte)1);       //az adott napon épp van nyári időszámítás 
  //EEPROM.put(2,(byte)15);      //hangerő az időpont kimondáskor
  //EEPROM.put(3,(byte)7);       //óránkénti idő kimondás kezdő időpontja (órája) 
  //EEPROM.put(4,(byte)18);      //óránkénti idő kimondás záró időpontja (órája)
  //EEPROM.put(5,(byte)1);       //Alapértelmezetten férfi hangon beszéljen az óra
  //figyelni kell, hogy a beállított dátumon épp van-e nyári időszámítás, és azzal szinkronban kell 
  //beállítani az eeprom tartalmat az 1-es eeprom címen
  //ds3231.masodperc=30;
  //ds3231.perc=59;
  //ds3231.ora=8;
  //ds3231.het_napja=6;
  //ds3231.nap=28;
  //ds3231.ho=5;
  //ds3231.ev=2022; 
  //setTime24();                 //óra beállítása: négyszög kimenő jelet kikapcsolja, 
                                 //32Khz-s kimenetet kikapcsolja és 24 órás üzemmódot állít be.
                                 //Beállítja a pontos időt a fenti változók értékével 
 //*************************************************/
  analogReference(DEFAULT);          //A tápfeszt veszi referenciának (5V)

  //eepromből áttültjük memória változókba az alapvető működési paramétereket
  EEPROM.get(0, aut_atall);     //automatikus nyári óraállítás
  EEPROM.get(2, hang);          //bemondási hangerő
  EEPROM.get(3, bsta);          //időbemondás kezdő órája
  EEPROM.get(4, bsto);          //időbemondás záró órája
  EEPROM.get(5, ff_no);         //férfi vagy női hang
  
  //bekapcsoláskor megmutatunk minden paramétert 
 // matrix_setup(intenzity,14);       //Intenzitás maximum
  aut_ir(aut_atall,0);
  delay(1000);
  hang_ir(hang,0);
  delay(1000);
  bsta_ir(bsta,0);
  delay(1000);
  bsto_ir(bsto,0);
  delay(1000);
  ff_no_ir(ff_no,0);
  delay(1000);
  homeresklet_ir(getTemperature());
  delay(1500);
  getTime24();
  if (aut_atall==1) {
    atallas_ell();
  }
  ev_ir(ds3231.ev-2000,0);
  delay(1500);

  elozo_fenyero=analogRead(A0);
  myDFPlayer.volume(hang);                      //Hangerőt beállítjuk állítjuk (0-30)
}


void loop() { 
  bemond_vezerles();                                          //ez a függvény indítja a bemondást, ha index változó értékét 0-ra állítottuk
                                                              //és a szo[] tömböt feltöltöttük a bemondandó tartalommal, nincs benn delay
                                                              //a loop fut tovább
  if (index==15 and ora_setup==0) {                           //amikor nyomógombot nyom, és nincs setup mód, és éppen nem is mond semmit,
                                                              //akkor elindítjuk az aktuális idő, aztán pedig a dátum és a hét napjának bemondását
                                                              //Szintén nincs benne delay, éa a loop fut tovább
    if (bemond_fazis==1 or bemond_fazis==2) {idobemondas();}  //egy rövid nyomógomb megnyomás a bemond_fazis változót 1-re álltja, és 
                                                              //ekkor indul a pillanatnyi idő és dátum bemondása
    if (bemond_fazis==3) {datumbemondas();}
  }
  //itt jönnek a nyomógomb ellenőrzés lépései
  //rövid (kisebb mint 700msec megnyomás indítja a dátum és hőmérséklet kijelzést, és a bemondást, ha épp a start és stop időpontok között vagyunk
  //Hosszú megnyomás setup módban (nagyobb mint 800msec) lépteti az éppen aktuális adat értékét a beállítandó adat kiválasztásához (év, hónap, nap stb.)
  //Hosszú megnyomás ha még nem vagyunk setup módban (nagyobb mint 5sec), elindítja a setup módot
  sw_allapot1=digitalRead(sw);    
  if (sw_allapot1==LOW and sw_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;sw_allapot=1;sw_time=millis();
    vissza_time=millis();
  } 
  //ha hosszan nyomva tartotta a gombot, valamit csinálni kell amikor elengedte  
  if ((ora_setup==0 and sw_allapot1==LOW and sw_time+5000<millis() and sw_allapot==1 and ism_tilt1==0) or    //ha még nem vagyunk setup módban, akkor 5 sec után belépjünk
      (ora_setup==1 and sw_allapot1==LOW and sw_time+800<millis() and sw_allapot==1 and ism_tilt1==0))       //ha már setup-ban vagyunk, akkor 0.8 sec után az adat értékének léptetése indul
  {    
    //itt következik annak levizsgálása, hogy mennyi ideig tartottuk nyomva hosszan a nyomógombot 
    setup_kilep=millis();               //itt épp egy gombnyomásnak van vége, ezért innen indítom a 20 másodperces tétlenségi kilépést a setup módból
    if (ora_setup==0) {                 //nem voltunk setup módban, most az következik, biztos ami biztos, újra átolvassuk a paramétereket az eepromból
      EEPROM.get(0,aut_atall);
      EEPROM.get(2, hang);
      EEPROM.get(3, bsta);
      EEPROM.get(4, bsto);
      EEPROM.get(5, ff_no);
    }
    if (ora_setup==1) {                 //ez a setup mód, akkor lesz ora_setup=1, ha már egyszer benne voltunk ebben az if-ben
                                        //a következő loop() ciklusban vált 1-re, mert előtte még 0, és csak a setup előkészítése történik
      ido_tmp1=millis()-700;            //azért, hogy a következő do ciklus belső feltétele biztosan igaz legyen, mikor bele lépünk a ciklusba
      lassit=0;                         //ezzel lassítom az automatikus időszámítás értékének váltását. 700msec-enként váltana az érték, 
                                        //ami tül gyors, és ezért nehéz a setup-ban kiválasztani a szükséges állapotot, így csak minden második
                                        //ciklusban változtatom. A többinél nem kell, mert ott számlálókat léptetek, ott ez lenne lassú.
      do {
       sw_allapot1=digitalRead(sw);
        if (ido_tmp1+700<millis()) {
          //ha folyamatosan nyomjuk a gombot, akkor 700msec időnként kerülünk be az if ágba.
          //az éppen aktuális paramétert 700msec-enként növeljük (egy limit után újra 0 lesz)
          ido_tmp1=millis(); 
          switch (setup_fazis) {
            case 0:                                                //ebben a fázisban kiírjuk a setup feliratot, hogy tudja a kezelő, mi következik
              setup_ir(0);
              break;
            case 1:                                                //setup felirat után megnyomta röviden a gombot, villogtatni fogjuk az évet, mert azt lehet beállítani
              ds3231.ev++;if (ds3231.ev>2040) {ds3231.ev=2021;}; 
              ev_ir(ds3231.ev-2000,0);
              break;
            case 2:                                                //év beállítás után megnyomta röviden a gombot, megjelenítjük a hónapot és a napot, villogtatni fogjuk az hónapot, mert azt lehet beállítani
              ds3231.ho++;if (ds3231.ho>12) {ds3231.ho=1;}; 
              dat_ir(ds3231.ho,ds3231.nap,0,0);
              break;
            case 3:                                                //hónap beállítás után megnyomta röviden a gombot, villogtatni fogjuk az napot, mert azt lehet beállítani
              ds3231.nap++;
              szoko_ev=szokoev(ds3231.ev);
              if (
                 ((ds3231.ho==1 or ds3231.ho==3 or ds3231.ho==5 or ds3231.ho==7 or ds3231.ho==8 or ds3231.ho==10 or ds3231.ho==12) and ds3231.nap>31)
                 or
                 ((ds3231.ho==4 or ds3231.ho==6 or ds3231.ho==9 or ds3231.ho==11) and ds3231.nap>30)
                 or 
                 (szoko_ev==0 and ds3231.ho==2 and ds3231.nap>28)
                 or 
                 (szoko_ev==1 and ds3231.ho==2 and ds3231.nap>29)
                 ) {ds3231.nap=1;}; 
              dat_ir(ds3231.ho,ds3231.nap,0,0);
              break;
            case 4:                                               //hónap és nap beállítás után megnyomta röviden a gombot, megjelenítjük az órát és a percet, villogtatni fogjuk az órát, mert azt lehet beállítani
              ds3231.ora++;if (ds3231.ora>23) {ds3231.ora=0;}; 
              ido_ir(ds3231.ora,ds3231.perc,1,0,0);
              break;
            case 5:                                               //óra beállítás után megnyomta röviden a gombot, villogtatni fogjuk a percet, mert azt lehet beállítani
              ds3231.perc++;if (ds3231.perc>59) {ds3231.perc=0;}; 
              ido_ir(ds3231.ora,ds3231.perc,1,0,0);
              break;
            case 6:                                               //óra és perc beállítás után megnyomta röviden a gombot, megjelenítjük a nyári óraállítást, villogtatni fogjuk a a KI illetve BE feliratot, mert azt lehet beállítani
              aut_ir(aut_atall,0);
              lassit++;
              if (lassit==2) {
                if (aut_atall==0) {aut_atall=1;} else {aut_atall=0;} 
                aut_ir(aut_atall,0);
                lassit=0;
              }
              break;
            case 7:                  //Automatikus nyári óraállítás beállítás után megnyomta röviden a gombot, megjelenítjük a hangerő értéket, villogtatni fogjuk a hangerő értékét, mert azt lehet beállítani
              hang++;
              if (hang>30) {hang=1;}  
              hang_ir(hang,0);
              break;
            case 8:                 //Hangerő beállítás után megnyomta röviden a gombot, megjelenítjük a start időpontot, villogtatni fogjuk az óra értékét, mert azt lehet beállítani
              bsta++;
              if (bsta>23) {bsta=0;}  
              bsta_ir(bsta,0);
              break;
            case 9:                //Sttart időpont beállítás után megnyomta röviden a gombot, megjelenítjük a stop időpontot, villogtatni fogjuk az óra értékét, mert azt lehet beállítani
              bsto++;
              if (bsto>23) {bsto=bsta;}  
              bsto_ir(bsto,0);
              break;
            case 10:               //Stop időpont beállítás után megnyomta röviden a gombot, megjelenítjük a férfi és nő állapotot, villogtatni fogjuk az FF illetve NŐ feliratot, mert azt lehet beállítani
              if (ff_no==0) {ff_no=1;} else {ff_no=0;} 
              ff_no_ir(ff_no,0);
              break;
            case 11:
              ora_setup=0;uzemmod=0;sw_allapot1=1;
              break;
          }
        }
      } while (sw_allapot1==0);
    } 
    if (setup_fazis==11) {sw_allapot=1;}
    if (uzemmod==0) {ora_setup=1;} 
  }
  if (sw_allapot1==HIGH and sw_allapot==1) {                     //már nem nyomja az 1-es nyomógombot
    setup_kilep=millis();               //itt épp egy gombnyomásnak van vége, ezért innen indítom a 10 másodperces tétlenségi kilépést a setup módból
    sw_allapot=0;
    if (millis()-sw_time<800 and millis()-sw_time>20) {            //ha 20ms-nél tovább nyomta, de kevesebb mint 800msec-ig, akkor kijelzést váltunk 
                                                                                    //a dátumra és a hőmérsékletre, illetve ha setup módban vagyunk akkor a következő
                                                                                    //beállítandó adatra
      if (ora_setup==0) {           //röviden nyomta és nem volt setup módban, akkor indítjuk a dátum és hőmérséklet kijelzést
        bemond_fazis=1;                                    //ezzel elindul az időbemondás, és azt követően a dátumbemondás
        uzemmod=uzemmod+1;         //sorban jelezzük ki az adatokat, és ez a változó vezéreli, hogy éppen melyiket
        szamol=0;
        ido_tmp=ido_tmp-1000;
        if (uzemmod>3) {uzemmod=0;}  //minden adatot kijeleztünk, felvesszük a nyugalmi helyzetet, az időpont kijelzést
      }
      if (ora_setup==1) {                                  //setup módban voltunk és rövidet nyomott, jön a következő adat, vagy ha utolsón álltunk, 
                                                           //akkor az értékek beírása a DS3231 chip-be és az eeprom-ba


        //ezt még itt fejlesztem
        if (setup_fazis<6)  {   //beállítjuk az időt a DS3231 chip-ben is
          ds3231.het_napja=datum_hetnapja(ds3231.ev,ds3231.ho,ds3231.nap);
          setTime24();
        }
        if (setup_fazis==6)  {   //beírjuk az automatikus nyári óraállítás paraméter értéket az eeprom-ba
          EEPROM.put(0,aut_atall);
        }
        if (setup_fazis==7)  {   // beírjuk a hangerő paraméter értéket az eeprom-ba
          EEPROM.put(2,hang);
          myDFPlayer.volume(hang);                      //Hangerőt beállítjuk állítjuk (0-30)
        }
        if (setup_fazis==8)  {   // beírjuk a bemondás start idő paraméter értéket az eeprom-ba
          EEPROM.put(3,bsta);
        }
        if (setup_fazis==9)  {   // beírjuk a bemondás stop idő paraméter értéket az eeprom-ba
          EEPROM.put(4,bsto);
        }
        if (setup_fazis==10)  {   // beírjuk a férfi-nő paraméter értéket az eeprom-ba
          EEPROM.put(5,ff_no);
          setup_fazis=-1;ora_setup=0;
        }
        setup_fazis++;
      }
    }
  }  
  //ha nem vagyunk setup módban, akkor üzemmod változó mondja meg, hogy mit jelzünk ki
  //uzemmod=0 - időkijelzés
  //uzemmod=1 - dátum kijelzés
  //uzemmod=2 - hét napjának kijelzése
  //uzemmod=3 - hőmérséklet kijelzés
  if (ido_tmp+1000<millis() and ora_setup==0) {
    ido_tmp=millis();
    fenyero_beallitas(); //fénymérés és fényerő beállítás 
    getTime24();
    orankenti_bemondas();   //ellenőrzi, hogy éppen egész óra van-e, és ha igen, akkor elindítja az idő bemondását
    if (uzemmod==0) {
      if (aut_atall==1) {
        atallas_ell();
      }
      if (pont==0) {ido_ir(ds3231.ora,ds3231.perc,1,0,0);pont=1;}
      else {ido_ir(ds3231.ora,ds3231.perc,0,0,0);pont=0;}
    }
    if (uzemmod==1) {
      szamol++;
      if (szamol>2) {uzemmod=2;szamol=0;}
      dat_ir(ds3231.ho,ds3231.nap,0,0);
    }
    if (uzemmod==2) {
      szamol++;
      if (szamol>2) {uzemmod=3;szamol=0;}
      het_ir(ds3231.nap,ds3231.het_napja,0);
    }
    if (uzemmod==3) {
      szamol++;
      if (szamol>2) {uzemmod=0;}
      homeresklet_ir(getTemperature());
    }
  }
  
  //Ha setup módban vagyunk, akkor a setup_fazis mondja meg, hogy éppen milyen adat látszik a képernyőn, 
  //és ha épp nem nyomja folyamatosan a gombot, akkor villogtatjuk is gyorsan az éppen állítható adatot
  if (ora_setup==1) {
    if (setup_kilep+20000<millis() and setup_fazis<10) {ora_setup=0;uzemmod=0;sw_allapot1=0;setup_fazis=0;}  //ha 20 másodpercig egy érték beállításán ácsingózik, akkor kilépünk a setup módból
    if (ido_tmp+25<millis()) {
      //ebbe az if-be 25msec-enként megyünk bele, és egyik alkalommal kijelezzük az éppen állított adatot, másik alkalommal meg nem
      ido_tmp=millis();
      switch (setup_fazis) {
        case 0:     //setup felirat jelzi a beállítás kezdetét
          if (pont==0) {setup_ir(0);pont=1;}
          else {setup_ir(1);pont=0;}
          break;
        case 1:    //év beállításhoz villogtatás
          if (pont==0) {ev_ir(ds3231.ev-2000,0);pont=1;}
          else {ev_ir(ds3231.ev-2000,1);pont=0;}
          break;
        case 2:    //hó beállításhoz villogtatás
          if (pont==0) {dat_ir(ds3231.ho,ds3231.nap,0,0);pont=1;}
          else {dat_ir(ds3231.ho,ds3231.nap,1,0);pont=0;}
          break;
        case 3:    //nap beállításhoz villogtatás
          if (pont==0) {dat_ir(ds3231.ho,ds3231.nap,0,0);pont=1;}
          else {dat_ir(ds3231.ho,ds3231.nap,0,1);pont=0;}
          break;
        case 4:     //óra beállításhoz villogtatás
          if (pont==0) {ido_ir(ds3231.ora,ds3231.perc,1,0,0);pont=1;}
          else {ido_ir(ds3231.ora,ds3231.perc,1,1,0);pont=0;}
          break;
        case 5:     //perc beállításhoz villogtatás
          if (pont==0) {ido_ir(ds3231.ora,ds3231.perc,1,0,0);pont=1;}
          else {ido_ir(ds3231.ora,ds3231.perc,1,0,1);pont=0;}
          break;
        case 6:     //Automatikus átállás nyári időszámításra beállításhoz villogtatás
          if (pont==0) {aut_ir(aut_atall,0);pont=1;}
          else {aut_ir(aut_atall,1);pont=0;}
          break;
        case 7:     //Hangerő beállításhoz villogtatás
          if (pont==0) {hang_ir(hang,0);pont=1;}
          else {hang_ir(hang,1);pont=0;}
          break;
        case 8:     //Bemondás start idő beállításhoz villogtatás
          if (pont==0) {bsta_ir(bsta,0);pont=1;}
          else {bsta_ir(bsta,1);pont=0;}
          break;
        case 9:     //Bemondás stop idő beállításhoz villogtatás
          if (pont==0) {bsto_ir(bsto,0);pont=1;}
          else {bsto_ir(bsto,1);pont=0;}
          break;
        case 10:     //A férfi vagy női hang kiválasztásához ff vagy no villogtatása
          if (pont==0) {ff_no_ir(ff_no,0);pont=1;}
          else {ff_no_ir(ff_no,1);pont=0;}
          break;
      }
    }
  }
}


void bemond_vezerles() {
/***************************************************************************************************
 * Az itt következő programrészek a szo[] tömbben összeállított szavak végig mondását végzik el    *
 * amikor az index változót 0-ra állítjuk, akkor indul a szöveg kimondása. Közben a ciklus fut     *
 * tovább, csak akkor vesz el egy kis időt a következő szöveg elindítása az mp3 lejátszón, amikor  *
 * éppen befejeződött az előző szöveg lejátszása. A 6-os kivezetésen jelenik meg az mp3 lejátszó   *
 * busy jele, ami mindaddig 0, amig épp lejátszik valamit. Mivel a busy jel nem megy le azonnal    *
 * 0-ra lejátszás alatt, hanem változik néhányszor, a hang lejátszás indítása után kell egy kicsit *
 * várni, mielőtt figyelni kezdjük.                                                                *
 ***************************************************************************************************/  
  if (digitalRead(6)==1 and index<15 and millis()>varakozas+200) {   //éppen szabad az mp3 lejátszó, lehet neki parancsot küldeni, ha van mit lejátszani és
                                                                     //eltelt legalább 200msec az utolsó indítás óta, mert a busy jelnek be kell állni 0-ra
                                                                     //a lejátszás indítása után, hogy figyelhessem mikor fejezte be a lejátszást (1-re vált)
                                                                     //Kezdetben 100msec várakozást használtam, de egyes szavak kimondását kihagyta, így 200msec-re
                                                                     //kelet növelni a várakozási időt. 
    varakozas=millis();                                 //elindítjuk a várakozást, amivel várunk egy kicsit mielőtt a busy jelet ellenőriznénk (tranziensek 
                                                        //vannak a lejátszás elindítása után egy ideig a busy jelen)
    if (ff_no==1) {myDFPlayer.play(szo[index]+95);}     //ha férfi, akkor 95-öt kel hozzáadni az index értékhez. 95 női hangú file van és 95 férfi
    else {myDFPlayer.play(szo[index]);}
    index++;
    if (szo[index]==0) {                                //ha az index értékhez tartozó tömbelem 0, akkor azt jelenti, hogy vége a lejátszható részleteknek
      index=15;                                         //index=15 jelzi, hogy éppen nincs lejátszani való
    }
  }                     
}

void orankenti_bemondas() {
  if (ds3231.perc==0 and ds3231.masodperc==0 and ds3231.ora>=bsta and ds3231.ora<=bsto) {
    if (index==15 and ora_setup==0) {
      index=0;ido_szo(ds3231.ora,ds3231.perc,1);
    }
  }
}

void idobemondas() {
  if (bemond_fazis==1) {index=0;ido_szo(ds3231.ora,ds3231.perc,0);}
  bemond_fazis=2;
  if (index==15) {bemond_fazis=3;}
}

void datumbemondas() {
  index=0;datum_szo(0,ds3231.ho,ds3231.nap,1,ds3231.het_napja);
  bemond_fazis=0;
}

byte datum_hetnapja(int ev, byte ho, byte nap)
/*******************************************************************************
 * Ez a függvény paraméterként várja egy dátumból az évet, hónapot és napot.   *
 * Eredményként visszaadja a megadott dátum melyik napja a hétnek. A hét napja *
 * 1től 7-ig megadott érték, az 1 a hétfő, 7 a vasárnap.                       *
 *******************************************************************************/
{
  if (ho<1) { return 0;} //hónap napjainak száma nem lehet 0
  if (ho!=1 & ho!=3 & ho!=5 & ho!=7 & ho!=8 & ho!=10 & ho!=12 & nap>31) { return 0;}; //több napot adtunk meg a hónapnak, mint amennyi napja van
  if (ho!=4 & ho!=6 & ho!=9 & ho!=11 & nap>30) { return 0;} //több napot adtunk meg a hónapnak, mint amennyi napja van
  if (ho==2) { //ha február van, ellenőrizni kell a szökőév szerinti napokat is
    if (szokoev(ev)) { //megmondja, hogy az adott év szökőév-e, mert ha igen, akkor a február 29 napos
    if (nap>29) { return 0;}} //szökőév, és több napot adtunk meg
    else {
    if (nap>28) { return 0;}} //nem szökőév, és több napot adtunk meg
  }
  int ho_napjai[]={0,31,59,90,120,151,181,212,243,273,304,334,365}; //Az évből eltelet hónapok napjainak száma halmozva havonként nem szökőévben
  long elmult_nap=ev*365;                                           //Eddig ennyi napja volt az elmúlt éveknek a szökőévek figyelembevétele nélkül
  int elmult_szokonap=0;                                            //Ebbe a változóba számoljuk ki majd a szökőévekből adódó plusz napok számát
  int szn4=(ev-1)/4;                                                //Minden negyedik év szökőév (kivéve minden 100. év, de azt később levonjuk)
                                                                    //az aktuális évet nem szabad beleszámolni, mert az majd az aktuális év napjaiban benne lesz
  int szn100=(ev-1)/100;                                            //minden 100. év nem szökőév, ezt majd levonjuk, kivéve minden 400. év, azt meg mindjárt hozzáadjuk
  int szn400=(ev-1)/400;                                            //Minden 400. év mégiscsak szökőév
  elmult_szokonap=szn4-szn100+szn400;                               //így megkaptuk a szökőévekből adódó plusz napokat
  long akt_ev_nap=ho_napjai[ho-1]+nap;                              //Az eddig eltelt hónapok napjainak száma kiderül a tömbből, plusz hozzáadjuk az aktuális hónap napjait, ahol épp járunk
                                                                    //Ha az adott év szökőév, és már elmúlt február, akkor még egyet hozzá kell majd adni, mert a tömb egy nem szökőévre készült.
  long akt_ev_szokonap=0;
  if (ho>2) {
    if (szokoev(ev)) {
      akt_ev_szokonap++;                                            // ha az aktuális éveben már elmúlt február, és az év szökőév, akkor még egy napot hozzá kell adni
    }
  }
  long napok=elmult_nap+elmult_szokonap+akt_ev_nap+akt_ev_szokonap; //és ezzel megkaptuk Jézus születésének napja óta eltelt napok számát
  if (napok%7==0) {
    return 7;                                                       //ha pont vasárnap van, akkor maradék nélkül osztható 7-el, ezért ilyenkor 7-et adunk vissza
  }
  else {
    return napok%7;                                                 //a maradék az adott hétben eltelt napok száma (hétfő az 1)
  }
}

bool szokoev(int ev) {
/************************************************************************************
 * Ez a függvény paraméterként várja az évet (pl. 2022) és visszaadja bool értékben *
 * hogy a paraméterben megadott év szökőév, vagy sem.                               *
 ************************************************************************************/
  if (ev==0) {
    return false; //a 0.évet nem vesszük szökőévnek
  }
  bool szoko_ev=false;
  if (ev%4==0) { //ha néggyel osztva nem ad maradékot, akkor szökőév
    szoko_ev=true;
    if (ev%100==0) { //ha 100-al osztva nem ad maradékot, akkor nem szökőév
      szoko_ev=false;
      if (ev%400==0) {
        szoko_ev=true; //ha 400-al osztva nem ad maradékot, akkor mégis szökőév
      }
    }
  }
  return szoko_ev;
}


void atallas_ell() {  
/********************************************************************************************************
 * Ez a függvény ellenőrzi, hogy elérkezett-e a nyári időszámítás átállásának időpontja, s ha igen, és  *       
 * Az óra nincs nyári időszámításban, akkor az aktuális órához hozzáad egyet. Ha elérkezett a nyári     *
 * Időszámítás kikapcsolásának időpontja, akkor pedig levon az órából egyet.                            *
 * Nyári időszámítás bekapcsolása: minden év márciusának utolsó vasárnapján hajnali 2-kor át kell       *
 * állítani az órát 3-ra.                                                                               *
 * Nyári időszámítás kikapcsolása: minden év októberének utolsó vasárnapján hajnali 3-kor vissza        *
 * kell állítani az órát hajnali 2-re.                                                                  *
 *                                                                                                      *
 * A függvény akkor is megoldja az óra állítást, ha az óra nem volt áram alatt, és a DS3231 óra chip    *
 * épp elemről működött. A ds3231 magától nem tud nyári óraállítást végezni.                            *
 ********************************************************************************************************/
  byte akt_marc_dat=ho_tabla[(ds3231.ev-2021)*2];                 //a ho_tabla[] többől kiolvassuk, hogy az adott évben hányadikára esik március utolsó vasárnapja
  byte akt_okt_dat=ho_tabla[(ds3231.ev-2021)*2+1];                //a ho_tabla[] többől kiolvassuk, hogy az adott évben hányadikára esik október utolsó vasárnapja
  byte nyari=0;

  EEPROM.get(1,nyari);                                            //ha nyari=1, akkor ebben a pillanatban az óra nyári időszámtás szerinti 
                                                                  //állapotban van (egy órával később lesz éjfél, mint a valóságban)
  //Ez a programrész akkor fut le, ha az átállás pillanatában a program működik, vagyis a teljes szerkezet áram alatt van, és az Arduino-ban is fut a program.
  if (ds3231.ho==3 && ds3231.nap==akt_marc_dat && ds3231.ora>1 && nyari==0) { //ha márciusban az átállás napján még nincs a nyári időszámításban az óra, és elmúlt éjjel 2 óra, 
                                                                  //előre állítjuk az órát egy órával, vagyis 2 órakor átállunk 3 órára, így az időpont egy órát késik
                                                                  //a tényleges csillagászati időhöz képest, a nap később kel.
    ds3231.ora=ds3231.ora+1;                                      //órát előre állítjuk
    setTime24();                                                  //beálltjuk az órát a hardverben is
    EEPROM.put(1,(byte)1);                                        //eeprom-ba beírjuk, hogy nyári időszámitás üzemmódban vagyunk
  }

  //Ha az óraállítás pillanatában az óra IC elemről működött, és az Arduino-ban nem futott a program, akkor nem lett átállítva nyári időszámtásba. 
  //Ezért ez első ezt követő bekapcsoláskor észre kell venni, hogy nyári időszámitásba kell állni, de ekkor bármilyen későbbi dátum lehet éppen.
  //Ha márciusban a dátum nagyobb mint az átállás dátuma, vagy a hónap már nagyobb mint március, de a hónap kisebb mint október,
  //vagy október de a nap kisebb mint az októberi átállás dátuma, és még nem vagyunk nyári időszámtásban, akkor előre kell állni egy órával. 
  if (((ds3231.ho==3 && ds3231.nap>akt_marc_dat) || (ds3231.ho>3)) && (ds3231.ho<10 || (ds3231.ho==10 && ds3231.nap<akt_okt_dat)) && nyari==0) {
    EEPROM.put(1,(byte)1);                                           //beírjuk az eeprom-ba a nyári üzemmódot

    ds3231.ora=ds3231.ora+1;                                         //előre álltjuk az órát
    if (ds3231.ora==24) {                                            //ha éppen 24 óra lenne a növelés után, akkor valójában egy napot kell hozzáadni és beállítani 0 órára
      ds3231.ora=0;                                                  //0 óra beállítása
      ds3231.nap=ds3231.nap+1;                                       //növeljük a dátumot 1-el.
      ds3231.het_napja=ds3231.het_napja+1;                           //ha a napot növeltük, akkor a hét napját is kell
      if (ds3231.het_napja==8) {  ds3231.het_napja=1;}               //ha épp vasárnap volt, akkor hétfő következik a 8. nap helyett
                                                                     //Ha a nap növelése után az aktuális hónap utolsó napjánál 1-el nagyobb lett a nap, akkor hónapot is kell váltai és a nap=1
      if ((ds3231.ho==3 || ds3231.ho==5 || ds3231.ho==7 || ds3231.ho==8 || ds3231.ho==10) && ds3231.nap>31) { ds3231.nap=1;ds3231.ho=ds3231.ho+1;}   //31 napos hónap esetén a vizsgálat  
      if ((ds3231.ho==6 || ds3231.ho==9) && ds3231.nap>30) {  ds3231.nap=1;ds3231.ho=ds3231.ho+1;}    //30 napos hónap esetén a vizsgálat
    } 
    setTime24();
  } 

  //Ez a feltétele akkor lehet igaz, ha az őszi óraállításkor az Arduino áram alatt van és fut a program. 
  if (ds3231.ho==10 && ds3231.nap==akt_okt_dat && ds3231.ora>2) {     //Ha októberben a téli óraállítás pillanatában éppen nyári időszámításban van a program,
                                                                      //akkor egy órával visszaállítjuk az órát.
    ds3231.ora=ds3231.ora-1;                                          //Az órát eggyel csökkentjük, 3 óra helyett újra 2 óra van, így a mutatott időpont megegyezik a csillagászati idővel
    setTime24();                                                      //Beállítjuk a DS3231 IC-n is az új időpontot
    EEPROM.put(1,(byte)0);                                            //megjegyezzük eepromban is, hogy téli időszámítás szerinti üzemmódban van az óra,
                                                                      //Egy következő ciklusban már nem fog újra lefutni ez a feltétel.
  }

  //Ha az óraállítás pillanatában az Arduino nincs áram alatt, és a DS3231 elemről működik, akkor nem történik meg az óra átállítás.
  //Ekkor az ezt követő első bekapcsoláskor kell az időt visszaállítani egy órával. Ha az óra által mutatott időpont a téli időszámítás
  //előtti pillanatban van (de a nyári időszámítás beállítási időpontja után) és az eeprom szerint nincs téli időszámításban, akkor kell
  //beállítani. Viszont ha a bekapcsolás éjfél és egy óra között történik, akkor nem visszaállítani kell az órát, hanem egy nappal előbbre
  //és 23 órára. Az egy nappal előbbre állítás miatt azonban akár hónapot is kell váltani, ha épp 1.-én ált a naptár.
  //Ha október van, de már elmúlt az óraállítás napja, vagy már elmúlt október, vagy már a következő évben vagyunk és március (nyári óraállítás
  //előtt, vagy már márciusban vagyunk de még nem jött el a nyári óraállítás dátuma, és az óra nincs téli időszámítás időpontban, akkor kell 
  //átállítani az időt.
  if (((ds3231.ho==10 && ds3231.nap>akt_okt_dat) || (ds3231.ho>10) || (ds3231.ho<3) || (ds3231.ho==3 && ds3231.nap<akt_marc_dat)) && nyari==1) {
    EEPROM.put(1,(byte)0);                                           //Az eepromban beállítjuk a téli időszámítást
    if (ds3231.ora==0) {                                             //Ha még 0 óra van, akkor előző napra kell beállni
      ds3231.ora=23;                                                 //Az előző napon ekkor 23 óra van
      ds3231.nap=ds3231.nap-1;                                       //csökkentjük a napot
      ds3231.het_napja=ds3231.het_napja-1;                           //csökkentjük a hét napját
      if (ds3231.het_napja==0) {  ds3231.het_napja=7;}               //ha a hét napja 0 lett (hétfőn fordulhat elő), akkor nem 0 nap következik, hanem 7 (vasárnap)
      if (ds3231.nap==0) {                                           //ha 1.-e volt, akkor hónapot is kell váltani
        ds3231.ho=ds3231.ho-1;                                       //csökkentjük a hónapot
        if (ds3231.ho==0) {                                          //ha a hónap január volt, akkor nem a 0. hónap jön, hanem az előző év decembere
          ds3231.ho=12;ds3231.nap=31;                                //az új dátum december 31
          ds3231.ev=ds3231.ev-1;                                     //csökkentjük az évet 
        }
        if (ds3231.ho==1 || ds3231.ho==3 || ds3231.ho==5 || ds3231.ho==7 || ds3231.ho==8 || ds3231.ho==10) {  ds3231.nap=31;}  //ezekben a hónapokban az előző hónap 31 napos, tehát az előzö nap 31.-e
        if (ds3231.ho==4 || ds3231.ho==6 || ds3231.ho==9 || ds3231.ho==11) {  ds3231.nap=30;} //ezekben a hónapokban az előző honap 30 napos, tehát az előző nap 30.-a
        if (ds3231.ho==2 && szokoev(ds3231.ev)) { ds3231.nap=29;}    //február utolsó napja van, ami 02.29, mert szökőévben vagyunk
        if (ds3231.ho==2 && !szokoev(ds3231.ev)) {  ds3231.nap=28;}  //február utolsó napja van, ami 02.28, mert nem szökőévben vagyunk
      }
    } 
    else {  ds3231.ora=ds3231.ora-1;}                                //nem 0 óra volt, így nyugodtan csökkenthetjük az órát 1-el.
    setTime24();                                                     //beállítjuk az órát az új időpontra
  } 
}


void setTime24() {
/*************************************************************************************************************
* Ezzel a függvénnyel lehet beállítani az időt. Egy dat_ido típusú és ds3231 nevű változót vár a működéshez. *
* Ezt a változót globális változóként célszerű létrehozni. A getTime24() függvény ugyanezt a változót        *
* tölti fel a ds3231 chipből kiolvasott dátummal és időponttal. Ha memóriában átírjuk a dátumot és időt      *
* a ds3231 változóban, akkor ez a függvény beírja a változó aktuális értékét a chip-be.                      *
* A dat_ido struktúra részleteit lásd a getTime24() függvény kommentjeiben!                                  *
**************************************************************************************************************/
  //status regiszter beállítása
  Wire.beginTransmission(CLOCK_ADDRESS);
  Wire.write(0x0e);               //A control regiszterbe fogunk írni, azt címezzük meg
  Wire.write(0b01100011);         //BBSQW bit 1, vagyis elemes táplálásnál is működik az oszcillátor
                                  //ha 1-re állítanánk, elemes táplálásnál nem járna az óra, csak őrizni az utolsó időpontot
                                  //A RS2 és RS1 bit 0-val beállítja a négyszögjel kimenetet 1Hz-ra, ezen lehet változtatni:
                                  // 0b01101011 esetén 1024Khz, 0b01110011 esetén 4096Khz, 0b01111011 esetén 8192Khz.
                                  //A INTCN bit 0-val beállítja, hogy az INT/SQW kimenet beállított frekvenciájú jelet ad ki.
  //címbet a státus regiszter következik, nem kell megcímezni csak írni, és az adat oda kerül
  Wire.write(0b00000000);         //A status regiszterben töröljük az OSF fleg-et, ami 1-el jelzi majd, ha elemes táplálásnál 
                                  //nem működött az oszcillátor, vagyis az óra valószínűleg nem pontos.
                                  //Az EN32Khz bit-et is 0-ra írjuk, azaz letiltjuk a 32Khz-s kimenetet
  Wire.endTransmission();
  //dátum és időpont beállítása
  Wire.beginTransmission(CLOCK_ADDRESS);
  Wire.write(0x00);
  Wire.write(dec_bcd(ds3231.masodperc));
  Wire.write(dec_bcd(ds3231.perc));
  Wire.write(dec_bcd(ds3231.ora) & 0b10111111);
  Wire.write(dec_bcd(ds3231.het_napja)); 
  Wire.write(dec_bcd(ds3231.nap));
  Wire.write(dec_bcd(ds3231.ho));
  Wire.write(dec_bcd(ds3231.ev-2000)); 
  Wire.endTransmission();
}

void getTime24() {
/****************************************************************************************************
 * Ez a függvény kiolvassa a DS3231 RTC óra chip-ből a dátumot és az időt és egy dat_ido típusú és  *
 * ds3231 navű változóba tölti azok aktuális pillanatnyi értékét.                                    *
 * A változót globális változóként célszerű létrehozni a program eljén:                             *
 * struct dat_ido {    // a dátum és idő beállításához illetve kiolvasásához a struktúrát           *
 * int ev;             //év tárolása a struktúrában (évszázadokkal kell megadni,                     *
 *                     //illetve így kapjuk meg az eredményt a dátum kiolvasásakor)                 *
 * byte ho;            //ho tárolása a struktúrában                                                 *
 * byte nap;           //nap tárolása a struktúrában                                                *
 * byte het_napja;     //hét napja a struktúrában (1-hétfő....7-vasárnap)                           *
 * byte ora;           //óra tárolása a struktúrában (24 órás üzemmódot fogunk használni)           *
 * byte perc;          //perc tárolása a struktúrában                                               *
 * byte masodperc;     //másodperc tárolása a struktúrában                                          *
 * bool pontos;        //ez a változó fogja megadni az IDO kiolvasását követően,                    *
 *                     //hogy pontos-e a kiolvasott időpont ha elemes működés közben leáll a        *
 *                     //DS3231 oszcillátora, akkor az "OSF" flag bebillen, és ezt olvassuk ki      *
 *};                                                                                                *
 *dat_ido ds3231;  //létrehozzuk az dat_ido típusú változónkat DS3231 változó néven                 *
 ****************************************************************************************************/
  //kiolvassa a dátumot és az időpontot 
  Wire.beginTransmission(CLOCK_ADDRESS);
  Wire.write(0x00);
  Wire.endTransmission();
  Wire.requestFrom(CLOCK_ADDRESS, 7);
  ds3231.masodperc = bcd_Dec(Wire.read());
  ds3231.perc = bcd_Dec(Wire.read());
  ds3231.ora = bcd_Dec(Wire.read());
  ds3231.het_napja = bcd_Dec(Wire.read());
  ds3231.nap = bcd_Dec(Wire.read());
  ds3231.ho = bcd_Dec(Wire.read() & 0b01111111);
  ds3231.ev = bcd_Dec(Wire.read())+2000;
  //status regiszterből az OSF bit kiolvasása.
  Wire.beginTransmission(CLOCK_ADDRESS);
  Wire.write(0x0f);
  Wire.endTransmission();
  Wire.requestFrom(CLOCK_ADDRESS, 1);
  if (Wire.read()& 0b10000000) {ds3231.pontos=0;} else {ds3231.pontos=1;}  //1-el jelezzük, ha az óra valószínűleg pontos
}

float getTemperature() {
  // Kiolvassa a hőmérséklet értékét a 0x11h és 0x12h regiszterekből
  byte temp;
  Wire.beginTransmission(CLOCK_ADDRESS);
  Wire.write(0x11);         //a DS3231 chip 0x11 és 0x12-es regisztere a hőmérséklet regiszter
  Wire.endTransmission();
  Wire.requestFrom(CLOCK_ADDRESS, 2);         //2 byte-ot kérünk el a chip-től
  temp = Wire.read();                         //hőmérséklet MSB regisztere
  return float(temp) + 0.25*(Wire.read()>>6); //hőmérséklet LSB regiszterének kiolvasása
}

byte bcd_Dec(byte val) {  // Convertál bcd számból decimálisba
  return ( (val/16*10) + (val%16) );
}
byte dec_bcd(byte val) {  // Convertál decimális számból bcd-be
  return ( (val/10*16) + (val%10) );
}

void ido_szo(int xora, byte xperc,bool bing) {
/********************************************************************************************************
 * Ez a függvény a szo[] tömbbe helyezi az idő kimondásához szükséges szavak index értékét kimondáshoz  *
 * szükséges sorrendben.                                                                                *
 * Paraméterek:                                                                                         *
 * ora        - az időpont órája                                                                        *
 * perc       - az időpont perce                                                                        *
 * bing       - az óránkénti bemondásnál szignált tesz a szöveg elé. Speciálisan a szignál a 191. file  *
 *              az SD kártyán, és ezt teszi be első hangnak                                             *
 ********************************************************************************************************/
  for (byte i=0;i<15;i++) {szo[i]=0;}    //tömb törlése
  byte index=0;
  if (bing==1) {szo[index]=191;index++;szo[index]=szunet;index++;}  //szignál az első tömbelembe, a második egy szünet
  byte h_tiz;
  byte h_egy;
  //óra ************************************
  h_tiz=xora/10;
  h_egy=xora-((long)h_tiz*10);
  if ((h_tiz==1) & (h_egy==0)) {szo[index]=tiz;index++;}
  if ((h_tiz==1) & (h_egy>0)) {szo[index]=tizen;index++;}
  if ((h_tiz==2) & (h_egy==0)) {szo[index]=husz;index++;}
  if ((h_tiz==2) & (h_egy>0)) {szo[index]=huszon;index++;}
  if (h_tiz>2) {szo[index]=tiz+h_tiz-1;index++;}
  if (h_egy>0) {szo[index]=egy+h_egy-1;index++;}
  szo[index]=ora;index++;
  if (xperc>0) {
    szo[index]=szunet;index++;    //az óra kimondása után beteszünk 0,2sec várakozást a szöveg tagolása érdekében
    //perc*************************************************
    h_tiz=xperc/10;
    h_egy=xperc-((int)h_tiz*10);
    if ((h_tiz==1) & (h_egy==0)) {szo[index]=tiz;index++;}
    if ((h_tiz==1) & (h_egy>0)) {szo[index]=tizen;index++;}
    if ((h_tiz==2) & (h_egy==0)) {szo[index]=husz;index++;}
    if ((h_tiz==2) & (h_egy>0)) {szo[index]=huszon;index++;}
    if (h_tiz>2) {szo[index]=tiz+h_tiz-1;index++;}
    if (h_egy>0) {szo[index]=egy+h_egy-1;index++;}
    szo[index]=perc;index++;
  }
}

void datum_szo(int ev, byte ho, byte nap, bool ho_nev, byte het_napja)
{
/*********************************************************************************************
 * Ez a függvény a szo[] tömbbe helyezi a dátum kimondásához szükséges szavak index értékét  *
 * kimondáshoz szükséges sorrendben.                                                         *
 * Paraméterek:                                                                              *
 * ev        - a dátumban megadott év, évszázadokkal együtt (pl. 2021). Ha az ev=0,          *
 *             akkor csak a hónapot mondja a hónap nevével                                   *
 * ho        - a dátum hónapja                                                               *
 * nap       - a dátum napja                                                                 *
 * ho_nev    - ha értéke 1, akkor a hónapokat a nevükkel mondja ki pl. "február",            *
 *             ha értéke 0, akkor a hónap sorszámával pl. "második hó"                       *
 * het_napja - ha 0, akkor nem kerül kimondásra a hét napja, ha értéke 1-7 közötti,          *
 *             akkor a dátum végén kimondja a hét napjának nevét is pl. ha 1, akkor "hétfő"  *
 *********************************************************************************************/
  for (byte i=0;i<15;i++) {szo[i]=0;}
  byte index=0;
  byte h_egyezer;
  byte h_egyszaz;
  byte h_tiz;
  byte h_egy;
  int maradek;
  //év ************************************
  szo[index]=szunet;index++;
  if (ev>0) {                           //ha az ev nagyobb mint 0 csak akkor mondjuk ki
    h_egyezer=ev/1000;
    maradek=ev-((long)h_egyezer*1000);
    h_egyszaz=maradek/100;
    maradek=maradek-((long)h_egyszaz*100);
    h_tiz=maradek/10;
    h_egy=maradek-((long)h_tiz*10);
    //ezer  
    if (h_egyezer>1) {szo[index]=egy+h_egyezer-1;index++;szo[index]=ezer;index++;}
    if (h_egyezer==1) {szo[index]=ezer;index++;}
    //ezernél kissebb rész  
    if (h_egyszaz!=0) {szo[index]=szaz+h_egyszaz-1;index++;}
    if ((h_tiz==1) & (h_egy==0)) {szo[index]=tiz;index++;}
    if ((h_tiz==1) & (h_egy>0)) {szo[index]=tizen;index++;}
    if ((h_tiz==2) & (h_egy==0)) {szo[index]=husz;index++;}
    if ((h_tiz==2) & (h_egy>0)) {szo[index]=huszon;index++;}
    if (h_tiz>2) {szo[index]=tiz+h_tiz-1;index++;}
    if (h_egy>0) {szo[index]=egy+h_egy-1;index++;}
    if (ev==0) {szo[index]=nulla;index++;}   //ha a kimondandó szám 0, akkor legalább egy 0-át mondani kell
    szo[index]=szunet;index++;    //az év kimondása után beteszünk 0,2sec várakozást a szöveg tagolása érdekében
  }
  //hónap ***************************************
  h_tiz=ho/10;
  h_egy=maradek-((long)h_tiz*10);
  if (ho_nev==1 or ev==0) {            //ha az ev=0 vagy a paraméter előírja, akkor nevével mondjuk a hónapot
    //hónap nevekkel kimondva
    szo[index]=januar+ho-1;index++;
  }
  else {
    //hónap sorszámmal kimondva
    szo[index]=elso+ho-1;index++;
    szo[index]=honap;index++;
  }
//  szo[index]=szunet;index++;    //a hónap kimondása után beteszünk 0,2 sec várakozást a szöveg tagolása érdekében
  //nap*************************************************
  h_tiz=nap/10;
  h_egy=nap-((int)h_tiz*10);
  if ((h_tiz==1) & (h_egy==0)) {szo[index]=tiz;index++;}
  if ((h_tiz==1) & (h_egy>0)) {szo[index]=tizen;index++;}
  if ((h_tiz==2) & (h_egy==0)) {szo[index]=husz;index++;}
  if ((h_tiz==2) & (h_egy>0)) {szo[index]=huszon;index++;}
  if (h_tiz>2) {szo[index]=tiz+h_tiz-1;index++;}
  if (h_egy>0) {szo[index]=egy+h_egy-1;index++;}
  szo[index]=szunet;index++;
  //het napja*******************************************
  if (het_napja>0) {
    szo[index]=hetfo+het_napja-1;index++;
  }  
}


void hang_ir (byte hang, bool set_hang) { 
/******************************************************************************************************************   
 * Amikor az idő bemondás hangerejét állítjuk be, ez a függvény jeleníti meg a                                    *
 * hangszóró szimbólumot, valamint a hengerő érték számjegyét.                                                    *
 * A hangszóró szimbólumot a hang_font[] tömbből vesszük, a számjegyeket a font[] tömbből.                        *
 * A setupban villogtatni is kell a számjegyet amikor épp beállítjuk az értékét,                                  *
 * erre szolgál a set_hang paraméter. Amikor értéke 0, akkor a számjegyek bitsorozatai                            *
 * bemásoljuk a kijelzőre menő bitsorozatba, amikor értéke 1, akkor csupa 0-át másolunk be.                       *
 * Hol 1-el, hol 0-val hívjuk meg a függvényt így érhető el a villogás.                                           *
 * paraméterek:                                                                                                   *
 * hang:     a hangerő értéke 0-30 között                                                                         *
 * hang_set: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba a           *
 *           a hangerő számjegyeit, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy a                     *
 *           számjegyek villogjanak a képernyőn, mert egyszer 1-el, egyszer pedig 0-val hívjuk meg ezt a függvényt*
 ******************************************************************************************************************/
  byte a1,a2;         //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző mosul van, így mindegyiknek van egy változója
  a1=hang/10;
  a2=hang-a1*10;
  for (byte sor=0;sor<8;sor++) {           //a matrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    b1=hang_font[sor*3];                   //balról első kijelző adott sorának tartalma
    b2=hang_font[sor*3+1];                 //balról második kijelző adott sorának tartalma
    if (set_hang==1) { 
      b3=hang_font[sor*3+2];               //balról harmadik kijlző adott sorának tartalma
      b4=0;                                //a negyedik kijelzőn egyik led-et sem kapcsoljuk be
    }
    else {
      s1=hang_font[sor*3+2];
      s2=font[a1*8+sor];
      s2=s2>>3;
      b3=s1|s2;                            //balról harmadik kijlző adott sorának tartalma
      s1=font[a1*8+sor];
      s2=font[a2*8+sor];
      s1=s1<<5;
      s2=s2>>2;
      b4=s1|s2;                            //balról negyedik kijlző adott sorának tartalma
    }
    //kiléptetjük a bitsorozatot a négy mártix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel 
                                          //a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void bsta_ir (byte bsta, bool set_bsta) {    //az évet évszázadok nélkül kell megadni
  //Amikor az idő bemondás kezdő időpontját (óráját) állítjuk be (bemondás start időpont), 
  //ez a függvény jeleníti meg a hangszóró és faltól induló nyilacska szimbólumot, 
  //valamint kezdő óra érték számjegyét.
  //A szimbólumokat a bsta_font[] tömbből vesszük, a számjegyeket a font[] tömbből.
  //A setupban villogtatni is kell a számjegyet amikor épp beállítjuk az értékét, 
  //erre szolgál a set_bsta paraméter. Amikor értéke 0, akkor a számjegyek bitsorozatai
  //bemásoljuk a kijelzőre menő bitsorozatba, amikor értéke 1, akkor csupa 0-át másolunk be. 
  //Hol 1-el, hol 0-val hívjuk meg a függvényt így érhető el a villogás. 
  //paraméterek:
  //bsta:     a kezdő óra értéke, ami 0 és 24 és ezek közötti numerikus érték lehet
  //bsta_set: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba a 
  //          a záró óra számjegyeit, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy a 
  //          számjegyek villogjanak a képernyőn, mert egyszer 1-el, egyszer pedig 0-val hívjuk meg ezt a függvényt
  byte a1,a2;         //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  a1=bsta/10;
  a2=bsta-a1*10;
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    b1=bsta_font[sor*3];
    b2=bsta_font[sor*3+1];
    if (set_bsta==1) {
      b3=bsta_font[sor*3+2];
      b4=0;
    }
    else {
      s1=bsta_font[sor*3+2];
      s2=font[a1*8+sor];
      s2=s2>>3;
      b3=s1|s2;
      s1=font[a1*8+sor];
      s2=font[a2*8+sor];
      s1=s1<<5;
      s2=s2>>2;
      b4=s1|s2;
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void bsto_ir (byte bsto, bool set_bsto) {    //az évet évszázadok nélkül kell megadni
  //Amikor az idő bemondás záró időpontját (óráját) állítjuk be (bemondás stop időpont), 
  //ez a függvény jeleníti meg a hangszóró és falnak ütköző nyilacska szimbólumot, 
  //valamint záró óra érték számjegyét.
  //A szimbólumokat a bsto_font[] tömbből vesszük, a számjegyeket a font[] tömbből.
  //A setupban villogtatni is kell a számjegyet amikor épp beállítjuk az értékét, 
  //erre szolgál a set_bsto paraméter. Amikor értéke 0, akkor a számjegyek bitsorozatai
  //bemásoljuk a kijelzőre menő bitsorozatba, amikor értéke 1, akkor csupa 0-át másolunk be. 
  //Hol 1-el, hol 0-val hívjuk meg a függvényt így érhető el a villogás. 
  //paraméterek:
  //bsto:     a záró óra értéke, ami a kezdő óra (bsta) és 24 és ezek közötti numerikus érték lehet
  //bsto_set: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba a 
  //          a záró óra számjegyeit, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy a 
  //          számjegyek villogjanak a képernyőn, mert egyszer 1-el, egyszer pedig 0-val hívjuk meg ezt a függvényt
  byte a1,a2;         //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  a1=bsto/10;
  a2=bsto-a1*10;
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    b1=bsto_font[sor*3];
    b2=bsto_font[sor*3+1];
    if (set_bsto==1) {
      b3=bsto_font[sor*3+2];
      b4=0;
    }
    else {
      s1=bsto_font[sor*3+2];
      s2=font[a1*8+sor];
      s2=s2>>3;
      b3=s1|s2;
      s1=font[a1*8+sor];
      s2=font[a2*8+sor];
      s1=s1<<5;
      s2=s2>>2;
      b4=s1|s2;
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}



void aut_ir (bool aut,bool set_aut) {    
  //Amikor az automatikus nyári időszámítás beállítását  állítjuk be (automatikus be vagy ki), 
  //ez a függvény jeleníti meg a "NYARI" feliratot és a "BE" illetve "KI" karaktereket.
  //Ha a setup során hosszan nyomjuk a nyomógombot, akkor ciklikusan váltogatja a BE és a KI 
  //feliratokat, és ahol elengedjük a gombot az lesz beállítva.
  //A setupban villogtatni is kell az BE illetve KI felirat részeket, erre szolgál a set_aut
  // paraméter. Amikor értéke 0, akkor az BE illetve KI feliratot bemásoljuk a bitsorozatba,
  //amikor értéke 1, akkor csupa 0-át másolunk be. Hol 1-el, hol 0-val hívjuk meg a függvényt
  //így érhető el a villogás. A "NYÁRI" felirat az aut_font[] tömbben található, innen másoljuk
  //ki. A tömbben kétszer van meg minden, egy BE és egy KI karakter sorozattal az utolsó mátrix kijelzőre.
  //paraméterek:
  //aut:     0 esetén KI felirat, 1 esetén BE felirat
  //aut_set: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba a BE 
  //         vagy KI bitképét, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy a BE illetve KI betűk
  //         villogjanak a képernyőn, mert egyszer 1-el, egyszer pedig 0-val hívjuk meg ezt a függvényt
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    b1=aut_font[sor*5];
    b2=aut_font[sor*5+1];
    b3=aut_font[sor*5+2];
    if (set_aut==1) {b4=0;}
    else {
      if (aut==1) {b4=aut_font[sor*5+3];}
      else {b4=aut_font[sor*5+4];}
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void ff_no_ir (bool ff_no,bool set_ff_no) {    
  //Amikor a bemondás hangját állítjuk be a setup során, ez a függvény jeleníti meg a hangszóró és
  //férfi, nő valamint az FF és NŐ karaktereket. Ha a setup során hosszan nyomjuk a nyomógombot,
  //akkor ciklikusan váltogatja a FF-t és a NŐ-t, és ahol elengedjük a gombot az lesz beállítva.
  //A setupban villogtatni is kell az FF illetve NŐ felirat részeket, erre szolgál a set_ff_no
  // paraméter. Amikor értéke 0, akkor az FF illetve NŐ feliratot bemásoljuk a bitsorozatba,
  //amikor értéke 1, akkor csupa 0-át másolunk be. Hol 1-el, hol 0-val hévjuk meg a függvényt
  //így érhető el a villogás. A szimbólumok (hangszóró, férfi és nő jel) az ff_no_font[] tömbben
  //találhatók, innen másoljuk ki. A tömbben kétszer van meg minden, egy FF és egy NŐ karakter 
  //sorozattal az utolsó mátrix kijelzőre.
  //paraméterek:
  //ff_no:     0 esetén FF felirat, 1 esetén NŐ felirat
  //ff_no_set: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba az FF 
  //           vagy NŐ bitképét, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy az FF illetve NŐ betűk
  //           villogjanak a képernyőn, mert egyszer 1-el egyszer 0-val hívjuk meg ezt a függvényt
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    b1=ff_no_font[sor*5];
    b2=ff_no_font[sor*5+1];
    b3=ff_no_font[sor*5+2];
    if (set_ff_no==1) {b4=0;}
    else {
      if (ff_no==1) {b4=ff_no_font[sor*5+3];}
      else {b4=ff_no_font[sor*5+4];}
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}


void ido_ir (byte ora, byte perc,bool kettospont, bool set_ora, bool set_perc) {
  //Ez a függvény az időt (óra, perc) jeleníti meg a kijelzőn. Paraméterként megkapja
  //az órát és a percet, ezeket az adatokat számjegyekre bontja és a font[] tömbből 
  //kiveszi a számjegyek bitképét és összemásolja soronként egy 16 bites bitsorozatba.
  //Mivel az órabeállításkor villogtatni kell vagy az órát vagy a percet, ezért megkapja
  //a set_ora és a set_perc paraméterekben, hogy melyiket kell villogtatni. A villogás
  //jelzi a setup folyamatban, hogy a hosszan nyomjuk a nyomógombot, akkor melyik adat fog változni.
  //paraméterek:
  //ora: 0-tól 24-ig az óra
  //perc: 0-59.ig a perc
  //kettospont: ha értéke 1, akkor a képernyő közepén megjelenik egy kettőspont, ha 0 akkor nem. Másodpercenként
  //            váltogatva hívjuk meg a függvényt, így másodperces ciklusban villog a kettőspont az óra és a perc között.
  //set_ora:    amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba az óra 
  //            számjegyeinek bitképét, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy az óra számjegyei
  //            villogjanak a képernyőn, mert egyszer 1-el egyszer 0-val hívjuk meg ezt a függvényt
  //set_perc:   ugyanúgy működik mint a set_ora, csak ez a percet villogtatja a setup azon részében, amikor a 
  //            percet állítjuk be
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  byte a1,a2,a3,a4;   //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  a1=ora/10;
  a2=ora-a1*10;
  if (a1==0) {a1=10;}
  a3=perc/10;
  a4=perc-a3*10;
  for (byte sor=0;sor<8;sor++) {    //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    if (set_ora==1) {b1=0;b2=0;kettospont=1;}
    else {
      s1=font[a1*8+sor];   //kiolvassuk a karakter tömbből a az óra számjegyének balról első számjegyét (tízes számjegy)
      s2=font[a2*8+sor];   //kiolvassuk a karakter tömbből az óra számjegyének balról második számjegyét (egyes számjegy)
      s2=s2>>7;            //az egyes számérték bitjeit 7-el jobbra toljuk mert az első mátrix kijelző első hét bitje a 
                           //tízes számjegy s1 első hét bitje, és e mögé kell egy bitet másolni
      b1=s1|s2;            //itt másoljuk a tízes számjegy első hét bitjéhez az egyes számjegy 1 bitjét
      s1=font[a2*8+sor];   //újra kiolvassuk az egyes számjegy bitsorozatát
      s1=s1<<1;            //itt meg balra toljuk egyet, mert egy bit az előző kijelzőn van, hat bit meg már a második kijelzőre szorul
      b2=s1;
    }
    if (set_perc==1) {b3=0;b4=0;kettospont=1;}
    else {
      s1=font[a3*8+sor];
      s1=s1>>3;
      b3=s1;
      s1=font[a3*8+sor];
      s2=font[a4*8+sor];
      s1=s1<<5;
      s2=s2>>2;
      b4=s1|s2;
    }
    if (kettospont==1){              //ha időt jelenítünk meg és a kettospont=1 akkor egy kettőspontot teszünk a kijelző közepére
      if (sor==1 or sor==2 or sor==5 or sor==6) {
        b2=b2|B00000001;
        b3=b3|B10000000;
      }
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void ev_ir (byte ev, bool set_ev) {    
  //A függvény a paraméterként számként megkapja az év értékét évszázadok nélkül.  
  //Az adatot átalakítja számjegyekké, amiknek a bitképét előveszi a font[]
  //tömbből, amit aztán kiírunk a MAX7219 chip-be. 
  //Mivel 4 kijelzőre kell kiléptetni az adatokat, össze kell másolgatni az összes kijelző adott sorának bitképét
  //és egyben kiléptetni, tehát a kijelző láncra 16 bitet kell kiírni soronként.
  //paraméterek:
  //ev: 0-tól 99-ig az év (ebben a programban csak 50-ig megy, mert a setup-ban max 2050-et lehet beállítani)
  //set_ev: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba az ev 
  //        karaktereinek bitképét, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy az év
  //        villog a képernyőn, mert egyszer 1-el, egyszer 0-val hívjuk meg ezt a függvényt
  byte a1,a2;         //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  a1=ev/10;
  a2=ev-a1*10;
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    b1=ev_font[sor*3];
    b2=ev_font[sor*3+1];
    if (set_ev==1) {
      b3=ev_font[sor*3+2];
      b4=0;
    }
    else {
      s1=ev_font[sor*3+2];
      s2=font[a1*8+sor];
      s2=s2>>3;
      b3=s1|s2;
      s1=font[a1*8+sor];
      s2=font[a2*8+sor];
      s1=s1<<5;
      s2=s2>>2;
      b4=s1|s2;
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void start_ir (bool set_start) {    
  //a képernyőre a start feliratot írja ki azzal, hogy a start_font[] tömbből soronként kilépteti
  //a felirat bitképét. A feliratot villogtatni is kell a setup folyamat során, mert ez jelzi
  //hogy egy gombnyomással beírjuk a beállított értékeket és paramétereket a MAX7219 chip-be és az 
  //eeprom-ba, és ehhez kell a set_start bemenő paraméter. Ha értéke 0 akkor
  //megjelenik a felirat, ha értéke 1. akkor nem. Hol 0-val, hogy 1-el hívjuk meg a függvényt
  //így villog a felirat.
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    if (set_start==1) {b1=0;b2=0;b3=0;b4=0;}
    else {
    b1=start_font[sor*4];
    b2=start_font[sor*4+1];
    b3=start_font[sor*4+2];
    b4=start_font[sor*4+3];
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void setup_ir (bool set_setup) {    
  //a képernyőre a setup feliratot írja ki azzal, hogy a setup_font[] tömbből soronként kilépteti
  //a felirat bitképét. A feliratot villogtatni is kell a setup folyamat során, mert ez jelzi
  //hogy elindult a folyamat, és ehhez kell a set_setup bemenő paraméter. Ha értéke 0 akkor
  //megjelenik a felirat, ha értéke 1. akkor nem. Hol 0-val, hogy 1-el hívjuk meg a függvényt
  //így villog a felirat.
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    if (set_setup==1) {b1=0;b2=0;b3=0;b4=0;}
    else {
    b1=setup_font[sor*4];
    b2=setup_font[sor*4+1];
    b3=setup_font[sor*4+2];
    b4=setup_font[sor*4+3];
    }
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}


void dat_ir (byte ho, byte nap, bool set_ho, bool set_nap) {
  //A függvény a paraméterként számként megkapja a hónapot és a hónap napját.  
  //Mindkét adatot átalakítja számjegyekké, amiknek a bitképét előveszi a honap_font[] és font[]
  //tömbökből, amit aztán kiírunk a MAX7219 chip-be. A hónap napjának karakter képét a 
  //font[] tömbben hoztuk létre, ebből emeli ki. A hónap rövidített három karakteres névvel jelenik meg,
  //ennek bitképe a honap_font[] tömbben található, minden egyes hóna külön-külön. 
  //Mivel 4 kijelzőre kell kiléptetni az adatokat, össze kell másolgatni az összes kijelző adott sorának bitképét
  //és egyben kiléptetni, tehát a kijelző láncra 16 bitet kell kiírni soronként.
  //paraméterek:
  //ho: 0-tól 12-ig a hónap
  //nap: az adott nap száma (dátum napja) 1-31
  //set_ho: amikor setup-ban vagyunk akkor kell ez a paraméter, 0 hatására bemásoljuk a bitsorozatba a ho 
  //        karaktereinek bitképét, míg 1 esetén csupa 0-át másolunk be. Így érjük el, hogy a hónap
  //        megnevezése villog a képernyőn, mert egyszer 1-el egyszer 0-val hívjuk meg ezt a függvényt
  //set_nap: ugyanúgy működik mint a set_ho, csak ez a napot villogtatja a setup azon részében, amikor a 
  //        napot állítjuk be
  byte a1,a2,a3,a4;   //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  a3=nap/10;
  a4=nap-a3*10;
  for (byte sor=0;sor<8;sor++) {           //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    if (set_ho==1) {b1=0;b2=0;}
    else {
      b1=honap_font[(ho-1)*16+sor*2];
      b2=honap_font[(ho-1)*16+sor*2+1];
    }
    if (set_nap==1) {b3=0;b4=0;}
    else {
      if (nap<10) {a3=10;};
      s1=font[a3*8+sor];
      s1=s1>>3;
      b3=s1;
      s1=font[a3*8+sor];
      s2=font[a4*8+sor];
      s1=s1<<5;
      s2=s2>>2;
      b4=s1|s2;
    }
    if (sor==7) {b3=b3|B10000000;}
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void het_ir (byte nap, byte het_napja, bool set_het) {
  //A függvény a paraméterként számként megkapja a hónap napját és a hét napját (1-7). A hét napját 
  //átalakítja három karakteres névvé (hétfő-vasárnapig), és a hónap napját és a hét napját soronként 
  //megjelenítendő bitképpé amit aztán kiírunk a MAX7219 chip-be. A hónap napjának karakter képét a 
  //font[] tömbben hoztuk létre, ebből emeli ki. Először a hónap napját felbontjuk két különálló 
  //egyjegyű számra, és ezekkel lehet megcímezni a font[] tömböt, amiből soronként ki lehet emelni az 
  //adott karakter bitsorozatát. A hét napjainak bitképe a het_font[] tömbben van. Minden nap 3 betűre 
  //van lerövidítve, és hét ilyen bitsorozat van ebben a tömbben.
  //Mivel 4 kijelzőre kell kiléptetni az adatokat, össze kell másolgatni az összes kijelző adott sorának bitképét
  //és egyben kiléptetni, tehát a kijelző láncra 16 bitet kell kiírni soronként.
  //paraméterek:
  //nap: 0-31 (nem ellenőrzi a hónap napjait)
  //het: 1-7, 1=hétfő
  //set_het: ha értéke 0, akkor a hét napjainak bitsorozatát írjuk a mátrix kijelzőre
  //         ha értéke 1, akkor csupa 0-át léptetünk ki a betűk bitképe helyett. Ez a setupban a hét napjainak
  //         villogtatására lett kitalálva, de a hét napjait immár nem kell beállítani, mert a dátumból
  //         a program kiszámolja magának. Benne hagytam a villogtatás lehetőségét, de nem használom, ez a paraméter mindig 0.
  byte a1,a2;         //paraméter érték számjegyekre bontásához
  byte s1,s2;         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat
  byte b1,b2,b3,b4;   //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                      //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  a1=nap/10;
  a2=nap-a1*10;
  for (byte sor=0;sor<8;sor++) {           //a matrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
      s1=font[a1*8+sor];
      s2=font[a2*8+sor];
      s2=s2>>7;
      b1=s1|s2;
      s1=font[a2*8+sor];
      s1=s1<<1;
      b2=s1;
    if (set_het==1) {b3=0;b4=0;}
    else {
      b3=het_font[(het_napja-1)*16+sor*2];
      b4=het_font[(het_napja-1)*16+sor*2+1];
    }
    if (sor==7) {b3=b3|B10000000;}
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}

void homeresklet_ir (float homerseklet) {
  //AZ a függvény a paraméterként kapott hőmérséklet számadatot alakítja át soronként megjelenítendő bitképpé
  //amit aztán kiírunk a MAX7219 chip-be. A karakter képet a font[] tömbben hoztuk létre, ebből emeli ki.
  //Először felbontjuk a float típusú hőmérséklet értéket számjegyekre, és ezekkel lehet megcímezni a font[]
  //tömböt, amiből soronként ki lehet emelni ez adott karakter bitsorozatát.
  //Mivel 4 kijelzőre kell kiléptetni az adatokat, össze kell másolgatni az összes kijelző adott sorának bitképét
  //és egyben kiléptetni, tehát a kijelző láncra 16 bitet kell kiírni.
  byte b1,b2,b3,b4;        //segédváltozók, amikbe a karakterkép adott sorát töltöm be, és ebből léptetem ki a MAX7219 chip-be,
                           //4 mátrix kijelző modul van, így mindegyiknek van egy változója
  int h0=(int)(homerseklet*10);
  byte h1=h0/100;
  byte h2=(h0-h1*100)/10;
  byte h3=h0-h1*100-h2*10;
  if (h1==0) {
    h1=10;
  }
  byte s1,s2;                         //ezekben tárolom a karakter tömbökből indexérték alapján kimásolt bitsorozatokat                   
  for (byte sor=0;sor<8;sor++) {      //a mátrix kijelzőkbe soronként lehet beléptetni az infót, de mind a négy kijelzőnek ugyanabba a sorába
    s1=font[h1*8+sor];                //első karakter
    s2=font[h2*8+sor];                //második karakter
    s2=s2>>7;                         //második karakterből csak egy oszlop kell, a legelső
    b1=s1|s2;                         //első karakter és a második karakter első oszlopának összemásolása
    s1=font[h2*8+sor];                //második karakter kiolvasása újra
    b2=s1<<1;                         //második karakterből csak a 2. oszloptól kell (tehát csak öt oszlop)
    if (sor==7 or sor==6) {b2=b2|B00000010;}    //második és harmadik karakter két oszlopának összemásolása a tizedesponttal
    b3=font[h3*8+sor];                //harmadik karakter kiolvasása újra
    b4=cfok_font[sor];                //celsius fok karakterkép 
    //kiléptetjük a bitsorozatot a négy mátrix kijelzőbe. Sorba vannak kötve, egymásnak adják tovább az infót!
    digitalWrite(cs_kimenet,0);       //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
    kileptet(sor+1,b1);
    kileptet(sor+1,b2);
    kileptet(sor+1,b3);
    kileptet(sor+1,b4);
    digitalWrite(cs_kimenet,1);       //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
  }
}


/**********************************************************************************************
 * Megméri az A6 bemenetre kötött fotó tranzisztor és ellenállásosztóban az ellenállás        *
 * feszültségét. Ellenállás értéke 1Kohm. A fotó tranzisztor kb. 5000Lux-nál teljesen kinyit, *
 * ekkor az ellenálláson közel 5V feszültség mérhető. Sötétben a feszültség 0V                *
 **********************************************************************************************/
void fenyero_beallitas(){
    int ledmatfeny=0;
    for (byte j=9;j>0;j--) {mert_fenyero[j]=mert_fenyero[j-1];}
    int fenyero=analogRead(A0);
    mert_fenyero[0]=fenyero;
    fenyertek=(mert_fenyero[0]+mert_fenyero[1]+mert_fenyero[2]+mert_fenyero[3]+mert_fenyero[4]+mert_fenyero[5]+mert_fenyero[6]+mert_fenyero[7]+mert_fenyero[8]+mert_fenyero[9])/10;
    if (fenyertek<=4) {ledmatfeny=0;}
    if (fenyertek<=8 & fenyertek>4) {ledmatfeny=1;}  
    if (fenyertek<=15 & fenyertek>8) {ledmatfeny=2;}  
    if (fenyertek<=30 & fenyertek>15) {ledmatfeny=3;}  
    if (fenyertek<=45 & fenyertek>30) {ledmatfeny=4;}  
    if (fenyertek<=60 & fenyertek>45) {ledmatfeny=5;}  
    if (fenyertek<=75 & fenyertek>60) {ledmatfeny=6;}  
    if (fenyertek<=90 & fenyertek>75) {ledmatfeny=7;}  
    if (fenyertek<=105 & fenyertek>90) {ledmatfeny=8;}  
    if (fenyertek<=120 & fenyertek>105) {ledmatfeny=9;}  
    if (fenyertek<=135 & fenyertek>120) {ledmatfeny=10;}  
    if (fenyertek<=150 & fenyertek>135) {ledmatfeny=11;}  
    if (fenyertek<=165 & fenyertek>150) {ledmatfeny=12;}  
    if (fenyertek<=200 & fenyertek>165) {ledmatfeny=13;}  
    if (fenyertek<=300 & fenyertek>200) {ledmatfeny=14;}  
    if (fenyertek>300) {ledmatfeny=15;} 
    //árnyékos lakásban kellett az óra gyengén látónak, ezért az éjszaka kivitelével azt akartam
    //hogy teljes fényerővel világítson, ezért nagyon szűk fényintenzitáson belül szabályoz.
    //300 felett már max fényerő. Úgy tapasztaltam, hogy olyan helyen ahol soha nem süt a nap 
    //az érzékelőre, 200 és 400 között van a mért érték maximuma.
    matrix_setup(intenzity,ledmatfeny);      //Intenzitás minimum
} 


void kileptet(byte bitkep1, byte bitkep2)  {
  //adatokat léptetek ezzel a függvénnyel a MAX7219 chip-be. A chip 8 sort kezel
  //bitkep1=a sor sorszáma, amibe a megjelenítendő adatot írjuk (0-7-ig lehet címezni)
  //bitkep2=az adat, amit bele írunk a regiszterbe, ez jelenik meg az adott sor led-jein bitenként
  for (byte i=0;i<8;i++) { //először a felső byte adatot fogjuk kiléptetni bitenként jobbról balra
    digitalWrite(adat_kimenet,(bitkep1<<i) & 128);
    digitalWrite(clk_kimenet,1);      //órajel felfutóél (beolvassa az adatot)
    digitalWrite(clk_kimenet,0);      //órajel lefutóél
  }
  delayMicroseconds(idozites);   
  for (byte i=0;i<8;i++) { //először a felső byte adatot fogjuk kiléptetni bitenként jobbról balra
    digitalWrite(adat_kimenet,(bitkep2<<i) & 128);
    digitalWrite(clk_kimenet,1);
    digitalWrite(clk_kimenet,0);
  }
}


void matrix_setup(byte mode_reg, byte ertek) {
  //a matrix kijelzőt vezérlő MAX7219 chip mode regiszterébe írok ezzel a függvénnyel működési beállításokat, pl fényerő beállítás
  //mode_reg= a mód regsizter címe a chip-ben, ertek= az az érték, amit a regiszterbe írok
  digitalWrite(cs_kimenet,0);            //cs bemenetre 0-at kapcsolunk, kijelző kiválasztva, jöhetnek az adatok
  delayMicroseconds(idozites);           //várunk kicsit, hogy legyen idő a chipnek beállni az adatfogadásre
  for (byte i=0;i<4;i++) {               //négyszer küldünk ki minden adatot, mert négy kijelzőnk van sorba kötve 
    kileptet(mode_reg,ertek);            //kiléptetjük az adatvezetéken a parancsot és az adatot egymás után
  }  
  digitalWrite(cs_kimenet,1);           //cs bemenetet vissza állítjuk 0-ra, chip nincs kiválasztva, illetve ezzel a felfutó éllel jelenik meg a beléptetett adat a kijelzőn
}