Fényérzékelés fotoellenállással és környezeti megvilágításszabályzás

Az Arduino és a fotoellenállás (LDR) segítségével egyszerűen és hatékonyan mérhetjük a környezeti fényviszonyokat. Ez a cikk részletesen bemutatja, hogyan építhetsz egy fényérzékelő rendszert, amely automatikusan kapcsolja a világítást, figyelembe véve a hiszterézis és a fényerő-szabályozás alapelveit. Ha dugdosós panelnél gyorsabb és stabilabb megoldásra van szükséged – a fotoellenállás modul kerül képbe – amely megkönnyíti az Arduino-val való munkát. Részletes áramköri rajzokkal, Arduino programkódokkal és magyarázatokkal vezetlek végig az automatikus világításvezérlés lépésein.

A cikkben egy fejlett világításvezérlő rendszert is bemutatok, amely nem csupán a fényviszonyokhoz igazodik, hanem fokozatosan növeli a LED fényerejét és a Serial Plotter segítségével valós időben is elemezhető. És még 1-2 megoldási trükk is terítékre kerül.

Tartalomjegyzék

Fotoellenállás modul használata – az egyszerűbb és gyorsabb megoldás

A fotoellenállás (LDR) egy rendkívül hasznos eszköz a fényintenzitás mérésére, de a hagyományos áramköri összeállítás – amely különálló fotoellenállást és járulékos ellenállást igényel – olykor időigényes és hibalehetőségekkel erősen terhelt megoldásra vezet. Ha gyorsabb, kompaktabb és könnyebben kezelhető megoldást keresel, akkor léteznek fotoellenállás modulok, amelyek egy egyszerűbb csatlakozási lehetőséget kínálnak. Ezek gyárilag tartalmazzák a fotoellenállást és a szükséges kiegészítő ellenállást valamint egy nyáklapra szerelt csatlakozósort, amelynek segítségével gyorsan és precízen illeszthetők az Arduino rendszerhez. A használatukkal elkerülhető a különálló alkatrészekkel való bajlódás, így különösen ajánlottak gyors prototípus-fejlesztéshez, oktatási célokra, vagy ha megbízható és stabil megoldásra van szükség.

Fényérzékelő modul, amely egy fotoellenállást (LDR) és egy ellenállást tartalmaz, három kivezetéssel az áramkörhöz való csatlakoztatáshoz. (KY-018 típusszám)

A fotoellenállás modul előnyei

Gyors és egyszerű csatlakozás: A modul három kivezetéssel rendelkezik – GND (GND – föld) / VCC (+ – tápfeszültség) / OUT (S – kimenet) –, amelyeket közvetlenül az Arduino megfelelő csatlakozóihoz lehet kötni, megkönnyítve a bekötést és az áramköri tervezést.
Stabil és megbízható működés: A gyárilag kalibrált ellenállások és precíz forrasztási pontok biztosítják a pontos működést és minimalizálják az áramköri zajokat vagy bekötési hibákat.
Időtakarékosság: Mivel az összes szükséges alkatrész egyetlen modulon található, a hagyományos vezetékes vagy breadboard-os összeállítással szemben jelentős időt takaríthatsz meg.
Hibamentes megoldás kezdők számára: Az előre gyártott modulok kiküszöbölik az alkatrészválasztásból vagy pontatlan/helytelen bekötésből adódó hibalehetőségeket.

A fotoellenállás modul bekötése Arduino laphoz

A modul használata rendkívül egyszerű, mindössze három vezeték szükséges a csatlakoztatásához:

VCC (tápfeszültség): Kösd az Arduino 5V kimenetére.
GND (földelés): Csatlakoztasd az Arduino GND lábához.
OUT (kimenet): Kösd az Arduino A1 analóg bemenetére, ahol az érzékelt fényintenzitás alapján feszültségmérés történik.

Egy Arduino Uno mikrokontrollerhez csatlakoztatott fényérzékelő modul, amely egy fotoellenállást (LDR) tartalmaz. A kábelek a tápellátást (5V és GND) és az analóg bemenetet (A1) kötik össze az érzékelő modullal.

Az előző cikkben (ami a →Fényérzékelés fotoellenállással oldalon található) – az ott leírt programkódok ezzel a moduláris fotoellenállással is használhatóak.

Fényérzékelés Arduinoval – Automatikus esti világítás fényérzékelővel

