Lakás világítás vezérlő

Tartalom:

  • Hat helység led világításának vezérlése fényerőszabályzással
  • Fényerő fel és leúsztatás
  • Kikapcsolási késleltetés, minden helyiség világításának kikapcsolása bárhonnan a világítás kapcsolókról
  • Paraméterek beállítása működés közben a világításkapcsolókról
  • Hagyományos világítás vezérlése is
  • ATmega328P vezérlő

Lakásunkban már szinte minden világitás ledes. Ezeket a led világításokat magam szerelgettem boltban kapható led szalagokból és led modulokból. Boltban kapható 12V kapcsoló üzemű tápegységeket használtam, esetenként 24V-os printer tápegységet. Dögös áramokról van szó, itt 10A-ek röpködnek. Kezdetben relével kapcsoltam be a világítást, egy primitív áramkörrel. Szerettem volna, ha egy kicsit komfortosabb a működés, pl. bárhonnan le tudom kapcsolni az összes szobában a világítást, de azt is nagyon szerettem volna, ha éjszaka felkapcsolva a villanyt, nem vakít el a hirtelen nagy fény, hanem lassan kúszik fel a fényerő. Ezért kezdtem bele ennek az áramkörnek a megépítésébe.

Az a fotó a megvalósított kapcsolást mutatja. Középen a vezérlő az ATmega328 chip-el, alul a hűtőbordán a MOSFET tranzisztorok, amikkel a 12 vagy 24V feszültséget kapcsolgatom a pwm jellel a fényerő szabályozáshoz. Nem kelett volna ekkora hűtőborda, de csak ekkora volt a fiókban. A MOSFET tranzisztorok működéséről az elektronikai alapokról szóló leírásomban olvashatsz! Alig van valami alkatrész benne!

Nagy előnye még ennek a kapcsolásnak, hogy egy szobában több kapcsolót is el lehet helyezni, párhuzamosan köthetők, és bármelyikről fel és le kapcsolható a villany. Ez a kényelem ma még nem teljesen egyértelmű. A szokásos villanyszerelők által bekötött alternatív kapcsolás nem pont ugyanez. Kaphatók készen villamos hálózatba szabvány módon beköthető elektronikus kapcsoló áramkörök, darabja 9-10.000Ft. Nekem az egész került ennyibe (led világítás nélkül).

Álltalános leírás a működésről

Az alapvető cél, hogy egy fényerőszabályozható (pwm) LED világításból és hagyományos 230V-os, relével vagy más módon kapcsolt világításból álló lakásvilágítást intelligens módon lehessen vezérelni. Összesen nyolc csatornás világításvezérlést valósít meg a program, ahol egy csatorna egy fali kapcsoló – lámpa párost jelent.

Lakás világítás vezérlésem tulajdonságai, ha az alkalmazott mikrovezérlő ATmega168 vagy ATmega328:

  • Maximum 6 db fényerőszabályozott kimenet és még 2 db digitális (relével stb. kapcsolható) kimenet.
  • Minden fényerőszabályozott kimenet átállítható digitális vagy fényerőszabályozott működésre. Ha a programot beégetitek, alapértelmezetten fényerőszabályzás nélküliek a kimenetek.
  • A nem fényerőszabályozott (digitális) kimenetek a fali kapcsolóval ki és bekapcsolhatók egy lenyomással (klikkeléssel), vagyis minden fali kapcsoló “csengő kapcsoló” kell, hogy legyen. Sajnos a hagyományos kétállású kapcsolókat (fel/lekapcsolókat) le kell cserélni! A mi lakásunkban szinte minden helységnek két bejárata van (a lakás körbejárható), így minden bejárathoz került egy fali kapcsoló. A kapcsolók párhuzamosan vannak kötve, így bármelyikről kapcsolható a világítás. Egyik ajtón bejövök és felkapcsolom, a másikon kimegyek és lekapcsolom.
  • A fényerőszabályozott kimeneteket a hozzájuk tartozó kapcsolókkal a következő módon lehet vezérelni:
    • Egy klikkel ki és be lehet kapcsolni. Bekapcsoláskor a fényerő nem ugrik azonnal maximumra, beállítható ütemben úszik fel egy beállított fényerőre. Kikapcsoláskor a világítás villan egy rövidet, ezzel jelzi, hogy megkezdődött a fényerőcsökkentés, ami egy 20%-os minimum fényerő eléréséig tart. Ekkor beindul a segédfény funkció, ami beállítható ideig tartja ezt a fényerőt, hogy ne kelljen vaksötétben kimenni a helységből. A beállított idő után a segédfény kikapcsol.
    • A lámpa bekapcsolható a fali kapcsoló folyamatos nyomva tartásával is. A kapcsoló lenyomását követően az ismétlési idő elteltével (alapértelmezetten 500msec), minimum fényerővel kezd világítani a lámpa és folyamatosan emelkedik a fényerő a maximum felé. A maximum elérésekor a lámpa villan egyet. A kapcsolót bármely fényerőnél elengedjük, az aktuális fényerőt a rendszer megjegyezi, és következő felkapcsoláskor erre a fényerő értékre áll be a lámpa fényereje.
    • Ha a lámpa világit, a fali kapcsoló folyamatos nyomva tartásával a fényerő növelhető a maximumig. Ha a fényerő a maximumot elérte, a lámpa villan (elalszik egy pillanatra). Újabb ismételt nyomva tartással a fényerő minimumig csökken. Ha a fényerő éppen megfelelő, elengedjük a nyomógombot és az így beállított fényerőt a rendszer tárolja (ez a fényerő érték a tápfesz kimaradáskor elveszik, újra be kell állítani). Ha a lámpát lekapcsoljuk, és újra bekapcsoljuk a tárolt fényerővel fog világítani. Természetesen a fényerő felúszik a beállított fényerőre, és leúszik a minimum fényerőig, amelyen a segédfény funkcióra beállított ideig még világít.
    • Bármely fali kapcsoló dupla lenyomásával (dupla klikk), az összes lámpát lekacsolja a rendszer. Ez a funkció a fényerőszabályozott és nem fényerőszabályozott lámpákra is működik, a fényerőszabályozott részeken fényerő leúsztatás és segédfény funkció is működik. Mivel egy vezérlővel csak maximum 8 világítás vezérelhető, vannak bővítő ki és bemenetek ehhez a funkcióhoz. A bővítő kimeneten a tripla klikk egy rövid 10msec-es impulzust generál, ami egy másik hasonló vezérlő bővítő bemenetére köthető. A bemeneten megjelenő impulzus hatása azonos a tripla klikkel, vagyis az összes lámpa lekapcsol. Ez a bemenet esetleg egy központi lámpa lekapcsolásra is felhasználható, pl. a riasztó élesítése lekapcsolja a lámpákat. Segédfény funkció természetesen ekkor is működik!
    • Bármely fali kapcsoló négyszeri lenyomása (4 klikk) bekapcsolja a „nyaralás” üzemmódot. Ez jelenleg még fejlesztés alatt áll. Lényege, hogy a vezérlő figyeli a világítási szokásokat, és ezen megtanult értékek alapján véletlenszerűen, de élet szerűen kapcsolgatja a villanyokat az esetleges rablók megtévesztésére. Természetesen más funkció is kialakítható, de én ezt terveztem a rendszerbe. A funkció megvalósítása óra funkció és külső memória beépítést is megköveteli, ezért is várat magára a fejlesztés.
    • Bármely fali kapcsoló ötszöri lenyomása (5 klikk) az adott kapcsolóhoz tartozó lámpa működési paramétereinek a beállítására szolgáló setup folyamat elindulását eredményezi. Setup folyamat leírását lásd később.

