ESP32 este o placă de microcontroler bazată pe IoT, care poate fi utilizată pentru a interfața, controla și citi diferiți senzori. PIR sau senzorul de mișcare este unul dintre dispozitivele pe care le putem interfața cu ESP32 pentru a detecta mișcarea unui obiect din raza de acțiune a senzorului de mișcare folosind ESP32.
Înainte de a începe interfațarea ESP32 cu senzorul PIR, trebuie să știm cum funcționează întreruperile și cum să le citim și să le gestionăm în ESP32. În continuare trebuie să înțelegem conceptul de bază al funcției delay() și millis() în programarea ESP32.
Să discutăm în detaliu funcționarea PIR cu ESP32.
Iată conținutul acestui articol:
1: Ce sunt întreruperile
Majoritatea evenimentelor care au loc în programarea ESP32 rulează secvenţial, ceea ce înseamnă executarea codului linie cu linie. Pentru a gestiona și controla evenimentele care nu trebuie să ruleze în timpul execuției secvențiale a codului an întreruperi sunt utilizate.
De exemplu, dacă dorim să executăm o anumită sarcină atunci când are loc un eveniment special sau un semnal de declanșare este dat pinii digitali ai microcontrolerului, folosim întrerupere.
Cu întrerupere, nu trebuie să verificăm în mod continuu starea digitală a pinului de intrare ESP32. Când apare o întrerupere, procesorul oprește programul principal și se numește o nouă funcție cunoscută sub numele de ISR ( Întreruperea rutinei de serviciu ). Acest ISR funcția gestionează întreruperea cauzată după aceea revenirea la programul principal și începerea executării acestuia. Unul dintre exemplele de ISR este Senzor de mișcare PIR care generează o întrerupere odată ce este detectată mișcarea .
1.1: Întrerupe Pinii în ESP32
O întrerupere externă sau hardware poate fi cauzată de orice modul hardware, cum ar fi senzorul tactil sau butonul de apăsare. Întreruperile de atingere au loc atunci când o atingere este detectată la pinii ESP32 sau întreruperea GPIO poate fi utilizată și atunci când este apăsat o tastă sau un buton.
În acest articol vom declanșa o întrerupere atunci când mișcarea este detectată folosind senzorul PIR cu ESP32.
Aproape toți pinii GPIO, cu excepția celor 6 pini integrati SPI, care de obicei vin în 36 Versiunea cu pin a plăcii ESP32 nu poate fi utilizată în scopul întreruperii apelurilor. Deci, pentru a primi întreruperile externe, următorii sunt pinii evidențiați în culoarea violet pe care îi puteți folosi în ESP32:
Această imagine este a unui ESP32 cu 30 de pini.
1.2: Apelarea unei întreruperi în ESP32
Pentru utilizarea întreruperii în ESP32 putem apela attachInterrupt() funcţie.
Această funcție acceptă următoarele trei argumente:
-
- Pin GPIO
- Funcția de executat
- Modul
1: GPIO pin este primul argument numit în interiorul attachInterrupt() funcţie. De exemplu, pentru a folosi pinul digital 12 ca sursă de întrerupere, îl putem numi folosind digitalPinToInterrupt(12) funcţie.
2: Funcția a fi executat este programul executat de fiecare dată când întreruperea este atinsă sau declanșată de o sursă externă sau internă. Poate fi fie să clipească un LED, fie să pornească o alarmă de incendiu.
3: Mod este al treilea și ultimul argument de care are nevoie funcția de întrerupere. Descrie când să declanșeze întreruperea. Următoarele sunt modurile care pot fi utilizate:
-
- Scăzut: Declanșați întreruperea de fiecare dată când pinul GPIO definit este scăzut.
- Înalt: Declanșați întreruperea de fiecare dată când pinul GPIO definit este ridicat.
- Schimbare: Declanșați întrerupere de fiecare dată când pinul GPIO își schimbă valoarea de la mare la scăzută sau invers.
- Cădere: Este modul de declanșare a unei întreruperi atunci când un anumit pin începe să cadă de la starea ridicată la starea scăzută.
- În creștere: Este modul de declanșare a unei întreruperi atunci când un anumit pin începe să se ridice de la starea scăzută la starea ridicată.
Astăzi vom folosi În creștere modul ca al treilea argument pentru funcția de întrerupere ori de câte ori senzorul PIR detectează LED-ul de întrerupere sau senzorul se va aprinde deoarece trece de la starea scăzută la starea ridicată.
2: Temporizatoare în programarea ESP32
Temporizatoarele în programarea microcontrolerelor joacă un rol semnificativ pentru executarea instrucțiunilor pentru o anumită perioadă de temporizare sau la un anumit moment de timp.
Două funcții principale utilizate în mod obișnuit pentru a declanșa ieșirea sunt întârziere() și milis() . Diferența dintre ambele ca funcție delay() oprește restul programului odată ce începe să se execute în timp ce millis() rulează pentru o perioadă de timp definită, apoi programul revine la funcțiile principale.
Aici vom folosi un LED cu senzor PIR și nu dorim să-l aprindem continuu după declanșarea unei întreruperi. Vom folosi funcția millis() care ne permite să-l strălucim pentru o perioadă definită de timp și apoi să revenim la programul original odată ce marca temporală trece.
2.1: Funcția delay().
Funcția delay() este destul de simplă, ia doar un argument care este Domnișoară de tip de date lungi nesemnate. Acest argument reprezintă timpul în milisecunde în care dorim să întrerupem programul până când acesta trece la următoarea linie.
De exemplu, următoarea funcție va opri programul pentru 1 sec .
întârziere ( 1000 )
delay() este un fel de funcție de blocare pentru programarea microcontrolerelor. delay() blochează restul codului pentru a se executa până când această funcție anume nu se finalizează. Dacă dorim să executăm mai multe instrucțiuni, ar trebui să evităm utilizarea funcțiilor de întârziere, în schimb putem folosi module milis sau timer externe RTC.
2.2: Funcția millis().
Funcția millis() returnează numărul de milisecunde trecute de când placa ESP32 a început să ruleze programul curent. Scriind câteva linii de cod, putem calcula cu ușurință timpul prezent în orice instanță în timp ce rulăm codul ESP32.
millis este utilizat pe scară largă acolo unde trebuie să rulăm mai multe sarcini fără a bloca restul codului. Iată sintaxa funcției millis folosită pentru a calcula cât timp a trecut, astfel încât să putem executa o anumită instrucțiune.
dacă ( actualMillis - precedentMillis > = interval ) {previousMillis = currentMillis;
}
Acest cod scade milis() anterior din milis() curent dacă timpul scăzut este egal pentru a defini intervalul în care va fi executată o anumită instrucțiune. Să presupunem că vrem să clipim un LED timp de 10 secunde. După fiecare 5 minute putem seta intervalul de timp egal cu 5 minute (300000ms). Codul va verifica intervalul de fiecare dată când codul rulează, odată ce acesta ajunge, LED-ul va clipi timp de 10 secunde.
Notă: Aici vom folosi funcția millis() pentru interfațarea ESP32 cu senzorul PIR. Motivul principal din spatele utilizării milli și nu delay este că funcția millis() nu blochează codul așa cum a făcut funcția delay(). Deci, odată ce PIR detectează mișcare, va fi generată o întrerupere. Utilizarea funcției de întrerupere millis() va declanșa LED-ul pentru un timp definit după aceea, dacă mișcarea este oprită, funcția millis() se va reseta și va aștepta următoarea întrerupere.
În cazul în care folosim funcția delay(), aceasta va bloca complet codul și orice întrerupere cauzată nu va fi citită de ESP32, rezultând în eșecul proiectului.
3: Interfața senzorului PIR cu ESP32
Aici vom folosi funcția millis() în codul IDE Arduino, deoarece dorim să declanșăm LED-ul de fiecare dată când senzorul PIR detectează o mișcare. Acest LED se va aprinde pentru un timp stabilit, după care va reveni la starea normală.
Iată o listă de componente care ne vor fi solicitate:
-
- Placa de dezvoltare ESP32
- Senzor de mișcare PIR (HC-SR501)
- LED
- Rezistor de 330 Ohm
- Fire de conectare
- Breadboard
Schematic pentru senzor PIR cu ESP32:
Conexiunile pin ale ESP32 cu senzor PIR sunt:
| ESP32 | Senzor PIR |
| vino | Vcc |
| GPIO13 | OUT |
| GND | GND |
3.1: Senzor de mișcare PIR (HC-SR501)
PIR este un acronim pentru senzor pasiv cu infraroșu . Utilizează o pereche de senzori piroelectrici care detectează căldura din jurul său. Ambii acești senzori piroelectrici se află unul după altul și, atunci când un obiect intră în raza lor de acțiune, o schimbare a energiei termice sau diferența de semnal dintre ambii acești senzori determină ieșirea senzorului PIR să fie Scăzută. Odată ce pinul de ieșire PIR devine LOW, putem seta o anumită instrucțiune de executat.
Următoarele sunt caracteristicile senzorului PIR:
-
- Sensibilitatea poate fi setată în funcție de locația proiectului (cum ar fi detectarea mouse-ului sau a mișcării frunzelor).
- Senzorul PIR poate fi setat pentru cât timp detectează un obiect.
- Utilizat pe scară largă în alarmele de securitate la domiciliu și în alte aplicații de detectare a mișcării pe bază termică.
3.2: Pinout HC-SR501
PIR HC-SR501 vine cu trei pini. Două dintre ele sunt pini de alimentare pentru Vcc și GND și unul este pinul de ieșire pentru semnalul de declanșare.
Mai jos este descrierea pinilor senzorului PIR:
| Pin | Nume | Descriere |
| 1 | Vcc | Pin de intrare pentru senzor Conectați la PIN-ul ESP32 Vin |
| Două | OUT | Ieșire senzor |
| 3 | GND | Senzor GND |
3.3: Cod
Acum, pentru a programa ESP32, scrieți codul dat în editorul Arduino IDE și încărcați-l în ESP32.
#define timeSecunde 10const int led = 4 ; /* PIN GPIO 4 definit pentru LED */
const int PIR_Out = 13 ; /* Pin GPIO 13 pentru PIR afară */
nesemnat lung Current_Time = milis ( ) ; /* variabilă definită pentru stocarea valorilor milimetrice */
nesemnat lung Previous_Trig = 0 ;
boolean Starting_Time = fals ;
void IRAM_ATTR detectează mișcarea ( ) { /* Verifica pentru mişcare */
Serial.println ( „Mișcare detectată” ) ;
digitalWrite ( condus, ÎNALT ) ; /* Porniți LED-ul dacă starea este Adevărat */
Starting_Time = Adevărat ;
Previous_Trig = milis ( ) ;
}
anulează configurarea ( ) {
Serial.begin ( 115200 ) ; /* baud rate pentru comunicare în serie */
pinMode ( PIR_Out, INPUT_PULLUP ) ; /* Modul senzor de mișcare PIR definit */
/* PIR este configurat în modul RISING, a stabilit pinul senzorului de mișcare la fel de ieșire */
attachInterrupt ( digitalPinToInterrupt ( PIR_Out ) , detectează Mișcare, RĂSARE ) ;
pinMode ( led, IEȘIRE ) ; /* a stabilit LED-ul la LOW */
digitalWrite ( condus, JOS ) ;
}
buclă goală ( ) {
Current_Time = milis ( ) ; /* stocarea curentului timp */
dacă ( Timpul de începere && ( Current_Time - Previous_Trig > ( timpSecunde * 1000 ) ) ) { /* Interval de timp după care LED-ul se va stinge */
Serial.println ( „Mișcarea OPRITĂ” ) ; /* Mișcarea de imprimare a fost oprită dacă nu a fost detectată nicio mișcare */
digitalWrite ( condus, JOS ) ; /* Setați LED-ul la LOW dacă starea este fals */
Starting_Time = fals ;
}
}
Codul a început prin definirea pinilor GPIO pentru ieșirea LED și PIR. Apoi, am creat trei variabile diferite care vor ajuta la aprinderea LED-ului atunci când este detectată mișcare.
Aceste trei variabile sunt Current_Time, Previous_Trig, și Timpul de începere. Aceste variabile vor stoca ora curentă, ora la care este detectată mișcarea și temporizatorul după detectarea mișcării.
În partea de configurare, am definit mai întâi rata de transmisie serială pentru comunicare. Următoarea utilizare pinMode() setați senzorul de mișcare PIR ca INPUT PULLUP. Pentru a seta întreruperea PIR attachInterrupt() este descris. GPIO 13 este descris pentru a detecta mișcarea în modul RISING.
În continuare, în bucla() parte a codului, folosind funcția millis(), am pornit și stins LED-ul atunci când este atins un declanșator.
3.4: Ieșire
În secțiunea de ieșire putem vedea că obiectul este în afara razei senzorului PIR, deci LED este intoarsa OFF .
Acum mișcarea detectată de LED-ul senzorului PIR se va aprinde PE pentru 10 sec după aceea, dacă nu este detectată nicio mișcare, va rămâne OFF până la primirea următorului declanșator.
Următoarea ieșire este afișată de monitorul serial din Arduino IDE.
Concluzie
Un senzor PIR cu ESP32 poate ajuta la detectarea mișcării obiectelor care trec prin raza sa. Folosind funcția de întrerupere în programarea ESP32, putem declanșa un răspuns la un anumit pin GPIO. Când este detectată o schimbare, funcția de întrerupere va fi declanșată și un LED se va aprinde.