Az intelligens világításvezérlés egy rendkívül hasznos alkalmazása a fényérzékelésnek. Ebben a fejezetben megvalósítunk egy olyan megoldást, amely egy fotoellenállás segítségével vezérli egy LED fényerejét az esti és félhomályos órákban. A rendszer a következő funkciókat fogja ellátni:

Automatikus világítás kapcsolás: A LED bekapcsol, ha a környezet fényszintje egy beállított érték alá csökken.
Hiszterézis alkalmazása: Megakadályozza a villogást a határérték közelében.
Fényerő fokozatos növelése: A környezet sötétségi szintjétől függően fokozatosan növekszik a LED fényereje.
Paraméterezhetőség: A küszöbértékek és az érzékenység a kód elején módosíthatóak.

Áramköri összeállítás

A projekt elkészítéséhez a következőkre lesz szükséged:

	→ Arduino Uno alaplap: Ez fogja kezelni az érzékelőt.
	→ LED modul (3W fehér): A megvilágítást adó részegység
	→ Fotoellenállás modul: A szenzorkészletek részeként is elérhető.
	→ Dupont összekötő kábelek (apa-apa/apa-anya/anya-anya).
	→ Breadboard – a könnyű csatlakoztatáshoz.

Bekötési lépések

Ha a közvetlen kábelezés nm járható út, akkor a BreadBoard is használható a könnyebb megépítéshez.
A fotoellenállás-modult csatlakoztasd az Arduino 5V és GND tápfeszültségéhez.
A fotoellenállás modul szenzorkimenetét (az LDR és ellenállásközös pontja) csatlakoztasd az A1 analóg bemenetre.
A LED modult csatlakoztasd az Arduino 5V és GND tápfeszültségéhez
A LED modul vezérlését kösd az Arduino egyik PWM kimenetére (itt: D9 kivezetés).

Egy Arduino Uno mikrokontroller kapcsolási rajza, amelyhez egy fotoellenállás és egy LED modul csatlakozik különböző színű vezetékekkel.

Tipp: Ha a fotoellenállás modult közvetlenül az A1-S , A2-5V, A3-GND kivezetésekre helyezzük, akkor az A2 és A3 kivezetéseket egyszerű digitális kimenetekként a GND és a +5V feszültségre állíthatjuk – így megúszható a kábelezés és a modul tápellátását biztosítjuk.

Arduino programkód – Fényerő vezérlése félhomályban és sötétben

Az alábbi program automatikusan vezérli a LED fényerejét a környezeti fényviszonyoknak megfelelően.

// --- Beállítható paraméterek ---
#define DARK_THRESHOLD 230      // A sötétben mért fotoellenállás analóg értéke (PWM = 255)
#define TURN_OFF_THRESHOLD 840  // A világosban mért fotoellenállás értéke (PWM = 0)
#define LED_PIN 9               // LED kimeneti láb (PWM)
#define LDR_PIN A1              // Fotóellenállás bemeneti láb
#define DELAY_TIME 100          // Mérési ciklus késleltetés (ms)

void setup() {
  pinMode(LED_PIN, OUTPUT);     // LED kimenet beállítása
  Serial.begin(9600);           // Soros kommunikáció indítása
}

void loop() {
  int lightValue = analogRead(LDR_PIN);  // Fényintenzitás beolvasása
  int brightness = 0;           // LED alapértelmezett fényereje

  // A LED fényerejének skálázása a sötét és világos határértékek között
  brightness = map(lightValue, TURN_OFF_THRESHOLD, DARK_THRESHOLD, 0, 255);
  brightness = constrain(brightness, 0, 255);  // Határok között tartás

  analogWrite(LED_PIN, brightness);  // LED fényerejének beállítása

  // Soros monitor kiírás a teszteléshez
  Serial.print("Feny:"); Serial.print(lightValue);
  Serial.print("\tLED:"); Serial.print(brightness);
  Serial.print("\tMin:"); Serial.print(TURN_OFF_THRESHOLD);
  Serial.print("\tMax:"); Serial.println(DARK_THRESHOLD);

  delay(DELAY_TIME);            // Mérési ciklus késleltetése
}

// --- Beállítható paraméterek ---

#define DARK_THRESHOLD 230 // A sötétben mért fotoellenállás analóg értéke (PWM = 255)

#define TURN_OFF_THRESHOLD 840 // A világosban mért fotoellenállás értéke (PWM = 0)

#define LED_PIN 9 // LED kimeneti láb (PWM)

#define LDR_PIN A1 // Fotóellenállás bemeneti láb

#define DELAY_TIME 100 // Mérési ciklus késleltetés (ms)