Ezeket a funkciókat egy jelentősen leegyszerűsített egy “CSATORNÁS” programban is közzétettem. Ha valakinek nincs szüksége hat fényerőszabályozott csatornára, akkor ezt a programot fel tudja használni. Lényegesen egyszerűbb program, alaposan felkommenteztem! A forráskódok menüben több más program között ez is megtalálható.

Az egyes lámpák (csatornák) beállítható paraméterei

Összesen nyolc csatornát lehet vezérelni, ezek hivatkozása 0-7 közötti index értékkel történik. A programban egy be[] nevű tömb változóban lehet megadni a fizikai mikrovezérlő lábakat, melyeket bemenetnek definiálunk. A mellékelt programban mind a 6 analóg bemenet digitális bemenetnek lett definiálva. A ki[] nevű tömb változóban kell megadni a kimeneti lábakat. Ezzel szinkronban kell megadni a pwm_hdvr_mask[] tömb változóban, hogy melyek a pwm kimenetek, hiszen a program csak ezek fényerő szabályozását kezelheti, a többi kimenetet csak fel-le kapcsolgatja. Ezen változók jelenlegi beállításai:

be[]={14,15,16,17,18,19,0,1}; 
ki[]={3,5,6,9,10,11,2,4};         
pwm_hdvr_mask[]={1,1,1,1,1,1,0,0}; //a 2,4 láb nem lehet pwm, ezért 0

Az egyes csatornák többféle tulajdonságát a felhasználó működés közben is megváltoztathatja. Ezt azért építettem be, mert a lakásvilágításomat folyamatosan fejlesztem (cserélem a hagyományos lámpákat fényerőszabályozható led világításra, illetve ha egy LED lámpa elromlik, gyorsan tudom helyettesíteni hagyományos lámpával), és nem akartam minden egyes változtatásnál programot módosítani és a mikrovezérlő beégetésével bajlódni.

A paraméterek:

  • Csatorna típusa: pwm be és kikapcsolás (ki_pwm nevű tömb) 1-nincs pwm bekapcsolva, 2-pwm be van kapcsolva a csatornán. Ha van pwm, akkor működik a fényerő fel/leúsztatás, és beállítható az alapértelmezett fényerő, amire a lámpa beáll a felkapcsolást követően. Ekkor van segédfény funkció is.
  • Klikkek közötti maximális várakozási idő:  (klikk_wait_time nevű tömb)  A beállított érték * 100msec ideig várakozik a program a következő klikkelésre ahhoz, hogy többszörös klikkelésnek érzékelje azokat (alapértelmezett 5 vagyis 500msec). Vagyis ha 500msec-en belül klikkelünk még egyet, akkor kétszeres, háromszoros stb. klikknek érzékeli a program. Ha 500msec-en belül nem érkezik klikk, akkor befejezi a klikkek számolását és az addigi klikkelések számához tartozó parancsot hajtja végre. Felkapcsolja a lámpát, beállítja a maximális fényerőt stb. Túl kicsire nem érdemes állítani, mert egy fali kapcsolóval nem lehet túl gyorsan klikkelni és esetleg csak fel és le fogjuk tudni kapcsolni a lámpát. Azonban túl lassúra sem érdemes állítani, mert ha felkapcsoljuk a lámpát és gyorsan szeretnénk mégis lekapcsolni, akkor meg kell várnunk ezt az időt, különben többszörös klikknek érzékeli a program és valami mást fog csinálni. Fontos tudni, hogy a klikkeléseket akkor is számolja a program, ha nincs az adott csatornán beállítva pwm mód. A lámpák lekapcsolása, nyaralásmód bekapcsolása és a setup mód ezeken a csatornákon is kiadható. A dupla klikkeknek azonban nem lesz hatása, mert nem fognak fényerőt növelni, vagy csökkenteni.
  • Fel/le úsztatási idő:  (fade_time nevű tömb). A beállított érték * 0,5sec  (alapértelmezett 6, vagyis 3 sec) alatt úsztatja fel vagy le a fényerőt a maximumról minimumra. Csak ha van pwm beállítva, akkor értelmezett és felhasznált érték)
  • Segédfény ideje: (assistance_time nevű tömb). A (beállított érték-1) * 3sec  ideig minimális fényerőn fog világítani a lámpa a kikapcsolást követően. Ha értéke 1, akkor nincs segédfény bekapcsolva. Ha értéke 2 akkor 3sec stb. Csak  ha van pwm, akkor értelmezett és felhasznált érték)

A setup folyamata

Elismerem, hogy ez a folyamat marhabonyolultnak látszik. Gyakorlatilag csak “papírból” lehet végigcsinálni. Szerencsére nem kell hozzányúlni gyakran. Öt év alatt talán háromszor állítgattuk feleségemmel, főleg a segédfénnyel kísérletezgettünk. Korrigálom magam, nem papírból csináltam a beállítást, a weblapomat használtam tablettel! Én már csak ilyen korszerű vagyok.

  1. Klikkeljünk a fali kapcsolóval ötször (a fali kapcsolót nyomjuk le gyorsan egymás után ötször).  Bármely csatorna setup módja alatt a rendszerbe kötött többi kapcsoló nem működik, a többi lámpa megőrzi aktuális állapotát.
  2. A kapcsolóhoz tartozó lámpát a program két rövid és egy hosszabb (ti-ti-tá) időre felkapcsolja (villogtatja a lámpát).
  3. Ekkor klikkelések (fali kapcsoló gyors egymásutáni kapcsolgatásával) kell megmondanunk, hogy melyik paramétert akarjuk állítani. Két klikkelés között nem telhet el több mint 500msec. A következő paramétereket tudjuk beállítani:

1 klikk: pwm szabályozás ki vagy be kapcsolása

2 klikk: klikkelések közötti maximális ismétlési idő.

3 klikk: fel és leúsztatási idő beállítása

4 klikk: segédfény világítási ideje a lámpa leikapcsolás után

