Az ESP32 egy IoT alapú mikrovezérlő kártya, amely különböző érzékelők interfészére, vezérlésére és olvasására használható. A PIR vagy a mozgásérzékelő az egyik olyan eszköz, amelyet az ESP32-vel illeszthetünk, hogy az ESP32 segítségével észleljük egy tárgy mozgását a mozgásérzékelő tartományában.
Mielőtt elkezdenénk az ESP32 és a PIR érzékelő összekapcsolását, tudnunk kell, hogyan működnek a megszakítások, és hogyan olvassuk és kezeljük őket az ESP32-ben. Ezután meg kell értenünk a delay() és a millis() függvény alapvető fogalmát az ESP32 programozásban.
Beszéljük meg részletesen a PIR és az ESP32 működését.
Íme a cikk tartalma:
1: Mik azok a megszakítások
Az ESP32 programozásban előforduló események többsége szekvenciálisan fut, ami a kód soronkénti végrehajtását jelenti. Azon események kezelésére és vezérlésére, amelyeknek nem kell futniuk a kód szekvenciális végrehajtása során, an Megszakítja használt.
Például, ha valamilyen különleges esemény bekövetkeztekor egy bizonyos feladatot szeretnénk végrehajtani, vagy triggerjelet kapnak a mikrokontroller digitális tűire, interruptot használunk.
Megszakítás esetén nem kell folyamatosan ellenőriznünk az ESP32 bemeneti érintkező digitális állapotát. Megszakítás esetén a processzor leállítja a főprogramot, és egy új függvény hívódik meg, amely ISR ( Szakítsa meg a szolgáltatási rutint ). Ez ISR függvény kezeli az ezt követően okozott megszakítást, térjen vissza a főprogramba és kezdje el végrehajtani. Az ISR egyik példája az PIR mozgásérzékelő melyik megszakítást generál, ha mozgást észlel .
1.1: Megszakítja a tűket az ESP32-ben
A külső vagy hardveres megszakítást bármely hardvermodul, például érintésérzékelő vagy nyomógomb okozhatja. Az érintés megszakítása akkor történik, amikor a rendszer érintést észlel az ESP32 érintkezőkön, vagy a GPIO megszakítás akkor is használható, amikor egy billentyűt vagy nyomógombot megnyomnak.
Ebben a cikkben megszakítást indítunk el, ha a mozgást az ESP32-vel ellátott PIR-érzékelő segítségével érzékeli.
Szinte az összes GPIO érintkező, kivéve a 6 integrált SPI érintkezőt, amelyek általában a készülékben találhatók 36 Az ESP32 kártya tűs verziója nem használható megszakítási hívás céljából. Tehát a külső megszakítás vételéhez a következő, lila színnel kiemelt tűk használhatók az ESP32-ben:
Ez a kép egy 30 tűs ESP32-ről készült.
1.2: Megszakítás hívása az ESP32-ben
A megszakítás használatához az ESP32-ben hívhatunk attachInterrupt() funkció.
Ez a függvény a következő három argumentumot fogadja el:
-
- GPIO pin
- Végrehajtandó funkció
- Mód
1: GPIO pin az első argumentum, amelyet a belsejében hívnak attachInterrupt() funkció. Például, ha a 12-es digitális érintkezőt megszakítási forrásként szeretnénk használni, akkor ezt a segítségével hívhatjuk digitalPinToInterrupt(12) funkció.
2: Funkció végrehajtandó az a program, amely minden alkalommal végrehajtódik, amikor a megszakítást külső vagy belső forrás eléri vagy kiváltja. Ez lehet villogó LED vagy tűzriadó bekapcsolása.
3: mód a harmadik és utolsó argumentum, amelyre a megszakítási függvénynek szüksége van. Leírja, hogy mikor kell kiváltani a megszakítást. A következő módok használhatók:
-
- Alacsony: Minden alkalommal indítsa el a megszakítást, amikor a meghatározott GPIO érintkező alacsony.
- Magas: Minden alkalommal indítsa el a megszakítást, amikor a meghatározott GPIO érintkező magas.
- Változás: Trigger megszakítás minden alkalommal, amikor a GPIO pin értékét magasról alacsonyra változtatja, vagy fordítva.
- Eső: Ez az a mód, amely megszakítást vált ki, amikor egy bizonyos érintkező magas állapotból alacsonyba kezd.
- Emelkedő: Ez az a mód, amely megszakítást vált ki, amikor egy bizonyos érintkező alacsony állapotból magasba kezd emelkedni.
Ma fogjuk használni Emelkedő mód, mint harmadik érv a megszakítási funkció mellett, amikor a PIR érzékelő érzékeli, hogy a megszakítási LED vagy az érzékelő kigyullad, mert alacsony állapotból magasra vált.
2: Időzítők az ESP32 programozásban
Az időzítők a mikrovezérlők programozásában jelentős szerepet játszanak az utasítások végrehajtásában egy adott időzítési periódusra vagy adott időpontban.
A kimenet indítására általában két fő funkciót használnak késleltetés() és millis() . A kettő közötti különbség, mint a delay() függvény, leállítja a program többi részét, amint az elkezdődik, míg a millis() a meghatározott ideig fut, majd a program visszatér a fő funkciókhoz.
Itt PIR érzékelővel ellátott LED-et fogunk használni, és nem szeretnénk folyamatosan világítani, miután egy megszakítás kiold. A millis() függvényt fogjuk használni, amely lehetővé teszi, hogy egy meghatározott ideig világítson, majd az időbélyeg lejárta után visszatérjen az eredeti programhoz.
2.1: delay() függvény
A delay() függvény meglehetősen egyszerű, csak egy argumentumot igényel, amely az Kisasszony előjel nélküli hosszú adattípusból. Ez az argumentum azt az időt jelenti ezredmásodpercben, ameddig a programot szüneteltetni akarjuk, amíg a következő sorba nem lép.
Például a következő funkció leállítja a programot 1 perc .
késleltetés ( 1000 )
A delay() egyfajta blokkoló funkció a mikrokontrollerek programozásához. A delay() blokkolja a kód többi részét a végrehajtásban, amíg az adott függvény be nem fejeződik. Ha több utasítást szeretnénk végrehajtani, kerüljük a késleltetési függvények használatát, helyette használhatunk millis vagy külső időzítő RTC modulokat.
2.2: millis() függvény
A millis() függvény visszaadja, hogy hány ezredmásodperc telt el azóta, hogy az ESP32 kártya elindította az aktuális programot. Néhány soros kód megírásával könnyen kiszámíthatjuk a jelenlegi időt bármely esetben az ESP32 kód futtatása közben.
A millis széles körben használatos, ahol több feladatot kell futtatnunk a kód többi részének blokkolása nélkül. Itt látható a millis függvény szintaxisa, amellyel kiszámítható, hogy mennyi idő telt el egy adott utasítás végrehajtásához.
ha ( jelenlegiMillis - előzőMillis > = intervallum ) {előzőMillis = jelenlegiMillis;
}
Ez a kód kivonja az előző millis()-t az aktuális millis()-ből, ha a kivont idő megegyezik az adott utasítás végrehajtásának intervallumának meghatározásával. Tegyük fel, hogy villogni akarunk egy LED-et 10 másodpercig. Minden 5 perc után beállíthatjuk az időintervallumot 5 percre (300 000 ms). A kód minden lefutáskor ellenőrzi az intervallumot, amint eléri, 10 másodpercig villogni fog a LED.
Jegyzet: Itt a millis() függvényt fogjuk használni az ESP32 és a PIR érzékelő összekapcsolására. A fő oka a milli és nem a delay használatának az, hogy a millis() függvény nem blokkolja a kódot, ahogy a delay() függvény tette. Tehát amint a PIR mozgást észlel, megszakítás jön létre. A millis() megszakítás funkció használata a LED-et meghatározott ideig aktiválja, majd ha a mozgás leáll, a millis() függvény alaphelyzetbe áll, és megvárja a következő megszakítást.
Ha a delay() függvényt használjuk, az teljesen blokkolja a kódot, és az esetleges megszakításokat az ESP32 nem olvassa be, ami a projekt meghibásodását eredményezi.
3: PIR érzékelő interfész az ESP32-vel
Itt a millis() függvényt fogjuk használni az Arduino IDE kódban, mert minden alkalommal ki akarjuk kapcsolni a LED-et, amikor a PIR érzékelő mozgást észlel. Ez a LED egy beállított ideig világít, majd visszaáll a normál állapotba.
Íme az alkatrészek listája, amelyekre szükségünk lesz:
-
- ESP32 fejlesztő tábla
- PIR mozgásérzékelő (HC-SR501)
- VEZETTE
- 330 ohmos ellenállás
- Csatlakozó vezetékek
- Kenyértábla
Vázlatos PIR érzékelő ESP32-vel:
Az ESP32 érintkezői a PIR érzékelővel:
| ESP32 | PIR érzékelő |
| jön | Vcc |
| GPIO13 | KI |
| GND | GND |
3.1: PIR mozgásérzékelő (HC-SR501)
A PIR a szó rövidítése passzív infravörös érzékelő . Egy pár piroelektromos érzékelőt használ, amelyek érzékelik a környezet körüli hőt. Mindkét piroelektromos érzékelő egymás után fekszik, és amikor egy tárgy a hatótávolságukba kerül, a hőenergia változása vagy a két érzékelő közötti jelkülönbség a PIR érzékelő kimenetét ALACSONY értékűvé teszi. Ha a PIR kimeneti láb LOW-ra kerül, beállíthatunk egy konkrét utasítást a végrehajtásra.
A PIR érzékelő jellemzői a következők:
-
- Az érzékenység a projekt helyétől függően állítható be (például egér vagy levél mozgásának érzékelése).
- A PIR érzékelő beállítható, hogy mennyi ideig érzékeljen egy tárgyat.
- Széles körben használják otthoni biztonsági riasztókban és más hőalapú mozgásérzékelő alkalmazásokban.
3.2: HC-SR501 csatlakozó
A PIR HC-SR501 három tűvel érkezik. Ezek közül kettő a Vcc és a GND táp érintkezője, egy pedig a triggerjel kimeneti érintkezője.
A PIR érzékelő érintkezőinek leírása a következő:
| Pin | Név | Leírás |
| 1 | Vcc | Bemeneti érintkező az érzékelőhöz Csatlakoztassa az ESP32 Vin Pin-hez |
| két | KI | Érzékelő kimenet |
| 3 | GND | GND érzékelő |
3.3: Kód
Most az ESP32 programozásához írja be a megadott kódot az Arduino IDE szerkesztőbe, és töltse fel az ESP32-be.
#define timeSeconds 10const int led = 4 ; /* GPIO PIN 4 meghatározott számára VEZETTE */
const int PIR_Out = 13 ; /* GPIO pin 13 számára PIR ki */
unsigned long Current_Time = millis ( ) ; /* változó definiálva számára millis értékek tárolása */
unsigned long Previous_Trig = 0 ;
logikai Kezdési_idő = hamis ;
void IRAM_ATTR mozgást észlel ( ) { /* jelölje be számára mozgás */
Serial.println ( 'MOTION DETECTED' ) ;
digitalWrite ( led, HIGH ) ; /* Kapcsolja BE a LED-et ha feltétele az igaz */
Kezdési_idő = igaz ;
Previous_Trig = millis ( ) ;
}
üres beállítás ( ) {
Serial.begin ( 115200 ) ; /* átviteli sebesség számára soros kommunikáció */
pinMode ( PIR_Out, INPUT_PULLUP ) ; /* PIR mozgásérzékelő mód definiálva */
/* A PIR be van állítva ban ben RISING mód, készlet mozgásérzékelő tű mint Kimenet */
attachInterrupt ( digitalPinToInterrupt ( PIR_Out ) , érzékeliMozgás, Emelkedett ) ;
pinMode ( led, OUTPUT ) ; /* készlet LED LOW-ra */
digitalWrite ( vezetett, LOW ) ;
}
üres hurok ( ) {
Aktuális_idő = millis ( ) ; /* tárolja az áramot idő */
ha ( Kezdési idő && ( Aktuális_idő – Előző_Trig > ( timeSeconds * 1000 ) ) ) { /* Időintervallum után melyik A LED kialszik */
Serial.println ( 'MOTION STOPED' ) ; /* Leállított mozgást nyomtat ha nem észlelt mozgást */
digitalWrite ( vezetett, LOW ) ; /* Állítsa a LED-et LOW-ra ha feltétele az hamis */
Kezdési_idő = hamis ;
}
}
A kód a LED és a PIR kimenet GPIO tűinek meghatározásával kezdődött. Ezután három különböző változót hoztunk létre, amelyek segítenek bekapcsolni a LED-et, ha mozgást észlel.
Ez a három változó az Current_Time, Previous_Trig, és Kezdési idő. Ezek a változók tárolják az aktuális időt, a mozgás érzékelésének időpontját és a mozgásérzékelés utáni időzítőt.
A beállítási részben először a kommunikáció soros adatátviteli sebességét határoztuk meg. Következő használat pinMode() állítsa be a PIR mozgásérzékelőt INPUT PULLUP értékre. A PIR megszakítás beállítása attachInterrupt() le van írva. A GPIO 13 leírása szerint érzékeli a mozgást RISING módban.
Következő a kód loop() részében, a millis() függvény segítségével bekapcsoltuk és kikapcsoltuk a LED-et, ha triggert értünk el.
3.4: Kimenet
A kimeneti részben láthatjuk, hogy az objektum kívül esik a PIR érzékelő hatótávolságán, így a VEZETTE meg van fordítva KI .
Ekkor a PIR-érzékelő LED-je által érzékelt mozgás felkapcsol TOVÁBB számára 10 mp ezután, ha nem érzékel mozgást, akkor marad KI amíg meg nem érkezik a következő trigger.
A következő kimenetet az Arduino IDE soros monitora mutatja.
Következtetés
Az ESP32-vel ellátott PIR-érzékelő segíthet észlelni a tartományán áthaladó tárgyak mozgását. Az ESP32 programozás megszakítási funkciójával választ tudunk kiváltani egy adott GPIO lábon. Ha változást észlel, a megszakítási funkció aktiválódik, és egy LED világít.