Esptop 10 med PIR -bevegelsessensor ved bruk av avbrudd og tidtakere - Arduino IDE

ESP32 er et IoT -basert mikrokontrollertavle som kan brukes til å grensesnitt, kontrollere og lese forskjellige sensorer. PIR eller bevegelsessensor er en av enhetene vi kan grensesnitt mot ESP32 for å oppdage bevegelse av et objekt i bevegelsesområdet ved bruk av ESP32.

Før vi begynner å grensesnitt mot ESP32 med PIR -sensor, må vi vite hvordan avbrytelser fungerer og hvordan vi kan lese og håndtere dem i ESP32. Neste må vi forstå kjernekonseptet med forsinkelse () og Millis () -funksjonen i ESP32 -programmering.

La oss diskutere arbeidet med PIR med ESP32 i detalj.

Her er innholdet for denne artikkelen:

1. Hva er avbryter
• 1.1: Avbryter pinner i ESP32
• 1.2: Hvordan ringe et avbrudd i ESP32
2. Tidtakere i ESP32 -programmering
• 2.1: forsinkelse () -funksjon
• 2.2: Millis () -funksjonen
3. Grensesnittende PIR -sensor med ESP32
   • 3.1: PIR-bevegelsessensor (HC-SR501)
   • 3.2: Pinout HC-SR501
   • 3.3: Kode
   • 3.4: Output

1: Hva er avbryter

De fleste av hendelsene som skjer i ESP32 -programmering kjøres sekvensielt som betyr linje ved linjeutførelse av kode. For å håndtere og kontrollere hendelsene som ikke trenger å kjøre under sekvensiell utførelse av kode og Avbryter er brukt.

For eksempel, hvis vi ønsker å utføre en bestemt oppgave når noen spesiell hendelse oppstår, eller et triggersignal blir gitt til digitale pinner i mikrokontrolleren, bruker vi avbrudd.

Med avbrudd trenger vi ikke å sjekke den digitale tilstanden til ESP32 -inngangspinnen kontinuerlig. Når et avbrudd oppstår stopper prosessoren hovedprogrammet og en ny funksjon kalles som er kjent som ISR (Avbryt servicerutine). Dette ISR Funksjon håndterer avbruddet forårsaket etter den returnerte tilbake til hovedprogrammet og begynn å utføre det. Et av eksemplene på ISR er PIR -bevegelsessensor hvilken genererer et avbrudd når bevegelse er oppdaget.

1: Avbryter pinner i ESP32

Et eksternt eller maskinvareavbrudd kan være forårsaket av hvilken som helst maskinvaremodul som berøringsføler eller trykknapp. Berøring.

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 -versjon av ESP32 -styret kan ikke brukes til å avbryte samtale. Så for å motta det eksterne avbruddet følgende er pinnene uthevet i lilla farge man kan bruke i ESP32:

Dette bildet er av en 30 -pinners ESP32.

2: Ringer et avbrudd i ESP32

For å bruke avbrudd i ESP32 kan vi ringe vedlegg () vedlegg () funksjon.

Denne funksjonen godtar følgende tre argumenter:

• • GPIO -pin
  • Funksjon som skal utføres
  • Modus

vedleggInterrupt (DigitalPinToinToRrupt (GPIO), funksjon, modus);

1: GPIO PIN er det første argumentet som heter inne i vedlegg () vedlegg () funksjon. For eksempel å bruke digital pin 12 som en avbruddskilde kan vi kalle den ved hjelp av DigitalPintointerrupt (12) funksjon.

2: Funksjon som skal utføres er programmet utført hver gang avbruddet er nådd eller utløst av en ekstern eller intern kilde. Det kan enten blinke en LED eller snu brannalarmen.

3: modus er det tredje og siste argumentet. Den beskriver når du skal utløse avbruddet. Følgende er modusene 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: Utløsningsavbrudd hver gang GPIO -pin endrer verdien fra høy til lav eller omvendt.
  • Falling: Det er modus for å utløse et avbrudd når en viss pin begynner å falle fra høy tilstand til lav.
  • Rising: Det er modus for å utløse et avbrudd når en viss pin begynner å stige fra lav tilstand til høy.