Az első klikkelésig maximum 5 másodperc áll rendelkezésre. Ha addig nem történik klikk, akkor a kapcsolóhoz tartozó lámpa rövid villantásával jelzi a program, hogy kilépett a setup módból.

  • Miután befejeztük a klikkeléseket (az utolsó klikk után eltelt 500msec) a lámpa felvillan annyiszor, ahány klikkelést végeztünk. Ezzel ellenőrizhető, hogy melyik paramétert fogjuk beállítani. Ha netán nem a megfelelő paramétert sikerült „leklikkelni” akkor ezen a ponton várjunk 5 másodpercet, és a program vissza fog térni a 2. pontban leírt állapotba (levillogtatja a ti-ti-tá setup mód nyitó üzenetet), és kezdhetjük elölről a paraméter megadást.
  • Most következik a paraméter értékének beállítása. A klikkelések megkezdésére 4 másodperc áll rendelkezésre. Itt is 500msec telhet el maximum két gombnyomás között. A következő értékek állíthatóak be az egyes paraméterek esetén:

1-es paraméter, pwm ki és bekapcsolás:
1 klikk pwm mód kikapcsolva
2 klikk pwm mód bekapcsolva

2-es paraméter, max. ismétlési idő: (1-10 klikk)
1 klikk 100msec,
2 klikk 200msec stb.

3-as paraméter, fel és leúsztatási idő: (1-10 klikk)
1 klikk 500msec,
2 klikk 1sec stb.

4-es paraméter, segédfény funkció:   (1-15 klikk)
1 klikk segédfény kikapcsolva
2 klikk 3 sec
3 klikk 6 sec stb.

5-ös paraméter, segédfény funkció:  (1-9 klikk)
1-1%,
2-3%,
3-5%,
4-10%,
5-15%,
6-20%,
7-30%,
8-40%,
9-50%

A paraméter érték beállítás megkezdéséhez, azaz az első gombnyomás megkezdéséhez 4 másodperc áll rendelkezésre. Ha nem teszünk semmit, akkor 4 másodperc után a program a paraméter értékét nem változtatja meg, és visszalép a 2. pontban leírt állapotba. (felvillantja a lámpát két rövid és egy hosszú villanással (ti-ti-tá), és várja a paraméter kiválasztását).

  • Amint leklikkeltük a paraméter értékét, az utolsó klikk után 1 másodperccel a program levillogtatja a fogadott klikkek számát. Ezzel ellenőrizhetjük a beállított értéket, ami tárolásra is került. Ezt követően visszatér a program a 2. pontban leírt állapotba. (felvillantja a lámpát két rövid és egy hosszú villanással (ti-ti-tá), és várja a paraméter kiválasztását).
  • Kiválaszthatjuk a következő paramétert, és annak értékét, vagy nem nyúlunk a kapcsolóhoz, és 5 másodperc múlva a lámpa rövid felvillanása jelzi, hogy kiléptünk a setup módból.

Gyári alapértelmezett értékek beállítása

Ehhez tegyünk a mikrovezérlő 7-es lábára egy kapcsolót, illetve valamilyen más módon kössük GND-re. Áramtalanítsuk a mikrovezérlőt és helyezzük áram alá úgy, hogy közben a 7-es láb földre van kötve. Pár másodperc után a láb GND-re kötését megszüntethetjük, mintavétel a láb állapotáról csak induláskor történik. Ha a program induláskor a 7-es lábon logikai 0-át talál, akkor az EEPROM-ba beírja az alapértelmezett értékeket. Következő induláskor már ezeket az értékeket fogja kiolvasni, illetve a setuppal ezeken az értékeken változtathatunk.

Forráskód:

#include <EEPROM.h>

//segéd változók
  byte sw_prell[]={0,0,0,0,0,0,0,0};            //kapcsoló prell figyeléshez
  long sw_time[]={0,0,0,0,0,0,0,0};             //kapcsoló lenyomás prell figyeléshez eltelt idő az első kontaktus óta
  long sw_on_time[]={0,0,0,0,0,0,0,0};          //a lenyomvatartás kezdő időpontja (millis())
  byte sw_valt[]={0,0,0,0,0,0,0,0};             //segéd változó, amig nincs ujabb klikk, addig blokkolja az állapot változást
  byte sw_prev_stat[]={0,0,0,0,0,0,0,0};        //kapcsoló előző ciklusbani állapotát tárolja. Kapcsoló lenyomás és elengedés 
                                                //érzékeléséhez kell
  byte lamp_prev_stat[]={0,0,0,0,0,0,0,0};      //lampa előző ciklusbani éllapotát tárolja lámpa felkapcsolás és lakapcsolás 
                                                //érzékeléshez kell
  long sw_nosens_time[]={0,0,0,0,0,0,0,0};      //a következő klikk megérkezéséig számolja az időt (ha több mint egy megadott érték, 
                                                //akkor nem jött további kapcsolás és ezt véglegesítjük)
  byte sw_nosens[]={0,0,0,0,0,0,0,0};           //ha bebillentjük 1-be akkor figyeli, hogy jön-e új klikk
  byte sw_nosens_prev_stat[]={0,0,0,0,0,0,0,0}; //sw_nosens előző ciklusbeni állapota
  byte fenyero_tmp[]={0,0,0,0,0,0,0,0};         //a fényerő felés leusztatááskor az éppen aktuális fényerő értéke
  long fenyero_nov_time2[]={0,0,0,0,0,0,0,0};   //fenyero novelés során segédváltozó időméréshez
  byte lamp_on_prev_stat[]={0,0,0,0,0,0,0,0};   //lámpa előző állapota bekapcsolt állapota esetén 1, kikapcsolva 0
  long fenyero_nov_time[]={0,0,0,0,0,0,0,0};    //a fenyero novelesnel az idozítés segédváltozója
  byte nyomvatart_prev_stat[]={0,0,0,0,0,0,0,0};//nyomvatartás végének észrevételéhez segédváltozó 
  long sw_tart_time[]={0,0,0,0,0,0,0,0};        //két kapcsoló lenyomás közötti időmérés segéd változója. Első lenyomáskor 
                                                //ez elengedéskor indul az időmérés, az ezt követő lenyomásokkor a felfutó éltől
                                                //indul a mérés
  byte villan[]={1,1,1,1,1,1,1,1};              //ha elérte a fényerő maximumot a fényerő növelés, akkor villan a lámpa, 
                                                //ezt engedélyezi, alapértelmezette 1 mert alapértelmezett változási irány a növelés
  byte jelzes=0;                                //négy klik esetén a háromszor felvillantjuk a lámpát, ennek a segédváltozója
  byte negyklik=0;                              //segédváltozó a négy klikk estén a lámpa villogtatáshoz, és összes 
                                                //lámpa lekapcsolásához.
  long negyklik_time=0;                         //segédválzozó négy klikk esetén időméréshez
  byte villanas_szaml=0;                        //segédváltozó négy klikk estén a lámpák villogtatásához
  byte zeroadress=16;                           //ettől a címtől kezdve tároljuk az adatokat az eeprom-ban