void setup() {

pinMode(LED_PIN, OUTPUT); // LED kimenet beállítása

Serial.begin(9600); // Soros kommunikáció indítása

}

void loop() {

int lightValue = analogRead(LDR_PIN); // Fényintenzitás beolvasása

int brightness = 0; // LED alapértelmezett fényereje

// A LED fényerejének skálázása a sötét és világos határértékek között

brightness = map(lightValue, TURN_OFF_THRESHOLD, DARK_THRESHOLD, 0, 255);

brightness = constrain(brightness, 0, 255); // Határok között tartás

analogWrite(LED_PIN, brightness); // LED fényerejének beállítása

// Soros monitor kiírás a teszteléshez

Serial.print("Feny:"); Serial.print(lightValue);

Serial.print("\tLED:"); Serial.print(brightness);

Serial.print("\tMin:"); Serial.print(TURN_OFF_THRESHOLD);

Serial.print("\tMax:"); Serial.println(DARK_THRESHOLD);

delay(DELAY_TIME); // Mérési ciklus késleltetése

}

Rövid működési összefoglaló

1. Beolvassa a fényintenzitást a fotoellenállásról (analogRead()).
2. A LED fényerejét beállítja a mért fényérték alapján:

Sötétben (DARK_THRESHOLD) → LED teljes fényerő (PWM = 255)
Világosban (TURN_OFF_THRESHOLD) → LED kikapcsol (PWM = 0)
Köztes értékeknél → A LED fényereje arányosan változik.

3. A map() függvény átalakítja az analóg beolvasott értéket 0-255 PWM tartományba.
4. A constrain() biztosítja, hogy a PWM értékek mindig a 0-255 tartományban maradjanak.
5. A LED aktuális fényerejét az analogWrite() állítja be.
6. A soros monitor kiírja az aktuális fényértéket és a LED állapotát.

Tipp: ha a programot feltöltjuk az Arduino lapra, akkor
– letakarva a fényérzékelő ellenállást a soros monitoron leolvashatjuk a minimum analóg értéket (DARK_THRESHOLD)
– elvéve a kezünket és a ellenállást fényt kapva a soros vonalon a határértéket olvashatjuk le, ahol a LED-nek már nem kell világítania (TURN_OFF_THRESHOLD)

Ha a DARK_THRESHOLD és a TURN_OFF_THRESHOLD értékeket ~10-15 értékkel csökkentjük, akkor biztosabb kapcsolási / billenési értékeket állíthatunk be.

A beállított billenési értékek és a mért megvilágításérték és a LED adatai.

A programhoz tartozó adatok vizualizálhatók az Arduino Serial Plotter funkciójával. Ehhez egyszerűen nyisd meg az Eszközök → Soros plotter menüpontot… Az eredmény valami hasonló lesz: ha a fényérzékelőt kitakarod illetve megvilágítod.
Ha a beállítás után a programot újrafordítjuk és feltöltjük, akkor a →Serial Plotter segítségével nagyon jól követhető a program működése.

A nyers adatok grafikonon ábrázolva... — A nyers adatok grafikonon ábrázolva…

Egy Arduino Uno mikrokontroller kapcsolási rajza, amelyhez egy fotoellenállás és egy LED modul csatlakozik különböző színű vezetékekkel.

Egyszerű ki-/bekapcsolásra redukált program

A világításvezérlés egyik legfontosabb kérdése, hogy a rendszer miként reagál a környezeti fényviszonyok változásaira. A mostani cél egy olyan automatizált megoldás, amely sötétben azonnal bekapcsol, viszont világosban nem kapcsol ki rögtön, hanem kivár egy beállított időtartamot, hogy elkerülje a felesleges ki-bekapcsolásokat. Ez a logika különösen hasznos lehet kültéri világítás esetén, ahol egy rövid fényvillanás – például egy autó fényszórója vagy egy felhők közül előbújó napsugár – nem indokolja a lámpák azonnali kikapcsolását. Ugyanakkor a rendszer képes azonnal reagálni a sötétedésre, így a világítás pontosan akkor kapcsol be, amikor arra valóban szükség van.

Mikor és miért lehet hasznos a ki-bekapcsolós világításvezérlés?

Az előző fejezetben bemutatott PWM-alapú fényerőszabályozás olyan helyzetekben hasznos, amikor fokozatos átmenetet szeretnénk elérni a világítás fényerejében. Ez jó megoldás lehet például beltéri hangulatvilágításhoz vagy olyan alkalmazásokhoz, ahol a LED-ek fokozatos halványítása és felerősítése vizuálisan kellemesebb. Ezzel szemben a ki-bekapcsolós megoldás egy egyszerűbb, de sok esetben hatékonyabb világításvezérlési logika. Az alábbi esetekben kifejezetten előnyös:

Kültéri világítás automatizálása

A LED azonnal bekapcsol, ha besötétedik – nincs lassú átmenet, azonnali reakció van.
Ha a fényviszonyok gyorsan változnak (például egy felhő elhalad a hold előtt, vagy egy autó fényszórója megvilágítja a szenzort), a lámpa nem kapcsol ki rögtön, hanem kivárja, hogy a világosság tartósan fennáll-e.

Biztonsági világítás és vészhelyzeti fények

Egy áramszünet vagy hirtelen fényviszony-változás esetén a világítás azonnal aktiválódik.
Nem kell attól tartani, hogy egy rövid világos impulzus (például egy mozgás közbeni fényvisszaverődés) kikapcsolja a fényt.

Garázs- és bejárati világítások

Ha valaki este beáll az autóval a garázsba, a fény azonnal felkapcsol, így biztosítja a megfelelő látási viszonyokat.
A rendszer nem kapcsolja le rögtön a világítást, ha az autó reflektora egy pillanatra megvilágítja a szenzort – ehelyett kivárja, hogy valóban világos marad-e a környezet.

De hogyan működik a ki-bekapcsolós világításvezérlő?

A rendszer működésének alapját – még mindig – egy fotoellenállás (LDR) adja, amely folyamatosan figyeli a környezeti fényviszonyokat.

Ha a mért fényintenzitás egy adott határérték (DARK_THRESHOLD) alá csökken, a LED azonnal bekapcsol.
Ha a mért fényérték egy másik határérték (TURN_OFF_THRESHOLD) fölé emelkedik, akkor a rendszer nem kapcsolja ki azonnal a fényt, hanem indít egy időzítőt.
Ha a világos állapot folyamatosan fennáll egy beállított időtartamig (pl. 5 másodpercig), a LED kikapcsol.
Ha közben a fényérték visszacsökken a sötét tartományba, az időzítő újraindul, és a fény továbbra is égve marad.

A logika célja az, hogy a világítás ne kapcsoljon le egy-egy rövid fényvillanás miatt, hanem csak akkor, ha valóban tartósan világos van.

// --- Beállítható paraméterek --- 
#define DARK_THRESHOLD 270         // A sötétben mért fotoellenállás értéke (LED bekapcsolás)
#define TURN_OFF_THRESHOLD 800     // A világosban mért fotoellenállás értéke (LED kikapcsolási küszöb)
#define LED_PIN 9                  // LED vagy relévezérlő kimenet
#define LDR_PIN A1                 // Fotoellenállás bemeneti láb
#define DELAY_TIME 100             // Mérési ciklus késleltetés (ms)
#define LIGHT_STABLE_TIME 5000     // Kikapcsolási idő (5 másodperc világos után)

unsigned long lightStartTime = 0;  // A világos környezet kezdő időpontja
bool ledState = false;             // LED állapota (bekapcsolva/kikapcsolva)

void setup() {
  pinMode(LED_PIN, OUTPUT);        // LED kimenet beállítása
  Serial.begin(9600);              // Soros kommunikáció indítása
}

void loop() {
  int lightValue = analogRead(LDR_PIN);  // Fényintenzitás beolvasása
  
  // Ha sötét van, azonnal kapcsoljon be a LED
  if (lightValue <= DARK_THRESHOLD) {
    ledState = true;               // Bekapcsolás
    lightStartTime = millis();     // Időzítő újraindítása
  }
  
  // Ha világos van, számolja az időt és csak akkor kapcsoljon ki, ha 5 másodpercnél tovább világos
  else if (lightValue >= TURN_OFF_THRESHOLD) {
    if (lightStartTime == 0) {     // Ha először észlel világosságot, jegyezze meg az időpontot
      lightStartTime = millis();
    }
    if (millis() - lightStartTime >= LIGHT_STABLE_TIME) {  // Ha folyamatosan világos 5 másodpercig
      ledState = false;            // Kikapcsolás
    }
  } else {
    lightStartTime = millis();     // Ha a fényviszony változik, időzítő újraindítása
  }

  // LED állapotának frissítése
  digitalWrite(LED_PIN, ledState ? HIGH : LOW);

  // Soros monitor kiírás a teszteléshez
  Serial.print("Feny:"); Serial.print(lightValue);
  Serial.print("\tLED:"); Serial.print(ledState ? "ON" : "OFF");
  Serial.print("\tMin:"); Serial.print(TURN_OFF_THRESHOLD);
  Serial.print("\tMax:"); Serial.println(DARK_THRESHOLD);

  delay(DELAY_TIME);               // Mérési ciklus késleltetése
}