I dag skal vi bruke Stiger modus som et tredje argument for avbruddsfunksjonen når PIR -sensoren oppdager avbrudd LED eller sensoren vil lyse opp 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 spesifikk tidtakerperiode eller på spesifikt forekomst av tid.

To hovedfunksjoner som vanligvis brukes til å utløse utgangen er forsinkelse() og millis (). Forskjellen mellom dem begge som forsinkelse () -funksjonen stopper resten av programmet når den begynner å utfø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 vil ikke gløde den kontinuerlig etter en avbrudd utløser. Vi vil bruke Millis () -funksjonen som lar oss gløde den for litt definert tid og deretter igjen går tilbake til det originale programmet når den tidsstempelet passerer.

1: forsinkelse () -funksjon

forsinkelse () -funksjonen er ganske enkel det tar bare ett argument som er MS av usignert lang datatype. Dette argumentet representerer tiden i millisekunder vi ønsker å pause programmet til det beveger seg til neste linje.

For eksempel vil følgende funksjon stoppe programmet for 1 sek.

Forsinkelse (1000)

forsinkelse () er en slags blokkeringsfunksjon for programmering av mikrokontrollere. forsinkelse () blokkerer resten av koden som skal utføres til denne spesielle funksjonstidene ikke fullfører. Hvis vi ønsker å utføre flere instruksjoner, bør vi unngå å bruke forsinkelsesfunksjoner i stedet for at vi kan bruke millis eller eksterne timer RTC -moduler.

2: Millis () -funksjonen

Millis () -funksjonen returnerer antallet millisekunder som ble bestått siden ESP32 -styret begynte å kjøre det nåværende programmet. Ved å skrive noen få kodelinjer kan vi enkelt beregne nåtiden til et hvilket som helst tilfelle 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 til å beregne hvor mye tid som gikk, slik at vi kan utføre en spesifikk instruksjon.

if (currentMillis - forrige Millis> = intervall)
Forrige Millis = CurrentMillis;

Denne koden trekker de forrige Millis () fra Current Millis () Hvis den trukket fra den trukkete tiden tilsvarer å definere intervallet, vil en spesifikk instruksjon bli utført. La oss si at vi vil blinke en LED i 10 sekunder. Etter hvert 5. minutt kan vi stille tidsintervallet lik 5 minutter (300000ms). Koden vil se etter intervallet hver gang koden kjører, når den når den vil blinke LED i 10 sekunder.

Merk: Her bruker vi Millis () -funksjonen for grensesnitt ESP32 med PIR -sensor. Hovedårsaken til å bruke Milli og ikke forsinkelse er at Millis () -funksjonen ikke blokkerer koden som forsinkelse () -funksjonen gjorde. Så når PIR oppdaget bevegelse, vil det bli generert et avbrudd. Bruk.

I tilfelle hvis vi brukte Delay () -funksjonen, vil den fullstendig blokkere koden og eventuell avbrudd forårsaket vil ikke bli lest av ESP32, noe som resulterer i feil i prosjektet.

3: grensesnittende 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 en viss bevegelse. Denne LED vil gløde i en bestemt tid etter at den vil gå tilbake til normal tilstand.

Her er en liste over komponenter vi vil være påkrevd:

• • ESP32 Development Board
  • PIR-bevegelsessensor (HC-SR501)
  • Led
  • 330 ohm motstand
  • Koble til ledninger
  • Brødbrett

Skjematisk For PIR -sensor med ESP32:

PIN -tilkoblinger av ESP32 med PIR -sensor er:

1: PIR-bevegelsessensor (HC-SR501)

