ESP32 is een op het IoT gebaseerde microcontrollerkaart die kan worden gebruikt om verschillende sensoren te koppelen, te besturen en uit te lezen. PIR of bewegingssensor is een van de apparaten die we kunnen koppelen met ESP32 om beweging van een object in het bereik van de bewegingssensor te detecteren met behulp van ESP32.
Voordat we beginnen met het koppelen van ESP32 met de PIR-sensor, moeten we weten hoe interrupts werken en hoe ze moeten worden gelezen en verwerkt in ESP32. Vervolgens moeten we het kernconcept van de functie delay() en millis() in ESP32-programmering begrijpen.
Laten we de werking van PIR met ESP32 in detail bespreken.
Hier is de inhoud van dit artikel:
1: Wat zijn onderbrekingen
De meeste gebeurtenissen die plaatsvinden in ESP32-programmering worden opeenvolgend uitgevoerd, wat betekent dat de code regel voor regel wordt uitgevoerd. Om de gebeurtenissen af te handelen en te controleren die niet hoeven te worden uitgevoerd tijdens de sequentiële uitvoering van code an Onderbreekt worden gebruikt.
Als we bijvoorbeeld een bepaalde taak willen uitvoeren wanneer er zich een speciale gebeurtenis voordoet, of als er een triggersignaal wordt gegeven aan digitale pinnen van de microcontroller, gebruiken we interrupt.
Met een onderbreking hoeven we niet continu de digitale status van de ESP32-ingangspin te controleren. Wanneer er een interrupt optreedt, stopt de processor het hoofdprogramma en wordt een nieuwe functie aangeroepen die bekend staat als ISR ( Serviceroutine onderbreken ). Deze ISR functie verwerkt de onderbreking die daarna wordt veroorzaakt, keert u terug naar het hoofdprogramma en begint u het uit te voeren. Een van de voorbeelden van ISR is PIR-bewegingssensor welke genereert een onderbreking zodra er beweging wordt gedetecteerd .
1.1: onderbreekt pinnen in ESP32
Een externe of hardware-onderbreking kan worden veroorzaakt door een hardwaremodule, zoals een aanraaksensor of een drukknop. Aanrakingsonderbrekingen vinden plaats wanneer een aanraking wordt gedetecteerd bij ESP32-pinnen of GPIO-onderbreking kan ook worden gebruikt wanneer een toets of drukknop wordt ingedrukt.
In dit artikel zullen we een onderbreking activeren wanneer de beweging wordt gedetecteerd met behulp van de PIR-sensor met ESP32.
Bijna alle GPIO-pinnen behalve 6 SPI-geïntegreerde pinnen die meestal in de 36 -pin-versie van ESP32-kaart kan niet worden gebruikt voor onderbrekingsoproepen. Dus om de externe interrupt te ontvangen, zijn de pinnen gemarkeerd in paarse kleur die men in ESP32 kan gebruiken:
Deze afbeelding is van een 30-pins ESP32.
1.2: Een onderbreking aanroepen in ESP32
Voor het gebruik van interrupt in ESP32 kunnen we bellen bijlageInterrupt() functie.
Deze functie accepteert de volgende drie argumenten:
-
- GPIO-pin
- Uit te voeren functie
- modus
1: GPIO pin is het eerste argument dat binnen de bijlageInterrupt() functie. Om bijvoorbeeld digitale pin 12 als onderbrekingsbron te gebruiken, kunnen we dit gebruik noemen digitalPinToInterrupt(12) functie.
2: Functie uit te voeren is het programma dat elke keer wordt uitgevoerd zodra de interrupt wordt bereikt of geactiveerd door een externe of interne bron. Het kan een knipperende LED zijn of een brandalarm activeren.
3: Modus is het derde en laatste argument dat de interruptfunctie nodig heeft. Het beschrijft wanneer de interrupt moet worden geactiveerd. Hieronder volgen de modi die kunnen worden gebruikt:
-
- Laag: Activeer de interrupt elke keer dat de gedefinieerde GPIO-pin laag is.
- Hoog: Activeer de interrupt elke keer dat de gedefinieerde GPIO-pin hoog is.
- Wijziging: Trigger interrupt elke keer dat de GPIO-pin de waarde verandert van hoog naar laag of vice versa.
- vallen: Het is de modus om een interrupt te activeren wanneer een bepaalde pin van een hoge naar een lage status begint te vallen.
- Stijgende lijn: Het is de modus om een interrupt te activeren wanneer een bepaalde pin begint te stijgen van een lage naar een hoge status.
Vandaag gaan we gebruiken Stijgende lijn modus als een derde argument voor de onderbrekingsfunctie wanneer de PIR-sensor detecteert, zal de onderbrekings-LED of sensor oplichten omdat deze van laag naar hoog gaat.
2: Timers in ESP32-programmering
Timers bij het programmeren van microcontrollers spelen een belangrijke rol bij het uitvoeren van instructies voor een specifieke timerperiode of op een bepaald tijdstip.
Twee hoofdfuncties die vaak worden gebruikt om de uitvoer te activeren, zijn vertraging() en millis() . Het verschil tussen beide, aangezien de functie delay() de rest van het programma stopt zodra het wordt uitgevoerd, terwijl millis() gedurende de gedefinieerde periode wordt uitgevoerd, gaat het programma terug naar de hoofdfuncties.
Hier zullen we een LED met PIR-sensor gebruiken en we willen deze niet continu laten gloeien nadat een onderbreking is geactiveerd. We zullen de functie millis() gebruiken waarmee we het een bepaalde tijd kunnen laten gloeien en dan weer teruggaan naar het oorspronkelijke programma zodra die tijdstempel is verstreken.
2.1: vertraging() Functie
De functie delay() is vrij eenvoudig, er is maar één argument voor nodig, namelijk Mevrouw van niet-ondertekend lang gegevenstype. Dit argument vertegenwoordigt de tijd in milliseconden dat we het programma willen pauzeren totdat het naar de volgende regel gaat.
De volgende functie stopt het programma bijvoorbeeld voor 1 seconde .
vertraging ( 1000 )
delay() is een soort blokkeerfunctie voor het programmeren van microcontrollers. delay() blokkeert de rest van de code die moet worden uitgevoerd totdat de tijd van deze specifieke functie niet is voltooid. Als we meerdere instructies willen uitvoeren, moeten we het gebruik van vertragingsfuncties vermijden. In plaats daarvan kunnen we millis of externe timer-RTC-modules gebruiken.
2.2: millis() Functie
functie millis() retourneert het aantal milliseconden dat is verstreken sinds het ESP32-bord het huidige programma begon uit te voeren. Door een paar regels code te schrijven, kunnen we op elk moment eenvoudig de huidige tijd berekenen terwijl de ESP32-code wordt uitgevoerd.
millis wordt veel gebruikt wanneer we meerdere taken moeten uitvoeren zonder de rest van de code te blokkeren. Hier is de syntaxis van de millis-functie die wordt gebruikt om te berekenen hoeveel tijd er is verstreken, zodat we een specifieke instructie kunnen uitvoeren.
als ( huidigeMillis - vorigeMillis > = interval ) {vorigeMillis = huidigeMillis;
}
Deze code trekt de vorige millis() af van de huidige millis() als de afgetrokken tijd gelijk is aan het definiëren van het interval dat een specifieke instructie zal worden uitgevoerd. Laten we zeggen dat we een LED 10 seconden willen laten knipperen. Na elke 5 minuten kunnen we het tijdsinterval instellen op 5 minuten (300000ms). De code controleert het interval elke keer dat de code wordt uitgevoerd, zodra deze is bereikt, knippert de LED gedurende 10 seconden.
Opmerking: Hier zullen we de functie millis() gebruiken om ESP32 met de PIR-sensor te verbinden. De belangrijkste reden achter het gebruik van milli en niet delay is dat de functie millis() de code niet blokkeert zoals de delay()-functie deed. Dus zodra de PIR beweging detecteert, wordt er een onderbreking gegenereerd. Het gebruik van de interruptfunctie millis() activeert de LED gedurende een bepaalde tijd, daarna wordt de millis()-functie gereset en wacht op de volgende interrupt als de beweging wordt gestopt.
Als we de functie delay() gebruiken, wordt de code volledig geblokkeerd en wordt een eventuele onderbreking niet gelezen door ESP32, wat resulteert in een mislukking van het project.
3: Interfacing PIR-sensor met ESP32
Hier zullen we de functie millis() gebruiken in de Arduino IDE-code, omdat we de LED willen activeren telkens wanneer de PIR-sensor enige beweging detecteert. Deze LED brandt een bepaalde tijd, waarna hij terugkeert naar de normale toestand.
Hier is een lijst met componenten die we nodig hebben:
-
- ESP32 ontwikkelbord
- PIR-bewegingssensor (HC-SR501)
- LED
- Weerstand van 330 Ohm
- Draden aansluiten
- Broodplank
Schematisch voor PIR-sensor met ESP32:
Pin aansluitingen van ESP32 met PIR sensor is:
| ESP32 | PIR-sensor |
| komen | Vcc |
| GPIO13 | UIT |
| GND | GND |
3.1: PIR-bewegingssensor (HC-SR501)
PIR is een afkorting voor passieve infraroodsensor . Het maakt gebruik van een paar pyro-elektrische sensoren die warmte rond zijn omgeving detecteren. Beide pyro-elektrische sensoren liggen achter elkaar en wanneer een object binnen hun bereik komt, zorgt een verandering in warmte-energie of het signaalverschil tussen beide sensoren ervoor dat de uitvoer van de PIR-sensor LAAG is. Zodra de PIR-out-pin LAAG wordt, kunnen we een specifieke instructie instellen om uit te voeren.
Hieronder volgen de kenmerken van de PIR-sensor:
-
- De gevoeligheid kan worden ingesteld afhankelijk van de locatie van het project (zoals het detecteren van muis- of bladbewegingen).
- PIR-sensor kan worden ingesteld hoe lang deze een object detecteert.
- Op grote schaal gebruikt in huisbeveiligingsalarmen en andere op warmte gebaseerde bewegingsdetectietoepassingen.
3.2: Pinout HC-SR501
PIR HC-SR501 wordt geleverd met drie pinnen. Twee daarvan zijn voedingspinnen voor Vcc en GND en één is de uitgangspin voor het triggersignaal.
Hieronder volgt de beschrijving van PIR-sensorpennen:
| Pin | Naam | Beschrijving |
| 1 | Vcc | Ingangspen voor sensor Aansluiten op ESP32 Vin Pin |
| twee | UIT | Sensoruitvoer |
| 3 | GND | Sensor GND |
3.3: code
Om ESP32 te programmeren, schrijft u de gegeven code in de Arduino IDE-editor en uploadt u deze naar ESP32.
#define timeSeconds 10const int led = 4 ; /* GPIO-pincode 4 bepaald voor LED */
const int PIR_Out = 13 ; /* GPIO-pin 13 voor PIR uit */
unsigned long Current_Time = millis ( ) ; /* variabele gedefinieerd voor millis-waarden opslaan */
unsigned long Vorige_Trig = 0 ;
booleaanse begintijd = vals ;
ongeldig IRAM_ATTR detecteertBeweging ( ) { /* controleren voor beweging */
Serial.println ( 'BEWEGING GEDETECTEERD' ) ;
digitaalSchrijven ( geleid, HOOG ) ; /* LED inschakelen als conditie is WAAR */
Starttijd = WAAR ;
Vorige_Trig = millis ( ) ;
}
ongeldige opstelling ( ) {
Serieel.begin ( 115200 ) ; /* baudsnelheid voor seriële communicatie */
pinMode ( PIR_Uit, INPUT_PULLUP ) ; /* PIR-bewegingssensormodus gedefinieerd */
/* PIR is geconfigureerd in STIJGENDE modus, set bewegingssensor speld net zo uitgang */
bijlageInterrupt ( digitalPinToInterrupt ( PIR_Uit ) , detecteertBeweging, STIJGEN ) ;
pinMode ( geleid, UITGANG ) ; /* set LED naar LAAG */
digitaalSchrijven ( geleid, LAAG ) ;
}
lege lus ( ) {
Current_Time = millis ( ) ; /* stroom opslaan tijd */
als ( Starttijd && ( Current_Time - Previous_Trig > ( tijdSeconden * 1000 ) ) ) { /* Tijdsinterval na welke LED gaat uit */
Serial.println ( 'BEWEGING GESTOPT' ) ; /* Afdrukken beweging gestopt als geen beweging gedetecteerd */
digitaalSchrijven ( geleid, LAAG ) ; /* Stel LED in op LAAG als conditie is vals */
Starttijd = vals ;
}
}
De code begon met het definiëren van GPIO-pinnen voor LED- en PIR-uitvoer. Vervolgens hebben we drie verschillende variabelen gemaakt die helpen om LED in te schakelen wanneer er beweging wordt gedetecteerd.
Deze drie variabelen zijn Current_Time, Previous_Trig, en Starttijd. Deze variabelen slaan de huidige tijd op, het tijdstip waarop beweging is gedetecteerd en de timer nadat de beweging is gedetecteerd.
In het installatiegedeelte hebben we eerst de seriële baudsnelheid voor communicatie gedefinieerd. Volgende gebruiken pinMode() stel de PIR-bewegingssensor in als INPUT PULLUP. Om de PIR-onderbreking in te stellen bijlageInterrupt() is beschreven. GPIO 13 wordt beschreven om beweging te detecteren in de RISING-modus.
Volgende in loop() deel van de code, met behulp van de millis() functie hebben we de LED AAN en UIT gezet wanneer een trigger is bereikt.
3.4: Uitvoer
In het uitvoergedeelte kunnen we zien dat het object buiten het bereik van de PIR-sensor is, dus de LED is gedraaid UIT .
Nu zal de door de PIR-sensor-LED gedetecteerde beweging draaien AAN voor 10 sec als er daarna geen beweging wordt gedetecteerd, blijft deze staan UIT totdat de volgende trigger wordt ontvangen.
De volgende uitvoer wordt weergegeven door de seriële monitor in Arduino IDE.
Conclusie
Een PIR-sensor met ESP32 kan helpen bij het detecteren van beweging van objecten die door zijn bereik gaan. Met behulp van de interruptfunctie in ESP32-programmering kunnen we een reactie activeren op een specifieke GPIO-pin. Wanneer er een verandering wordt gedetecteerd, wordt de onderbrekingsfunctie geactiveerd en gaat een LED branden.