ESP32 er et IoT-basert mikrokontrollerkort som kan brukes til å grensesnitt, kontrollere og lese forskjellige sensorer. PIR eller bevegelsessensor er en av enhetene vi kan koble til ESP32 for å oppdage bevegelse av et objekt i rekkevidden av bevegelsessensor ved hjelp av ESP32.
Før vi begynner å koble ESP32 med PIR-sensor, må vi vite hvordan avbrudd fungerer og hvordan vi leser og håndterer dem i ESP32. Deretter må vi forstå kjernebegrepet delay() og millis()-funksjonen i ESP32-programmering.
La oss diskutere hvordan PIR fungerer med ESP32 i detalj.
Her er innholdet i denne artikkelen:
1: Hva er avbrudd
De fleste hendelsene som skjer i ESP32-programmering kjører sekvensielt, noe som betyr linje for linje kjøring av kode. For å håndtere og kontrollere hendelsene som ikke trenger å kjøre under sekvensiell kjøring av kode an Avbryter er brukt.
For eksempel, hvis vi ønsker å utføre en bestemt oppgave når en spesiell hendelse inntreffer, eller et triggersignal blir gitt til digitale pinner på mikrokontrolleren, bruker vi avbrudd.
Med avbrudd trenger vi ikke kontinuerlig sjekke den digitale tilstanden til ESP32-inngangspinnen. Når et avbrudd oppstår stopper prosessoren hovedprogrammet og en ny funksjon kalles som er kjent som ISR ( Avbryt servicerutine ). Dette ISR funksjonen håndterer avbruddet som oppstår etter at du går tilbake til hovedprogrammet og begynner å kjøre det. Et av eksemplene på ISR er PIR bevegelsessensor hvilken genererer et avbrudd når bevegelse oppdages .
1.1: Avbryter pins i ESP32
Et eksternt avbrudd eller maskinvareavbrudd kan være forårsaket av hvilken som helst maskinvaremodul som berøringssensor eller trykknapp. Berøringsavbrudd skjer når en berøring oppdages på ESP32-pinner eller GPIO-avbrudd kan også brukes når en tast eller trykknapp trykkes.
I denne artikkelen vil vi utløse et avbrudd når bevegelsen oppdages ved hjelp av PIR-sensoren med ESP32.
Nesten alle GPIO pinnene bortsett fra 6 SPI integrerte pinner som vanligvis kommer i 36 -pin-versjonen av ESP32-kortet kan ikke brukes for å avbryte anrop. Så, for å motta det eksterne avbruddet, er pinnene uthevet i lilla farge som du kan bruke i ESP32:
Dette bildet er av en 30 pin ESP32.
1.2: Ringe et avbrudd i ESP32
For bruk av avbrudd i ESP32 kan vi ringe legg ved avbrudd() funksjon.
Denne funksjonen godtar følgende tre argumenter:
-
- GPIO pin
- Funksjon som skal utføres
- Modus
1: GPIO pin er det første argumentet som kalles inne i legg ved avbrudd() funksjon. For eksempel, for å bruke digital pin 12 som en avbruddskilde kan vi kalle det å bruke digitalPinToInterrupt(12) funksjon.
2: Funksjon som skal utføres er programmet som kjøres hver gang når avbruddet er nådd eller utløst av en ekstern eller intern kilde. Det kan enten være å blinke en LED eller slå på en brannalarm.
3: Modus er det tredje og siste argumentet avbruddsfunksjonen trenger. Den beskriver når avbruddet skal utløses. Følgende er modusene som kan brukes:
-
- Lav: Utløs avbruddet hver gang den definerte GPIO-pinnen er lav.
- Høy: Utløs avbruddet hver gang den definerte GPIO-pinnen er høy.
- Endring: Trigger avbrudd hver gang GPIO-pinne endrer verdien fra høy til lav eller omvendt.
- Fallende: Det er modusen for å utløse et avbrudd når en bestemt pinne begynner å falle fra høy tilstand til lav.
- Stigende: Det er modusen for å utløse et avbrudd når en bestemt pinne begynner å stige fra lav tilstand til høy.
I dag skal vi bruke Rising modus som et tredje argument for avbruddsfunksjonen hver gang PIR-sensoren oppdager avbrudds-LED eller sensor vil lyse fordi den går fra lav tilstand til høy.
2: Tidtakere i ESP32-programmering
Tidtakere i mikrokontrollerprogrammering spiller en betydelig rolle for å utføre instruksjoner for en bestemt tidtakerperiode eller på et bestemt tidspunkt.
To hovedfunksjoner som vanligvis brukes for å utløse utgangen er forsinkelse() og millis() . Forskjellen mellom begge som delay()-funksjon stopper resten av programmet når det begynner å kjøre mens millis() kjører i den definerte tidsperioden, så går programmet tilbake til hovedfunksjonene.
Her skal vi bruke en LED med PIR-sensor, og vi ønsker ikke å lyse den kontinuerlig etter at et avbrudd utløses. Vi vil bruke millis()-funksjonen som lar oss gløde den i en viss definert tid og deretter igjen gå tilbake til det opprinnelige programmet når tidsstempelet går.
2.1: delay() funksjon
delay()-funksjonen er ganske enkel, den tar bare ett argument som er ms av usignert lang datatype. Dette argumentet representerer tiden i millisekunder vi ønsker å sette programmet på pause til det går til neste linje.
For eksempel vil følgende funksjon stoppe programmet for 1 sek .
forsinkelse ( 1000 )
delay() er en slags blokkeringsfunksjon for programmering av mikrokontrollere. delay() blokkerer resten av koden for å kjøre inntil denne funksjonen ikke fullføres. Hvis vi ønsker å utføre flere instruksjoner, bør vi unngå å bruke forsinkelsesfunksjoner, i stedet kan vi bruke millis eller eksterne timer RTC-moduler.
2.2: millis() funksjon
millis()-funksjonen returnerer antall millisekunder som har gått siden ESP32-kortet begynte å kjøre det gjeldende programmet. Ved å skrive noen få linjer med kode kan vi enkelt beregne det nåværende tidspunktet når som helst mens vi kjører ESP32-koden.
millis er mye brukt der vi trenger å kjøre flere oppgaver uten å blokkere resten av koden. Her er syntaksen til millis-funksjonen som brukes for å beregne hvor mye tid som gikk slik at vi kan utføre en spesifikk instruksjon.
hvis ( currentMillis - forrigeMillis > = intervall ) {forrigeMillis = gjeldendeMillis;
}
Denne koden trekker forrige millis() fra gjeldende millis() hvis den subtraherte tiden er lik for å definere intervallet en spesifikk instruksjon skal utføres. La oss si at vi vil blinke en LED i 10 sekunder. Etter hvert 5. minutt kan vi sette tidsintervallet lik 5 minutter (300 000ms). Koden vil sjekke for intervallet hver gang koden kjører, når den når den vil den blinke LED i 10 sek.
Merk: Her vil vi bruke millis()-funksjonen for å koble ESP32 med PIR-sensor. Hovedårsaken bak bruken av milli og ikke delay er at millis()-funksjonen ikke blokkerer koden slik delay()-funksjonen gjorde. Så når PIR-en oppdager bevegelse, vil det genereres et avbrudd. Bruk av interrupt millis()-funksjonen vil utløse LED-en i definert tid etter at hvis bevegelsen stoppes, vil millis()-funksjonen tilbakestilles og vente på neste avbrudd.
Hvis vi brukte delay()-funksjonen, vil den blokkere koden fullstendig, og eventuelle avbrudd vil ikke bli lest av ESP32, noe som resulterer i feil i prosjektet.
3: Interfacing PIR-sensor med ESP32
Her vil vi bruke millis()-funksjonen i Arduino IDE-kode fordi vi ønsker å utløse LED hver gang PIR-sensoren oppdager bevegelse. Denne LED-en vil lyse i en viss tid etter at den vil gå tilbake til normal tilstand.
Her er en liste over komponenter vi trenger:
-
- ESP32 utviklingskort
- PIR bevegelsessensor (HC-SR501)
- LED
- 330 Ohm motstand
- Koble ledninger
- Brødbrett
Skjematisk for PIR-sensor med ESP32:
Pin-tilkoblinger til ESP32 med PIR-sensor er:
| ESP32 | PIR-sensor |
| komme | Vcc |
| GPIO13 | UTE |
| GND | GND |
3.1: PIR-bevegelsessensor (HC-SR501)
PIR er et akronym for passiv infrarød sensor . Den bruker et par pyroelektriske sensorer som registrerer varme rundt omgivelsene. Begge disse pyroelektriske sensorene ligger etter hverandre, og når et objekt kommer innenfor deres rekkevidde, vil en endring i varmeenergi eller signalforskjellen mellom begge disse sensorene føre til at PIR-sensorens utgang er LAV. Når PIR ut-pinnen blir LAV, kan vi angi en spesifikk instruksjon som skal utføres.
Følgende er egenskapene til PIR-sensoren:
-
- Følsomhet kan angis avhengig av plasseringen av prosjektet (som for eksempel å registrere mus eller bladbevegelser).
- PIR-sensor kan stilles inn for hvor lenge den oppdager et objekt.
- Mye brukt i hjemmesikkerhetsalarmer og andre termiskbaserte bevegelsesdeteksjonsapplikasjoner.
3.2: Pinout HC-SR501
PIR HC-SR501 kommer med tre pinner. To av dem er strømpinner for Vcc og GND og en er utgangspinnen for triggersignalet.
Følgende er beskrivelsen av PIR-sensorpinner:
| Pin | Navn | Beskrivelse |
| 1 | Vcc | Inngangspinne for sensor Koble til ESP32 Vin Pin |
| to | UTE | Sensorutgang |
| 3 | GND | Sensor GND |
3.3: Kode
Nå for å programmere ESP32, skriv den gitte koden i Arduino IDE-editor og last den opp til ESP32.
#define timeSeconds 10const int led = 4 ; /* GPIO PIN 4 definert til LED */
const int PIR_Out = 1. 3 ; /* GPIO pin 1. 3 til PIR ut */
unsigned long Current_Time = millis ( ) ; /* variabel definert til lagre millis-verdier */
unsigned long Previous_Trig = 0 ;
boolsk starttid = falsk ;
void IRAM_ATTR oppdager bevegelse ( ) { /* kryss av til bevegelse */
Serial.println ( 'BEVEGELSE DETEKTERT' ) ;
digitalWrite ( ledet, HØY ) ; /* Slå PÅ LED hvis tilstanden er ekte */
Starttid = ekte ;
Previous_Trig = millis ( ) ;
}
ugyldig oppsett ( ) {
Serial.begin ( 115200 ) ; /* baud rate til seriell kommunikasjon */
pin-modus ( PIR_Ut, INPUT_PULLUP ) ; /* PIR-bevegelsessensormodus definert */
/* PIR er konfigurert i STIGENDE modus, sett bevegelsessensor pinne som produksjon */
legg ved Avbrudd ( digitalPinToInterrupt ( PIR_Ut ) , oppdager Bevegelse, STIGENDE ) ;
pin-modus ( ledet, OUTPUT ) ; /* sett LED til LAV */
digitalWrite ( ledet, LAVT ) ;
}
ugyldig sløyfe ( ) {
Current_Time = millis ( ) ; /* lagre strøm tid */
hvis ( Starttid && ( Current_Time - Previous_Trig > ( timeSeconds * 1000 ) ) ) { /* Tidsintervall etter hvilken LED vil slå seg av */
Serial.println ( 'BEVEGELSE STOPPET' ) ; /* Utskriftsbevegelse stoppet hvis ingen bevegelse oppdaget */
digitalWrite ( ledet, LAVT ) ; /* Sett LED til LAV hvis tilstanden er falsk */
Starttid = falsk ;
}
}
Koden startet med å definere GPIO-pinner for LED- og PIR-utgang. Deretter opprettet vi tre forskjellige variabler som vil bidra til å slå på LED når bevegelse oppdages.
Disse tre variablene er Current_Time, Previous_Trig, og Starttid. Disse variablene vil lagre gjeldende klokkeslett, tidspunkt for bevegelse oppdages og tidtaker etter at bevegelsen er oppdaget.
I oppsettdelen definerte vi først seriell overføringshastighet for kommunikasjon. Neste bruk pinMode() still inn PIR-bevegelsessensoren som INPUT PULLUP. For å stille inn PIR-avbruddet legg ved avbrudd() er beskrevet. GPIO 13 er beskrevet for å oppdage bevegelse i RISING-modus.
Neste i loop()-delen av koden, ved å bruke millis()-funksjonen skrudde vi PÅ og AV LED-en når en trigger oppnås.
3.4: Utgang
I utgangsdelen kan vi se at objektet er utenfor rekkevidden til PIR-sensoren, så LED er snudd AV .
Nå vil bevegelsen som oppdages av PIR-sensor-LED-en snu PÅ til 10 sek etter det, hvis ingen bevegelse oppdages, vil den forbli AV til neste trigger mottas.
Følgende utgang vises av den serielle skjermen i Arduino IDE.
Konklusjon
En PIR-sensor med ESP32 kan hjelpe til med å oppdage bevegelse av objekter som passerer gjennom området. Ved å bruke avbruddsfunksjonen i ESP32-programmering kan vi utløse et svar på en bestemt GPIO-pin. Når endring oppdages, vil avbruddsfunksjonen utløses og en LED vil slå seg PÅ.