PIR er et forkortelse for Passiv infrarød sensor. Den bruker et par pyroelektriske sensorer som oppdager varme rundt omgivelsene. Begge disse pyroelektriske sensorene ligger etter hverandre, og når et objekt kommer inn i deres område, får en endring i varmeenergi eller signalforskjellen mellom begge disse sensorene fører til at PIR -sensorutgangen er lav. Når PIR ut -pinnen går lavt, kan vi angi en spesifikk instruksjon for å utføre.

Følgende er egenskapene til PIR -sensor:

• • Følsomhet kan settes avhengig av prosjektets beliggenhet (for eksempel sensing av mus eller bladbevegelse).
  • PIR -sensor kan settes for hvor lenge den oppdager et objekt.
  • Mye brukt i hjemmesikkerhetsalarmer og andre termiske baserte bevegelsesapplikasjoner.

2: Pinout HC-SR501

PIR HC-SR501 kommer med tre pinner. To av dem er kraftpinner for VCC og GND, og ​​en er utgangspinnen for utløsersignalet.

Følgende er beskrivelsen av PIR -sensorpinner:

3: Kode

Nå for å programmere ESP32, skriv den gitte koden i Arduino IDE -redaktør og last den opp til ESP32.

#Define Timeseconds 10
const int LED = 4; /*Gpio pin 4 definert for LED*/
const int pir_out = 13; /*Gpio pin 13 for pir out*/
usignert lang nåværende_tid = millis (); /*Variabel definert for lagring av millisverdier*/
usignert lang tidligere_trig = 0;
boolean start_time = falsk;
void iram_attr detectSmovement () /*sjekk for bevegelse* /
Serie.println ("bevegelse oppdaget");
digitalwrite (LED, høy); /*Slå på LED hvis tilstanden er sann*/
Start_time = true;
Forrige_trig = millis ();

void setup ()
Serie.Begin (115200); /*baudfrekvens for seriell kommunikasjon*/
pinmode (pir_out, input_pullup); /*PIR -bevegelsessensormodus definert*/
/*PIR er konfigurert i stigende modus, sett bevegelsessensorpinne som utgang*/
vedlegginterrupt (DigitalPinToinToRrupt (PIR_OUT), DetectSmovement, Rising);
pinmode (LED, output); /*sett førte til lav*/
DigitalWrite (LED, lav);

void loop ()
Current_time = millis (); /*Lagre nåværende tid*/
if (start_time && (current_time - forrige_trig> (timeseconds*1000))) /*tidsintervall hvoretter LED vil slå av* /
Serie.println ("bevegelse stoppet"); /*Skriver ut bevegelse stoppet hvis ingen bevegelse oppdaget*/
DigitalWrite (LED, lav); /*Sett ført til lav hvis tilstanden er falsk*/
Start_time = 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, forrige_trig, og Starttid. Disse variablene vil lagre gjeldende tid, tid hvor bevegelse oppdages og timer etter at bevegelsen er oppdaget.

I oppsettdelen først definerte vi seriell baudfrekvens for kommunikasjon. Neste bruk pinmode () Angi PIR -bevegelsessensoren som inngangspullup. For å sette piravbruddet vedlegg () vedlegg () er beskrevet. GPIO 13 er beskrevet for å oppdage bevegelse på stigende modus.

Neste i Loop () del av koden, ved å bruke Millis () -funksjonen vi slo av og på LED når en trigger oppnås.

4: Output

I utgangsseksjonen kan vi se at objektet er utenfor PIR -sensoren, så Led er snudd AV.

Nå vil bevegelsen oppdaget av PIR -sensor -LED snu PÅ til 10 sek Etter det hvis ingen bevegelse blir oppdaget, vil det forbli AV Inntil neste trigger er mottatt.

Følgende utgang vises av seriemonitoren i Arduino IDE.

Konklusjon

En PIR -sensor med ESP32 kan bidra til å oppdage bevegelse av objekter som går gjennom rekkevidden. Ved å bruke avbruddsfunksjonen i ESP32 -programmering kan vi utløse et svar på en spesifikk GPIO -pinne. Når endring oppdages, vil avbrytelsesfunksjonen bli utløst og en LED vil slå på.