// --- Beállítható paraméterek ---

#define DARK_THRESHOLD 270 // A sötétben mért fotoellenállás értéke (LED bekapcsolás)

#define TURN_OFF_THRESHOLD 800 // A világosban mért fotoellenállás értéke (LED kikapcsolási küszöb)

#define LED_PIN 9 // LED vagy relévezérlő kimenet

#define LDR_PIN A1 // Fotoellenállás bemeneti láb

#define DELAY_TIME 100 // Mérési ciklus késleltetés (ms)

#define LIGHT_STABLE_TIME 5000 // Kikapcsolási idő (5 másodperc világos után)

unsigned long lightStartTime = 0; // A világos környezet kezdő időpontja

bool ledState = false; // LED állapota (bekapcsolva/kikapcsolva)

void setup() {

pinMode(LED_PIN, OUTPUT); // LED kimenet beállítása

Serial.begin(9600); // Soros kommunikáció indítása

}

void loop() {

int lightValue = analogRead(LDR_PIN); // Fényintenzitás beolvasása

// Ha sötét van, azonnal kapcsoljon be a LED

if (lightValue <= DARK_THRESHOLD) {

ledState = true; // Bekapcsolás

lightStartTime = millis(); // Időzítő újraindítása

}

// Ha világos van, számolja az időt és csak akkor kapcsoljon ki, ha 5 másodpercnél tovább világos

else if (lightValue >= TURN_OFF_THRESHOLD) {

if (lightStartTime == 0) { // Ha először észlel világosságot, jegyezze meg az időpontot

lightStartTime = millis();

}

if (millis() - lightStartTime >= LIGHT_STABLE_TIME) { // Ha folyamatosan világos 5 másodpercig

ledState = false; // Kikapcsolás

}

} else {

lightStartTime = millis(); // Ha a fényviszony változik, időzítő újraindítása

}

// LED állapotának frissítése

digitalWrite(LED_PIN, ledState ? HIGH : LOW);

// Soros monitor kiírás a teszteléshez

Serial.print("Feny:"); Serial.print(lightValue);

Serial.print("\tLED:"); Serial.print(ledState ? "ON" : "OFF");

Serial.print("\tMin:"); Serial.print(TURN_OFF_THRESHOLD);

Serial.print("\tMax:"); Serial.println(DARK_THRESHOLD);

delay(DELAY_TIME); // Mérési ciklus késleltetése

}

A kód könnyen testre szabható az adott környezet fényviszonyaihoz, és relé segítségével nagyobb teljesítményű fényforrásokat is vezérelhet. Az energiatakarékos működés és a megbízható kapcsolási logika miatt kiválóan alkalmazható kültéri és beltéri világítási rendszerek automatizálására. De ne is álljunk meg ennél a pontnál! Fejlesszük tovább:

Mozgásérzékelővel kombinálható kültéri fényforrások

A ki-bekapcsolási logika jól kombinálható egy mozgásérzékelővel, amely akkor aktiválja a világítást, ha valaki közeledik.
Ha a környezeti fény megfelelő, a rendszer nem kapcsol feleslegesen.

PIR bővítéssel készített világítás

Az alábbi mintarendszer egy PIR mozgásérzékelővel (SR501) és egy fotoellenállással (LDR) kiegészített világításvezérlő, amely sötétben észlelt mozgás esetén kapcsolja be a LED-et, és mozgás megszűnése után egy meghatározott ideig világítva marad. A világítás nem kapcsol ki rögtön a mozgás megszűnése után, hanem csak késleltetés letelte végén. De …

…mi az a PIR mozgásérzékelő és hogyan működik?

