Lakás világítás 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. 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.
Így néz ki a megépített vezérlő:

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.

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

  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?

Kattints egy csillagra az értékeléshez!

Sajnálom, hogy amit olvastál nem volt hasznos számodra!

Szeretném ha elégedett lennél!

Írd le kérlek, hogy mi nem tetszett!?