// chip lábkiosztásának beállításai
  byte exp_input=8;                       //bővítő bemenet lábszáma
  byte exp_output=12;                     //bővítő kimenet lábszáma
  byte factory_default=7;                 //gyári beállítás bemenet lábszáma
  byte be[]={14,15,16,17,18,19,0,1};      //bemneti lábak definiálása
  byte ki[]={3,5,6,9,10,11,2,4};          //kimeneti lábak definiálása
  byte pwm_hdvr_mask[]={1,1,1,1,1,1,0,0}; //a pwm vezérelhető kimeneteket maszkolja. 0-aláb nem pwm képes, 1-a láb pwm képes.
                                          //Hiába állítja be pwm-nek a felhasználó azt abemenetet ami csak digitális kimenet, 
                                          //mivel ez felülbírálja a beállított setup paramétert. A KI[] változóval szinkronban 
                                          //kell feltölteni. Azoknál a lábaknál, melyek nem pwm vezérelhetők 0-at kell megadni.
                                        
// Működési paraméterek változói EEPROM-ból töltődnek fel bekapcsoláskor
  byte ki_pwm[]={0,0,0,0,0,0,0,0};           //kimeneti lábak pwm kimenetek legyenek-e (1-igen,0-nem)
  byte klikk_wait_time[]={5,5,5,5,5,5,5,5};  //két lenyomás közötti maximális várakozási idő ahhoz, hogy számolja a lenyomások számát
  byte fade_time[]={6,6,6,6,6,6,6,6};        //fény fel és leúsztatásának tempóját határozza meg (érték * 0,5sec) a nulláról
                                             //maximumig (vagy fordítva) teljes ideje.
  byte assistance_time[]={2,2,2,2,2,2,2,2};  //segédfény időtartama (érték * 3sec) eddig még világit a lámpa lekapcsolás után
                                             //minimumfényerővel
 // byte minimumfenyero=20;                    //erre a fényerő értékre csökken kikapcsoláskor a lámpa
  byte min_fenyero[]={1,1,1,1,1,1,1,1};       //csatornánként az alapminimális fényerő értéke. Az eeprom-ban nem ezek az értékek kerülnek tárolásra
  
  byte fenyero[]={5,5,5,5,5,5,5,5};          //lámpa fényereje 5..255-ig. Felkapcsoláskor az ebben tárolt fényerőre 
                                           //kapcsolja be a lámpát. Nyomvatartáskor ennek az értékét változtatja a program
                                  
//Kapcsolók lámpál és egyéb futás közbeni változók
  byte lamp_on[]={0,0,0,0,0,0,0,0};         //lámpa bekapcsolt állapota esetén 1, kikapcsolva 0
  byte sw_on[]={0,0,0,0,0,0,0,0};           //kapcsoló nyomvatartás alatt értéke 1
  byte sw_klik[]={0,0,0,0,0,0,0,0};         //a kapcsoló klikkelések számát számolja folyamat közben
  byte sw_klik_mem[]={0,0,0,0,0,0,0,0};     //ha letelt a két klik közötti idő, akkor ebbe tárolóik le a klikkelések száma
  byte nyomvatart[]={0,0,0,0,0,0,0,0};      //jelzi, hogy nyomvatarjuk a nyomógombot, amig nyomjuk éstéke 1
  byte valtozas_fel_le[]={1,1,1,1,1,1,1,1}; //a fenyero változás iránya nyomvatartáskor 1-fel 0-le

void setup() {
for (byte i=0;i<8;i++) {pinMode(be[i],INPUT);digitalWrite(be[i],HIGH);pinMode(ki[i],OUTPUT);}
  //be és kimenetek definiálása
pinMode(factory_default,INPUT);digitalWrite(factory_default,HIGH); 
  //gyári beállítás bemenet. Ha bekapcsoláskor 0, akkor betöltődi a gyári alapbeállítás
pinMode(exp_input,INPUT);digitalWrite(exp_input,HIGH);  
  //bővítő bemenet. Ha 0 jön, akkor minden lámpát kikapcsol (ugyanaz, mintha 3 klik-t nyomunk a kapcsolón)
pinMode(exp_output,OUTPUT);digitalWrite(exp_output,HIGH);
  //bővítő kimenet. Ha bármellyik nyomógombot háromszor lenyomjuk (tripla klikk), akkor 100msec 0-at ad a kimenetre
if (digitalRead(factory_default)==LOW)  //alapértrelmezett értékekkel töltjük fel az eeprom-ot (gyári alapbeállítás)
  {
    for (byte i=0;i<8;i++) 
    {
      EEPROM.write(zeroadress+(i*5),1);EEPROM.write(zeroadress+(i*5)+1,5);EEPROM.write(zeroadress+(i*5)+2,6);EEPROM.write(zeroadress+(i*5)+3,2);EEPROM.write(zeroadress+(i*5)+4,3);ki_pwm[i]=EEPROM.read(zeroadress+(i*5))-1;
      klikk_wait_time[i]=EEPROM.read(zeroadress+(i*5)+1);fade_time[i]=EEPROM.read(zeroadress+(i*5)+2);assistance_time[i]=EEPROM.read(zeroadress+(i*5)+3)-1;
      if (EEPROM.read(zeroadress+(i*5)+4)==1) {min_fenyero[i]=1;}
      if (EEPROM.read(zeroadress+(i*5)+4)==2) {min_fenyero[i]=3;}
      if (EEPROM.read(zeroadress+(i*5)+4)==3) {min_fenyero[i]=5;}
      if (EEPROM.read(zeroadress+(i*5)+4)==4) {min_fenyero[i]=10;}
      if (EEPROM.read(zeroadress+(i*5)+4)==5) {min_fenyero[i]=15;}
      if (EEPROM.read(zeroadress+(i*5)+4)==6) {min_fenyero[i]=20;}
      if (EEPROM.read(zeroadress+(i*5)+4)==7) {min_fenyero[i]=30;}
      if (EEPROM.read(zeroadress+(i*5)+4)==8) {min_fenyero[i]=40;}
      if (EEPROM.read(zeroadress+(i*5)+4)==9) {min_fenyero[i]=50;}
    }
    //alapértelmezett adatokkal történő feltöltés
    //pwm be és kikapcsolás (ki_pwm nevű tömb) 1-nem 2-igen (alapértelmezett 1, nincs pwm vagyis nincs fényerő fel-le 
    //                      üsztatás, csak ki-be kapcsolgatás) 
    //klikkek kozotti idő   (klikk_wait_time nevű tömb) /100msec    (alapértelmezett 5 vagyis 500msec-en belül kell 
    //                      lenyomni a gombot, hogy egy gombnyomás sorozatnak érzékelje és számolja a gombnyomások számát. 
    //                      Ennyi idő után érzékeli folyamatos nyomvatartásnak a gombnyomást és változtatja a fényerőt
    //fel-le usztatási idő  (fade_time nevű tömb) /kb. 0,5sec  (alapértelmezett 6, vagyis 3 sec alatt úsztatja fel vagy le
    //                      a fényerőt a maximumról minimumra. Csak ha van pwm beállítva, akkor értelmezett és felhasznált érték)
    //segédfény ideje       (assistance_time nevű tömb) /3sec  Ha értéke 1, akkor nincs segédfény bekapcsolva, 2-nél 3sec, 
    //                      3-nál 6-se stb. (alapértelmezett 2, vagyis 3sec-ig minimum fényerőn világit a lámpa, és csak ezt 
    //                      követően kapcsol ki. Csak  ha van pwm, akkor értelmezett és felhasznált érték) 
    //minimális fényerő     1-1%, 2-3%, 3-5%, 4-10%, 5-15%, 6-20%, 7-30%, 8-40%, 9-50%
  } //then ág vége
  else  //bekepcsoláskor a paraméter változók feltöltése az eeprom-ból
  {
    Serial.begin(9600); //csak fejlesztéshez a paraméterek kiíratása
    Serial.println("Lampa  pwm  klikk  usztat  seged");  
    Serial.println("-----  ---  -----  ------  -----");  
    for (byte i=0;i<8;i++) 
    {
      ki_pwm[i]=EEPROM.read(zeroadress+(i*5))-1;klikk_wait_time[i]=EEPROM.read(zeroadress+(i*5)+1);fade_time[i]=EEPROM.read(zeroadress+(i*5)+2);assistance_time[i]=EEPROM.read(zeroadress+(i*5)+3)-1;
      Serial.print("  ");   //csak fejlesztéshez a paraméterek kiíratása
      Serial.print(i);
      Serial.print("    ");
      Serial.print(ki_pwm[i]);
      Serial.print("    ");
      Serial.print(klikk_wait_time[i]);
      Serial.print("      ");
      Serial.print(fade_time[i]);
      Serial.print("       ");
      Serial.println(assistance_time[i]); 
    }
  } //else vége
} //void setup vége