A PIR (Passzív Infravörös) mozgásérzékelő egy olyan eszköz, amely az emberi test által kibocsátott infravörös sugárzást érzékeli, és ezt használja mozgásdetektálásra. Az SR501 típusú PIR szenzor az egyik leggyakrabban alkalmazott változat, amely olcsó, megbízható és egyszerűen használható. A szenzor működése két fő komponensre épül: egy pyroelektromos érzékelőre, amely érzékeli az infravörös sugárzást, valamint egy Fresnel-lencsére, amely a környezetből érkező IR sugarakat a detektorra fókuszálja. Amikor egy ember vagy más hőforrás elhalad a szenzor látóterében, az infravörös sugárzás mintázata megváltozik, ezt a PIR érzékelő észleli, és magas (HIGH) jelszintet küld az Arduino számára. A PIR érzékelők nem aktívan bocsátanak ki jeleket, hanem csak a környezet hősugárzását figyelik, így rendkívül energiatakarékosak. Az SR501 típust gyakran használják biztonsági rendszerekhez, automatikus világításvezérléshez és okosotthon alkalmazásokhoz. A szenzor érzékenysége és az aktiválási idő késleltetése potméterekkel állítható (vagy fixen beállított változat is elérhető), így a felhasználási igényekhez igazítható.

Egy Arduino Uno mikrokontroller áramköri kapcsolási rajza, amelyhez egy PIR mozgásérzékelő és egy fotoellenállás és egy LED modul csatlakozik különböző színű vezetékekkel. — A képen egy Arduino Uno látható, amelyhez egy PIR mozgásérzékelő és egy LED modul és egy megvilágításmérő modul van csatlakoztatva. A kapcsolások különböző színű vezetékekkel történnek a megfelelő tápfeszültség (VCC), föld (GND) és jel (S) vezetékek használatával.

Ez a megfigyelő-szenzor különösen hasznos olyan helyzetekben, ahol csak mozgás esetén szeretnénk aktiválni egy rendszert, például világítást, riasztót vagy ajtónyitó mechanizmust. Az Arduino-val való integrációja egyszerű, mindössze egy digitális bemenetre van szükség, amely figyeli a PIR jeleit és a megfelelő reakciót váltja ki. Itt is ezt használjuk ki.

Működési logika

Az előző programunkat egészítjük ki…

Ha besötétedik (DARK_THRESHOLD alatt) és mozgás van a PIR előtt, a LED azonnal bekapcsol.
Ha a PIR mozgást érzékel, a LED végig ég és az időzítés újraindul minden mozgásérzékeléskor.
Ha nincs mozgás és továbbra is sötét van, a LED a PIR utolsó érzékelése után egy meghatározott időtartamig égve marad, majd kikapcsol.
Ha a fényerő eléri a TURN_OFF_THRESHOLD értéket (tartós világos állapot), a LED kikapcsol, és a PIR nem kapcsolja újra a világítást.
A PIR csak sötétben aktív! Ha világos van, a mozgásérzékelés figyelmen kívül marad.

Mindezeket a kódunkba be is építjük (azaz az előzőt kiegészítjük):

// --- Beállítható paraméterek ---
#define DARK_THRESHOLD 270         // A sötétben mért fotoellenállás értéke (LED bekapcsolás)
#define TURN_OFF_THRESHOLD 800     // A világosban mért fotoellenállás értéke (LED kikapcsolási küszöb)
#define LED_PIN 9                  // LED vagy relévezérlő kimenet
#define LDR_PIN A1                 // Fotoellenállás bemeneti láb
#define PIR_PIN 11                 // PIR mozgásérzékelő bemenet (SR501)
#define DELAY_TIME 100             // Mérési ciklus késleltetés (ms)
#define LIGHT_STABLE_TIME 5000     // Kikapcsolási idő világos környezetben (ms) - 5 másodperc
#define PIR_STABLE_TIME 20000      // PIR mozgás utáni LED kikapcsolási idő (4x hosszabb)

// Időzítés változók
unsigned long lightStartTime = 0;   // A világos környezet kezdő időpontja
unsigned long motionEndTime = 0;    // Utolsó mozgás érzékelés időpontja
bool ledState = false;              // LED állapota (bekapcsolva/kikapcsolva)

void setup() {
  pinMode(LED_PIN, OUTPUT);         // LED kimenet beállítása
  pinMode(PIR_PIN, INPUT);          // PIR mozgásérzékelő bemenet
  Serial.begin(9600);               // Soros kommunikáció indítása
}

