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.
- 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.
- 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).
- 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);
}
Utólag emlékezetből lerajzoltam a megépített vezérlő kapcsolási rajzát. Fontos különbség a rajz és a valóság között, hogy eredetiben ATMeaga328P chip-et építettem az áramkörre, amihez ugyebár még egy kvarcz kristály és két kondenzátor is kell. Nomeg eredetiben egy 5V-os tápegységet is építettem az áramkörre egy kicsi trafóval és 5V-os táp IC-vel. Praktikusabbnak látszik mamár egy Arduino nano egy telefon USB töltővel!!
Áramköri rajz (csak egy csatorna szerepel rajta a 6-ból):
Néhány instrukció és magyarázat a képen látható megoldásokhoz:
- Elméletileg 8 csatornát lehet kialakítani. A rajzon csak egy csatorna látható, a többi teljesen azonos, csak a nyomógombok más bemenetre lennének kötve, illetve a kimenetek is más mosfet-et hajtanak meg. Nyilván kimenetnek a PWM kimeneteket érdemes választani, amikből összesen 6 db van. Két csatorna ezért „digitális” kell hogy legyen. Vagyis csak ki és bekapcsol.
- Azokban a szobákban, ahol nem kellett fényerőszabályozás (pl. 230V-os teljesítmény ledeket szereltem), egy relével kapcsolom a 230V-ot. A reléket ugyanúgy a mosfet kapcsolja, mint a rajzon látható power led-et. A relé 24, 12 vagy akár 5V-os is lehet, mert a mosfet bármilyen feszültséget tud kapcsolni, amit rákötünk. Nálam mindhárom eset előfordul (led szalad 12V, 10V-os teljesítmény ledek sorba kapcsolva soros ellenállással 24V-on, 5V-os relé a 230V kapcsolására). Ha valaki relét kapcsol a mosfet-el, az ne feledje el a relé tekercsivel párhuzamosan a védődiódát, különben kezdheti előről ez egészet. A relé igen nagy feszültséget indukál kikapcsoláskor, és a nano-nak annyi! Ha relét teszünk a kimenetre, akkor úgy kell programozni a vezérlőt (fenti setup leírás szerint), hogy ne legyen fényerőszabályozás az adott csatornán.
- FONTOS! A rajzon a power led-el sorba van egy ellenállás. Ez esetleg akkor kell, ha valaki ugyanazt a megoldást választja mint én, azaz több led-et kapcsol sorba, és az áramot egy soros ellenállással állítja be. A rajzon szereplő ellenállás érték hibás. Utólag vettem észre. Nyilván nem 100ohm kell, hanem konkrétan ki kell számolni, vagy kísérletezni. Nálam a kb. 10V-os 10W-os power ledekhez kb. 1ohm 5W ellenállás kellett.
- Tesztelés és szerviz célokból az áramkörre is építettem nyomógombokat minden csatornához. Ugyanezen célból került a kimenetre egy-egy led. Így teszteléskor nem kellett az áramkört bekötni a helyére. Jól jött ez a megoldás akkor is, amikor buta módon bekötöttem közvetlenül a bemenetre a fali kapcsolókat (csengő kapcsoló, csak klikk-elünk vele) a hozzájuk vezető 10-20 m-es vezetékekkel. Annyi zajt szedtek össze, hogy tűzijátékot játszott az áramkör. Persze ha kikötöttem a vezetéket, minden jól működött a beépített nyomógombokról. Sokat segített ez a megoldás a hiba megoldásában.
- Az előző pontban szereplő zajszűrés céljából került a nyomógombbal párhuzamosan egy 1 mikroF kondi (vagy elkó is jó polaritás helyesen bekötve), és egy 1Kohm körüli felhúzó ellenállás. A zajok nem tudnak akkora energiát szolgáltatni, hogy lényegesen megváltozzon a kondi feszültsége. Így utólag még esetleg egy 4.7V-os zener diódát is oda tennék párhuzamosan a kondival, mert nagyon hosszú vezetéknél akár 5V feletti feszültség is kialakulhat.
- A rajzon szereplő alapbeállítás gomb nem feltétlenül kell, meg lehet oldani a problémát programból is. Már akinek elérhető helyen van az áramkör, és hozzáfér egy laptoppal.
- A cikk eléjén szerepel egy fotó a kész világítás vezérlésről. Látható, hogy a mosfet-ek hatalmas hűtőbordára kerültek. A legnagyobb áram amit kapcsolok velük 24V 3A, ez meg sem kottyan nekik. Még csak nem is langyosodnak. Ekkora áramnál semmi szükség ekkora hűtésre. Ezt alaposan eltúloztam! Elég egy 5x5cm-es alumínium lemez, vagy akár a semmi is elég! Ki kell persze próbálni.