void loop()
{
  klikk_detect();
  // ez a fuggvény nem vesz el időt, nincs benne delay utasítás. akár további funkciók is beilleszthetőek, de arra vigyázni kell,
  //hogy a további prgramrészekben se legyenek hosszú várakozások, mert a lámpa vezérlés esetleg nem fog működni
  //ha a program lemarad egy-egy kapcsoló lenyomásról.
} //void loop vége

void klikk_detect() { 
  //egy lenyomás hatására bekapcsol a lámpa. A bekapcsolás a nyomógomb elengedésekor következik be.
  //A nyomógomb elengedésekor elindul egy időzítás, ami minden lenyomáskor ujraindul 500msec (beállítható)időre, 
  //ez alatt további nyomógomb lenyomások történhetnek, de ezek a lámpát nem kapcsolják fel vagy le (nosens változó).
  //Miután letelt a (nosens) időszak, a sw_klik_mem változóban megkapjuk a klikkelések számát. Ha csak egy gombnyomás
  //volt és ezzel fel vagy lekapcsolódott a lámpa, akkor is megkapjuk a számot (1). Ha az első gombnyomás hosszabb ideig
  //tart mint 500msec, akkor az foilyamatos nyomvatartásnak minősül (nyomvatart=1) Ha felkapcsolt lámpánál nyomjuk 
  //folyamatosan a lámpát, akkor az elengedéskor a lámpa nem alszik el, és az sw_klik_mem tartalma 0 marad, a fényerő 
  //növekszik vagy csökken (valtozas_fel_le). Ha lekapcsolt lámpánál nyomjuk folyamatosan a nyomógombot, akkor 500msec
  //után a lámpa felkapcsol, a nyomvatartás ideéig emelkedik a fényerő és a nyomógom elengedésekor az sw_klik_mem 
  //változó 0 marad.
  for (byte i=0;i<8;i++) //végig nézzük az összes nyomógombot
  {
    if (sw_on[i]==0 and digitalRead(be[i])==LOW and sw_prell[i]==0)
       {sw_prell[i]=1;sw_time[i]=millis();} 
       //első lenyomás érzékelése
    if (sw_on[i]==0 and digitalRead(be[i])==LOW and sw_prell[i]==1 and millis()>sw_time[i]+50) 
       {sw_on[i]=1;sw_prell[i]=0;sw_on_time[i]=millis();} 
       // már 50msecv óta nyomva van, most már biztos, hogy lenyomták és nem prellezik
    if (sw_on[i]==1 and digitalRead(be[i])==HIGH and sw_prell[i]==0) 
       {sw_prell[i]=1;sw_time[i]=millis();} 
       //első elengedés érzékelése
    if (sw_on[i]==1 and digitalRead(be[i])==HIGH and sw_prell[i]==1 and millis()>sw_time[i]+50) 
       {sw_valt[i]=0;sw_on[i]=0;sw_prell[i]=0;} 
       // már 50msecv óta elengedte, most már biztos, hogy elengedte a kapcsolót és nincs prell
    
    if (sw_on[i]==1 and sw_prev_stat[i]==0) 
       {sw_tart_time[i]=millis();} 
       //kapcsoló felfutó élénél indítjuk az időmérést a nyomvatartás figyeléshez
    if (sw_on[i]==1 and sw_prev_stat[i]==1 and millis()>sw_tart_time[i]+(klikk_wait_time[i]*100)) 
       //kapcsoló nyomvatartás ha várakozási idő (500msec) letelt
    {
       nyomvatart[i]=1;sw_klik_mem[i]=0;
       if (lamp_on[i]==0)
         {lamp_on[i]=1;fenyero[i]=min_fenyero[i];valtozas_fel_le[i]=1;villan[i]=1;fenyero_nov_time2[i]=millis();}
         //a lámpa nincs felkapcsolva, ezért felkapcsoljuk
    }
    if (sw_on[i]==0 and sw_prev_stat[i]==1 and nyomvatart[i]==1) 
       {nyomvatart[i]=0;sw_klik[i]=0;sw_klik_mem[i]=0;sw_nosens[i]=1;sw_nosens_time[i]=millis();}
       //ha kapcsolót elengedtuk nyomvatartás után, akkor mindent lenullázunk, lámpa felkapcsolva marad, 
       //a következő kapcsoló érzékelésik még 400msec-et várni kell
    if (sw_on[i]==0 and sw_prev_stat[i]==1 and sw_klik[i]==0 and sw_nosens[i]!=1) //sw_on felfutó éle, lápát kel fel vagy le kapcsolni
    {
       sw_klik[i]++;sw_nosens_time[i]=millis();sw_nosens[i]=1; //lehet, hogy több klik lessz, azért növelni kell a klikk számlálót
                                                               //nosens időt elkezdjük mérni, és nosens is 1, ezzel jelezzük, hogy
                                                               //nosens ideig további lenyomások jöttek, nem kell fel le kapcsolni
       if (lamp_on[i]==0) 
         {lamp_on[i]=1;fenyero_nov_time2[i]=millis();}  //lampa felkapcsol
       else 
         {lamp_on[i]=0;}}  //lampa lekapcsol
       //sw_on lefutó éle első kattintáskor, lámpa fel vagy lekapcsol
    if (sw_on[i]==1 and sw_prev_stat[i]==0 and sw_klik[i]>0) 
       {sw_klik[i]++;sw_nosens_time[i]=millis();} 
       //sw_on felfutó második és további felfutó élei, lehet számlálni egyet, és ujraindítjuk a nyomógomb figyelési időzitőt 
    if (sw_nosens[i]==1 and millis()>sw_nosens_time[i]+(klikk_wait_time[i]*100)) 
       {sw_nosens[i]=0;}
       //500msec (illetve beállított érték) után ujra figyeli a nyomógombot
    if (sw_nosens[i]==0 and sw_nosens_prev_stat[i]==1) 
       {sw_klik_mem[i]=sw_klik[i];sw_klik[i]=0;jelzes=1;}
       //miután letelt a várakozási idő (500msec), a nosens lefutó élekor tároljuk a klikkek számát sw_klik_mem-ben
    sw_prev_stat[i]=sw_on[i]; //nyomógom elengedés felismeréséhez     
    lamp_prev_stat[i]=lamp_on[i]; //amikor a lampa felkapcsol, akkor szamolunk egyet
    sw_nosens_prev_stat[i]=sw_nosens[i]; //amig nosens 1 addig számoljuk a klikkeket, illetve a kapcsoló lenyomások nem kapcsolják a lámpát
    if (ki_pwm[i]==1 and pwm_hdvr_mask[i]==1) //csak pwm kimeneteknél és pwm-re beállított kimeneteknél kell fényerő szabályozással foglalkozni
    {
      if (fenyero[i]<min_fenyero[i]+1) 
         {fenyero[i]=min_fenyero[i]+2;}  
         //fényerő minimumra értünk. Azért állunk meg előtte egy értékkel, mert így kikapcsoláskor lesz segédfény
      if (fenyero[i]>254) 
         {fenyero[i]=254;}  
         //fenyero maximumhoz értünk
      if (lamp_on[i]==1 and millis()>fenyero_nov_time2[i]+(fade_time[i]*2))  
         //ha felkapcsoltuk a lámpát akkor a fenyero változóig növeljuk a fényerőt
      {
         if (fenyero_tmp[i]<fenyero[i]) 
            {fenyero_tmp[i]=fenyero_tmp[i]+1;fenyero_nov_time2[i]=millis();analogWrite(ki[i],fenyero_tmp[i]);}
            //még nem értük el a szükséges fényerőt
         if (fenyero_tmp[i]>fenyero[i]) 
            {fenyero_tmp[i]=fenyero_tmp[i]-1;fenyero_nov_time2[i]=millis();analogWrite(ki[i],fenyero_tmp[i]);}
            // csökkenteni is kell a fényerőt, ha folyamatosan nyomja a gombot (követéshez csökkentés is kell)
      }
      if (lamp_on[i]==0 and millis()>fenyero_nov_time2[i]+(fade_time[i]*2))  
         //lekapcsoltuk a lámpát, csökkenteni kell a fénmyerőt 0-ig
      {
         if (fenyero_tmp[i]==min_fenyero[i] and millis()>fenyero_nov_time2[i]+assistance_time[i]*3000+5) 
            {analogWrite(ki[i],0);fenyero_tmp[i]=0;}
            // minimumfényerőnél megállunk a csökkentéssel és várunk, amig segédfény idő le nem telik
         if (fenyero_tmp[i]>min_fenyero[i]) 
            {fenyero_tmp[i]=fenyero_tmp[i]-1;fenyero_nov_time2[i]=millis();analogWrite(ki[i],fenyero_tmp[i]);}
            //fenyerő csökkentés a minimum fényerőig
      }  
      if (lamp_on[i]==0 and lamp_on_prev_stat[i]==1) 
         {analogWrite(ki[i],0);fenyero_nov_time2[i]=millis()+90;}  
         //lampa lekapcsoláskor csökkemnteni fogjuk a fenyerőtz
      if (valtozas_fel_le[i]==1 and nyomvatart[i]==1 and millis()>fenyero_nov_time[i]+15) 
         {fenyero[i]=fenyero[i]+1;fenyero_nov_time[i]=millis();}
         //nyomvatartjuk a gombot és növeljuk a fényerőt maximumig
      if (fenyero[i]==255 and nyomvatart[i]==1 and villan[i]==1) 
         {analogWrite(ki[i],125);fenyero_nov_time2[i]=millis();villan[i]=0;} 
         //nyomvatartjuk a kapcsolót és elértük a maximumot megvillantjuk a lámpát rövid fényerő csökkentéssel
      if (fenyero[i]==255 and nyomvatart[i]==1 and millis()>fenyero_nov_time2[i]+200) 
         {analogWrite(ki[i],255);} 
         //200msec múlva visszakapcsolojuk a fényt maximumra (nyomvatartja a kapcsolót és elértük a maximumot, villanás van)
      if (valtozas_fel_le[i]==0 and nyomvatart[i]==1 and millis()>fenyero_nov_time[i]+15) 
         {fenyero[i]=fenyero[i]-1;fenyero_nov_time[i]=millis();}
         // nyomvatartjuk a gombot és csökkentjük a fényerőt
      if (nyomvatart[i]==0 and nyomvatart_prev_stat[i]==1) //nyomvatartás után elengedtük a nyomógombot
      {
         if (valtozas_fel_le[i]==1) 
           {valtozas_fel_le[i]=0;} //ha eddig "fel" irány volt, akkor most "le" jön
         else 
           {valtozas_fel_le[i]=1;villan[i]=1;} //ha eddig "le" irány volt, akkor most "fel" jön. Engedélyezzük a villanást is
                                               //ha elérte a mximumot a fényerő
      }
      nyomvatart_prev_stat[i]=nyomvatart[i]; //előző ciklus állapotának tárolása a változás megállapításához
//      if (sw_klik_mem[i]==2) 
//      {
//         lamp_on[i]=1;
//         if (valtozas_fel_le[i]==1) 
//            {fenyero[i]=254;valtozas_fel_le[i]=0;} //dupla klikkre növelnunk kell a fényerőt maximumra
//         else 
//            {fenyero[i]=min_fenyero[i]+1;valtozas_fel_le[i]=1;villan[i]=1;};sw_klik_mem[i]=0;sw_klik[i]=0;
//            //dupla klikkre csökkentenünk kell a fényerőt minimumra
//         } 
    }
    else
    {
      if (negyklik==0) {if (lamp_on[i]==1) {digitalWrite(ki[i],HIGH);} else {digitalWrite(ki[i],LOW);}}
    }
    if (digitalRead(exp_input)==LOW) {sw_klik_mem[i]=2;}
    if (sw_klik_mem[i]==2) //két klikk érkezett, minden lámpát lekapcsolunk
    {
       for (byte z=0;z<8;z++)
       {
         lamp_on[z]=0;sw_klik_mem[z]=0;
         //lámpák lekapcsolása
       }
       ;digitalWrite(exp_output,LOW);delay(10);digitalWrite(exp_output,HIGH); //bővítő kimenet írása
    }  //if vége
       // három klik hatására minden lámpát lekapcsolunk
    if (sw_klik_mem[i]==4) //négy klikk történt
    { 
       negyklik=1;negyklik_time=millis();sw_klik_mem[i]=0;villanas_szaml=0;
       for(byte y=0;y<8;y++)
       {
         digitalWrite(ki[y],LOW);lamp_on[y]=0;fenyero_tmp[y]=0;
        //négy klik hatására villogtatunk, és ezzel jelezzuk, hogy bekapcsoljuk az otthonlét szimulátort. Ez még nincs megírva
        //ide kellene írni az ekkor meghívott fügvényt.
       } //for vége
    } //if vége
    if (sw_klik_mem[i]==3)
       {sw_klik_mem[i]=0;digitalWrite(ki[i],LOW);lamp_on[i]=0;fenyero_tmp[i]=0;param_select(i);} 
       //3 klikkel belépünk a setup módba. Előtte  a lámpát lekapcsoljuk. lamp_on[i]=0 lekapcsolja a lámpát
       // fenyero_tmp[i]=0 ahhoz kell, nehogy a következő programciklus visszakapcsolja és fokozatosan 
       //csökkentse 0-ra, miutan kikapcsoluk a lámpát (csak pwm-nél van jelentősége)
    lamp_on_prev_stat[i]=lamp_on[i];
  }
  if (negyklik==1 and millis()>negyklik_time+500)
  {
    for(byte k=0;k<5;k++){
      if (villanas_szaml==0) {if (ki_pwm[k]==0) {digitalWrite(ki[k],HIGH);} else {analogWrite(ki[k],255);}}
      if (villanas_szaml==1) {if (ki_pwm[k]==0) {digitalWrite(ki[k],LOW);} else {analogWrite(ki[k],0);}}
      if (villanas_szaml==2) {if (ki_pwm[k]==0) {digitalWrite(ki[k],HIGH);} else {analogWrite(ki[k],255);}}
      if (villanas_szaml==3) {if (ki_pwm[k]==0) {digitalWrite(ki[k],LOW);} else {analogWrite(ki[k],0);}}
    } 
    villanas_szaml++;
    if (villanas_szaml==4) {negyklik=0;villanas_szaml=0;}
    negyklik_time=millis(); 
  } 
}