void loop() {
  int lightValue = analogRead(LDR_PIN);  // Fényintenzitás beolvasása
  bool motionDetected = digitalRead(PIR_PIN); // PIR mozgásérzékelő állapota

  // Ha sötét van és mozgás van, azonnal kapcsoljon be a LED
  if (lightValue <= DARK_THRESHOLD && motionDetected) {
    ledState = true;                // LED bekapcsol
    motionEndTime = millis() + PIR_STABLE_TIME; // Utolsó mozgás utáni időzítés
    lightStartTime = millis();      // Fény időzítés újraindítása
  }

  // Ha világos van, akkor időzítve kikapcsol
  else if (lightValue >= TURN_OFF_THRESHOLD) {
    if (lightStartTime == 0) {      // Ha először észlel világosságot, jegyezze meg az időpontot
      lightStartTime = millis();
    }
    if (millis() - lightStartTime >= LIGHT_STABLE_TIME) {  // Ha folyamatosan világos van 5 másodpercig
      ledState = false;             // Kikapcsolás
    }
  }

  // Ha mozgás megszűnt, de továbbra is sötét van, akkor várakozik a PIR_STABLE_TIME idejéig
  if (!motionDetected && millis() > motionEndTime && lightValue <= DARK_THRESHOLD) {
    ledState = false; // Kikapcsolás mozgás után 4x késleltetéssel
  }

  // Ha világos van, akkor a PIR mozgásérzékelést figyelmen kívül hagyja
  if (lightValue >= TURN_OFF_THRESHOLD) {
    motionEndTime = millis(); // Mozgásérzékelés újraindítása
  }

  // LED állapotának frissítése
  digitalWrite(LED_PIN, ledState ? HIGH : LOW);

  // Soros monitor kiírás a teszteléshez
  Serial.print("Feny: "); Serial.print(lightValue);
  Serial.print("\tPIR: "); Serial.print(motionDetected ? "Mozgás" : "Nincs mozgás");
  Serial.print("\tLED: "); Serial.print(ledState ? "ON" : "OFF");
  Serial.print("\tMin: "); Serial.print(TURN_OFF_THRESHOLD);
  Serial.print("\tMax: "); Serial.println(DARK_THRESHOLD);

  delay(DELAY_TIME);                // Mérési ciklus késleltetése
}

// --- Beállítható paraméterek ---

#define DARK_THRESHOLD 270 // A sötétben mért fotoellenállás értéke (LED bekapcsolás)

#define TURN_OFF_THRESHOLD 800 // A világosban mért fotoellenállás értéke (LED kikapcsolási küszöb)

#define LED_PIN 9 // LED vagy relévezérlő kimenet

#define LDR_PIN A1 // Fotoellenállás bemeneti láb

#define PIR_PIN 11 // PIR mozgásérzékelő bemenet (SR501)

#define DELAY_TIME 100 // Mérési ciklus késleltetés (ms)

#define LIGHT_STABLE_TIME 5000 // Kikapcsolási idő világos környezetben (ms) - 5 másodperc

#define PIR_STABLE_TIME 20000 // PIR mozgás utáni LED kikapcsolási idő (4x hosszabb)

// Időzítés változók

unsigned long lightStartTime = 0; // A világos környezet kezdő időpontja

unsigned long motionEndTime = 0; // Utolsó mozgás érzékelés időpontja

bool ledState = false; // LED állapota (bekapcsolva/kikapcsolva)

void setup() {

pinMode(LED_PIN, OUTPUT); // LED kimenet beállítása

pinMode(PIR_PIN, INPUT); // PIR mozgásérzékelő bemenet

Serial.begin(9600); // Soros kommunikáció indítása

}