void param_select(byte select_lamp) {
  //ha lenyomta ötször a nyomógombot, akkor minden más nyomógob figyelése felfüggesztve
  //megvillogtatjuk a lámpát (a nyomógombhoz tatozót) .-.. (morze L)jelzéssel és várjuk, hogy nyomkkodja a nyomógombot
  //minden egyes alkalommal, maikor paraméter kiválasztásra várunk, ez a morse kód lesz levillogtatva a lámpán.
  // ha nem nyomja le a nyomógombot, akkor 10 sec mulva kilépünk a setupból, ezt egy lámpa villanás jelzi
  //két nyomógomb lenyomás között maximum 500msec telhet el. Ha ennél sűrűbba nyomkodja, akkor számoljuk. 
  //ha 500msec-nél többet várt, és legalább egyszer lenyomta, akkor belépünk a paraméter megadásba
  //Hogy melyik paramétert fogjuk megadni, azt a nyomógomb lenyomások száma adja meg. Négy paraméter van, tehát max. négy
  //nyomógomb lenyomást várunk. Ha többet nyomott le, akkor nem lesz beállítva paraméter.
  //ha visszatértünk paraméter beállításból, akkor ujra indul a 10 sec, és ezen belül ujra lehet paramétert kiválasztani megadni.
  byte setup_indulas_jelzes=1;
  byte param_number=0;  // a kiválasztott paraméter száma
  long select_time; //kiválasztásra szolgáló időt méri
  while ( millis() < select_time+4000) {
    if (setup_indulas_jelzes==1) 
    {
      digitalWrite(ki[select_lamp],LOW);delay(200);digitalWrite(ki[select_lamp],HIGH);delay(200);digitalWrite(ki[select_lamp],LOW);
      delay(200);digitalWrite(ki[select_lamp],HIGH);delay(200);digitalWrite(ki[select_lamp],LOW);
      delay(200);digitalWrite(ki[select_lamp],HIGH);delay(800);digitalWrite(ki[select_lamp],LOW);
      // ..- jelzés arra, hogy várja a paraméter sorszámának megadását
      setup_indulas_jelzes=0;
      select_time=millis();
    } //If vége
    if (sw_on[select_lamp]==0 and digitalRead(be[select_lamp])==LOW and sw_prell[select_lamp]==0)
       {sw_prell[select_lamp]=1;sw_time[select_lamp]=millis();} 
       //első lenyomás érzékelése
    if (sw_on[select_lamp]==0 and digitalRead(be[select_lamp])==LOW and sw_prell[select_lamp]==1 and millis()>sw_time[select_lamp]+50) 
       {sw_on[select_lamp]=1;sw_prell[select_lamp]=0;} 
       //már 50msecv óta nyomva van, most már biztos, hogy lenyomták és nem prellezik
    if (sw_on[select_lamp]==1 and digitalRead(be[select_lamp])==HIGH and sw_prell[select_lamp]==0) 
       {sw_prell[select_lamp]=1;sw_time[select_lamp]=millis();} 
       //első elengedés érzékelése
    if (sw_on[select_lamp]==1 and digitalRead(be[select_lamp])==HIGH and sw_prell[select_lamp]==1 and millis()>sw_time[select_lamp]+50) 
       {sw_on[select_lamp]=0;sw_prell[select_lamp]=0;} 
       // már 50msecv óta elengedte, most már biztos, hogy elengedte a kapcsolót és nincs prell
    if (sw_on[select_lamp]==1 and sw_prev_stat[select_lamp]==0) 
       {param_number++;sw_tart_time[select_lamp]=millis();} 
       //kapcsoló felfutó élénél indítjuk az időmérést a következő lenyomás figyeléshez
    if (param_number>0 and millis()>sw_tart_time[select_lamp]+500)  
       {param_setup(param_number,select_lamp);param_number=0;setup_indulas_jelzes=1;select_time=millis();}
       // ha 500msec-ig nem nyom újabb nyomóggombot, akkor belépünk a paraméter setupba a lenyomások számával
       // paraméter beállítás után ujraindítjuk a setup időt, lehet ujabb paramétert beállítani
    digitalWrite(ki[select_lamp],LOW); //biztosan ne égjen a lámpa
    sw_prev_stat[select_lamp]=sw_on[select_lamp]; //nyomógom elengedés felismeréséhez     
  }
  digitalWrite(ki[select_lamp],LOW);delay(200);digitalWrite(ki[select_lamp],HIGH);delay(200);digitalWrite(ki[select_lamp],LOW);
  //egy rövid (200msec) villanás jelzi, hogy kilépünk a setup-ból
}

void param_setup(byte param_number, byte select_lamp) {
  //Amikor belépünk ebbe a függvénybe, a nyomógomb lenyomások száma jelzi, hogy melyik paramétert fogjuk beállítani.
  //Elősször levillogtatjuk a paraméter számát, majd várjuk, hogy nmyomógomb lenyomások számával megadja  a 
  //beállítandó paraméter értékét. 4sec van arra, hogy elkezdje nyomkodni a gombot, ha nem teszi, kilépünk 
  //a paraméter kiválasztásból, amit egy villanás jelez. Ha legalább egyszer lenyomta a gombot, de ha 500msec-ig 
  //nem nyomja le ujra, akkor befelyeződött a paraméter érték megadása, meghívódik a param_setup függvény
  byte param_value=0;
  long param_ido;
  for (byte u=0;u<param_number;u++) 
  {
    digitalWrite(ki[select_lamp],LOW);delay(400);digitalWrite(ki[select_lamp],HIGH);delay(400);
    //annyit villantunk hosszan (400msec), ahányszor lenyomta a nyomógombot
  }
  digitalWrite(ki[select_lamp],LOW);delay(500); // lekapcsoljuk a lámpát
  //kezdődik a nyomógomb figyelés
  param_ido=millis();
  while ( millis() < param_ido+4000) 
  {
    if (sw_on[select_lamp]==0 and digitalRead(be[select_lamp])==LOW and sw_prell[select_lamp]==0)
       {sw_prell[select_lamp]=1;sw_time[select_lamp]=millis();} 
       //első lenyomás érzékelése
    if (sw_on[select_lamp]==0 and digitalRead(be[select_lamp])==LOW and sw_prell[select_lamp]==1 and millis()>sw_time[select_lamp]+50) 
       {sw_on[select_lamp]=1;sw_prell[select_lamp]=0;} 
       // már 50msecv óta nyomva van, most már biztos, hogy lenyomták és nem prellezik
    if (sw_on[select_lamp]==1 and digitalRead(be[select_lamp])==HIGH and sw_prell[select_lamp]==0) 
       {sw_prell[select_lamp]=1;sw_time[select_lamp]=millis();} 
       //első elengedés érzékelése
    if (sw_on[select_lamp]==1 and digitalRead(be[select_lamp])==HIGH and sw_prell[select_lamp]==1 and millis()>sw_time[select_lamp]+50) 
       {sw_on[select_lamp]=0;sw_prell[select_lamp]=0;} 
       // már 50msecv óta elengedte, most már biztos, hogy elengedte a kapcsolót és nincs prell

    if (sw_on[select_lamp]==1 and sw_prev_stat[select_lamp]==0) {param_value++;sw_tart_time[select_lamp]=millis();} 
       //kapcsoló felfutó élénél indítjuk az időmérést a következő lenyomás figyeléshez
    if (param_value>0 and millis()>sw_tart_time[select_lamp]+500)  {param_store(select_lamp,param_number,param_value);
                                                                   param_value=0;param_ido=millis()-4000;}
       // ha 500msec-ig nem nyom újabb nyomóggombot, akkor belépünk a paraméter setupba a lenyomások számával
    digitalWrite(ki[select_lamp],LOW); //biztosan ne égjen a lámpa
    sw_prev_stat[select_lamp]=sw_on[select_lamp]; //nyomógom elengedés felismeréséhez     
  } //while ciklus vége
}