void loop() {

int lightValue = analogRead(LDR_PIN); // Fényintenzitás beolvasása

bool motionDetected = digitalRead(PIR_PIN); // PIR mozgásérzékelő állapota

// Ha sötét van és mozgás van, azonnal kapcsoljon be a LED

if (lightValue <= DARK_THRESHOLD && motionDetected) {

ledState = true; // LED bekapcsol

motionEndTime = millis() + PIR_STABLE_TIME; // Utolsó mozgás utáni időzítés

lightStartTime = millis(); // Fény időzítés újraindítása

}

// Ha világos van, akkor időzítve kikapcsol

else if (lightValue >= TURN_OFF_THRESHOLD) {

if (lightStartTime == 0) { // Ha először észlel világosságot, jegyezze meg az időpontot

lightStartTime = millis();

}

if (millis() - lightStartTime >= LIGHT_STABLE_TIME) { // Ha folyamatosan világos van 5 másodpercig

ledState = false; // Kikapcsolás

}

// Ha mozgás megszűnt, de továbbra is sötét van, akkor várakozik a PIR_STABLE_TIME idejéig

if (!motionDetected && millis() > motionEndTime && lightValue <= DARK_THRESHOLD) {

ledState = false; // Kikapcsolás mozgás után 4x késleltetéssel

}

// Ha világos van, akkor a PIR mozgásérzékelést figyelmen kívül hagyja

if (lightValue >= TURN_OFF_THRESHOLD) {

motionEndTime = millis(); // Mozgásérzékelés újraindítása

}

// LED állapotának frissítése

digitalWrite(LED_PIN, ledState ? HIGH : LOW);

// Soros monitor kiírás a teszteléshez

Serial.print("Feny: "); Serial.print(lightValue);

Serial.print("\tPIR: "); Serial.print(motionDetected ? "Mozgás" : "Nincs mozgás");

Serial.print("\tLED: "); Serial.print(ledState ? "ON" : "OFF");

Serial.print("\tMin: "); Serial.print(TURN_OFF_THRESHOLD);

Serial.print("\tMax: "); Serial.println(DARK_THRESHOLD);

delay(DELAY_TIME); // Mérési ciklus késleltetése

}

És a könnyebb (?) megértéshez a működési logika sem árt – áttekinthetőbben:

Fényviszony	Mozgás (PIR)	LED állapot	Megjegyzés
Sötét	Van mozgás	Bekapcsol	Azonnali reakció
Sötét	Mozgás megszűnik	Marad bekapcsolva	PIR utolsó érzékelése után még ég
Sötét	Nincs mozgás	Kikapcsol késleltetéssel	PIR után még 4x hosszabb ideig ég
Világos	Van mozgás	Nem kapcsol be	A PIR ilyenkor nem aktív
Világos	Nincs mozgás	Kikapcsol késleltetéssel	Csak ha stabilan világos
Rövid világos idő	Van mozgás	Marad bekapcsolva	Fényingadozás nem kapcsolja le
Sötét és világos gyorsan vált	Nincs mozgás	LED marad égve	Nem reagál pillanatnyi fényváltozásra

Miért hasznos ez a rendszer?

Csak akkor kapcsol be, ha szükséges → Ha világos van, a mozgásérzékelés inaktív.
Nem kapcsol ki egy pillanatnyi fényváltozás miatt → Megakadályozza a villogást.
Mozgás után késleltetve kapcsol ki → Nem alszik ki rögtön, hanem marad égve.
Energiatakarékos → Csak sötétben és mozgás esetén kapcsol be.
Könnyen testre szabható → Az érzékelési küszöbök és az időzítés módosíthatók.

Összegzés

A bemutatott Arduino-alapú világításvezérlő rendszer egy egyszerű, de hatékony megoldás a fényviszonyok és a mozgás alapján történő világításvezérlésre. A rendszer egyesíti a fotoellenállás (LDR) és a PIR szenzor előnyeit, biztosítva ezzel az intelligens energiahasználatot és a pontos vezérlést. A projekt könnyen elkészíthető akár kezdők számára is, és egy remek kiindulópont a világításvezérlési rendszerek fejlesztéséhez. A kód egyszerűen módosítható, hogy az adott környezethez igazodjon, és az áramkör könnyen bővíthető további érzékelőkkel vagy vezérlési lehetőségekkel.

Ha szeretnél egy automatizált, intelligens világításvezérlő rendszert építeni az otthonodba vagy a kertedbe, ez a projekt egy kiváló alap!

Milyen további fejlesztési lehetőségek vannak?

Az itt bemutatott rendszerek egyszerűen továbbfejleszthetők és bővíthetők, például:

Távoli vezérlés Wi-Fi-n vagy Bluetooth-on keresztül – Egy ESP8266 vagy ESP32 modul segítségével az adatokat akár egy okostelefonra is küldhetjük, és távolról kapcsolhatjuk be vagy ki a világítást.
Időzített világításvezérlés – A rendszer kiegészíthető egy RTC (valós idejű óra) modullal, így például csak este 6 után aktiválódik a világítás.
Energiafogyasztás optimalizálás – A LED-ek fényereje naplemente után automatikusan növekedhet, majd az éjszaka közepén csökkenhet, hogy még energiatakarékosabb legyen a rendszer.
További érzékelők integrálása – Hőmérséklet- és páratartalom-érzékelőkkel kombinálva okos kültéri vagy beltéri világítási rendszert építhetünk.
Mozgásérzékelő integrálása – Csak mozgás esetén aktiválja a világítást.
Időzítés funkció – Csak bizonyos órákban kapcsoljon be a fény.
Wi-Fi vezérlés – Az adatok távoli eléréséhez ESP32 modul használata.
LCD kijelző – A fényértékek valós idejű kijelzéséhez.