void param_store(byte select_lamp,byte param_number,byte param_value) {
  //Ennek a függvénynek a feladata a beállított paraméter érték tárolása az EEPROM-ban, és a vezérlést végző tömb
  //változókban. Elősször levillogtatja a program a paraméter értéket, aztán tárol.
  for (byte u=0;u<param_value;u++) {digitalWrite(ki[select_lamp],LOW);delay(400);digitalWrite(ki[select_lamp],HIGH);delay(400);}
    // annyit villantunk hosszan (400msec), ahányszor lenyomta a nyomógombot
  digitalWrite(ki[select_lamp],LOW);delay(500); // lekapcsoljuk a lámpát
  // kezdődik a paraméter érték tárolás és memória változó felülírás az új értékkel
  EEPROM.write(zeroadress+(select_lamp*5)+param_number-1,param_value);
  for (byte i=0;i<8;i++) 
  {
    ki_pwm[i]=EEPROM.read(zeroadress+(i*5))-1;klikk_wait_time[i]=EEPROM.read(zeroadress+(i*5)+1);fade_time[i]=EEPROM.read(zeroadress+(i*5)+2);
    assistance_time[i]=EEPROM.read(zeroadress+(i*5)+3)-1;
      if (EEPROM.read(zeroadress+(i*5)+4)==1) {min_fenyero[i]=1;}
      if (EEPROM.read(zeroadress+(i*5)+4)==2) {min_fenyero[i]=3;}
      if (EEPROM.read(zeroadress+(i*5)+4)==3) {min_fenyero[i]=5;}
      if (EEPROM.read(zeroadress+(i*5)+4)==4) {min_fenyero[i]=10;}
      if (EEPROM.read(zeroadress+(i*5)+4)==5) {min_fenyero[i]=15;}
      if (EEPROM.read(zeroadress+(i*5)+4)==6) {min_fenyero[i]=20;}
      if (EEPROM.read(zeroadress+(i*5)+4)==7) {min_fenyero[i]=30;}
      if (EEPROM.read(zeroadress+(i*5)+4)==8) {min_fenyero[i]=40;}
      if (EEPROM.read(zeroadress+(i*5)+4)==9) {min_fenyero[i]=50;}
  }
  delay(1000);
}

Mennyire volt hasznos amit olvastál? Értékelés után szövegesen is leírhatod megjegyzéseidet és véleményedet!

Kattints egy csillagra az értékeléshez!

Szövegesen is leírhatod véleményedet! Ha kérdésed van, ne felejtsd el megadni az email címedet!