ESP32 är ett IoT-baserat mikrokontrollerkort som kan användas för att koppla ihop, styra och läsa olika sensorer. PIR eller rörelsesensor är en av enheterna som vi kan samverka med ESP32 för att upptäcka rörelse av ett objekt inom rörelsesensorns omfång med hjälp av ESP32.
Innan vi börjar koppla ESP32 med PIR-sensor måste vi veta hur avbrott fungerar och hur man läser och hanterar dem i ESP32. Därefter måste vi förstå kärnkonceptet delay() och millis()-funktioner i ESP32-programmering.
Låt oss diskutera hur PIR fungerar med ESP32 i detalj.
Här är innehållet i denna artikel:
1: Vad är avbrott
De flesta händelser som händer i ESP32-programmering körs sekventiellt, vilket innebär rad för rad exekvering av kod. För att hantera och kontrollera händelser som inte behöver köras under sekventiell exekvering av kod an Avbryter används.
Till exempel, om vi vill utföra en viss uppgift när någon speciell händelse inträffar, eller en triggersignal ges till digitala stift på mikrokontrollern, använder vi avbrott.
Med avbrott behöver vi inte kontinuerligt kontrollera det digitala tillståndet för ESP32-ingångsstiftet. När ett avbrott inträffar stoppar processorn huvudprogrammet och en ny funktion anropas som kallas ISR ( Rutin för avbrott i tjänsten ). Detta ISR funktionen hanterar avbrottet som orsakas efter att återgå till huvudprogrammet och börja köra det. Ett av exemplen på ISR är PIR rörelsesensor som genererar ett avbrott när rörelse detekteras .
1.1: Avbryter stift i ESP32
Ett externt avbrott eller hårdvaruavbrott kan orsakas av vilken hårdvarumodul som helst som peksensor eller tryckknapp. Beröringsavbrott inträffar när en beröring upptäcks på ESP32-stiften eller GPIO-avbrott kan också användas när en tangent eller tryckknapp trycks ned.
I den här artikeln kommer vi att utlösa ett avbrott när rörelsen detekteras med PIR-sensorn med ESP32.
Nästan alla GPIO-stift utom 6 SPI-integrerade stift som vanligtvis kommer i 36 -pin-versionen av ESP32-kortet kan inte användas för att avbryta samtal. Så för att ta emot det externa avbrottet är följande stift markerade i lila färg som man kan använda i ESP32:
Den här bilden är av en 30-stifts ESP32.
1.2: Anropa ett avbrott i ESP32
För att använda avbrott i ESP32 kan vi ringa bifogaInterrupt() fungera.
Denna funktion accepterar följande tre argument:
-
- GPIO-stift
- Funktion som ska utföras
- Läge
1: GPIO pin är det första argumentet som kallas inuti bifogaInterrupt() fungera. Till exempel, för att använda digital pin 12 som en avbrottskälla kan vi kalla det att använda digitalPinToInterrupt(12) fungera.
2: Funktion som ska exekveras är det program som exekveras varje gång när avbrottet nås eller utlöses av en extern eller intern källa. Det kan antingen vara att blinka en lysdiod eller att vrida på ett brandlarm.
3: Läge är det tredje och sista argumentet som avbrottsfunktionen behöver. Den beskriver när avbrottet ska utlösas. Följande lägen kan användas:
-
- Låg: Utlösa avbrottet varje gång det definierade GPIO-stiftet är lågt.
- Hög: Utlösa avbrottet varje gång det definierade GPIO-stiftet är högt.
- Förändra: Trigga avbrott varje gång GPIO-stift ändrar sitt värde från högt till lågt eller vice versa.
- Faller: Det är läget för att utlösa ett avbrott när ett visst stift börjar falla från högt läge till lågt.
- Stigande: Det är läget för att utlösa ett avbrott när ett visst stift börjar stiga från lågt läge till högt.
Idag kommer vi att använda Stigande läge som ett tredje argument för avbrottsfunktionen närhelst PIR-sensorn detekterar avbrottslampan eller sensorn kommer att tändas eftersom den går från lågt läge till högt.
2: Timers i ESP32-programmering
Timers i mikrokontrollerprogrammering spelar en viktig roll för exekvering av instruktioner för en specifik timerperiod eller vid specifik tidpunkt.
Två huvudfunktioner som vanligtvis används för att trigga utgången är dröjsmål() och millis() . Skillnaden mellan dem båda som delay()-funktionen stoppar resten av programmet när det börjar köras medan millis() körs under den definierade tidsperioden och sedan går programmet tillbaka till huvudfunktionerna.
Här kommer vi att använda en LED med PIR-sensor och vi vill inte lysa upp den kontinuerligt efter att ett avbrott triggar. Vi kommer att använda funktionen millis() som låter oss lysa upp den under en viss bestämd tid och sedan återgå till det ursprungliga programmet när den tidsstämpeln har passerat.
2.1: delay() Funktion
delay()-funktionen är ganska enkel, den tar bara ett argument som är Fröken av osignerad lång datatyp. Detta argument representerar tiden i millisekunder vi vill pausa programmet tills det går till nästa rad.
Till exempel kommer följande funktion att stoppa programmet för 1 sek .
dröjsmål ( 1000 )
delay() är en slags blockeringsfunktion för mikrokontrollers programmering. delay() blockerar resten av koden att exekvera tills denna funktionstid inte slutförs. Om vi vill utföra flera instruktioner bör vi undvika att använda fördröjningsfunktioner istället kan vi använda millis eller externa timer RTC-moduler.
2.2: millis() Funktion
millis()-funktionen returnerar antalet millisekunder som gått sedan ESP32-kortet började köra det aktuella programmet. Genom att skriva några rader kod kan vi enkelt beräkna aktuell tid när som helst när vi kör ESP32-koden.
millis används ofta där vi behöver köra flera uppgifter utan att blockera resten av koden. Här är syntaxen för millis-funktionen som används för att beräkna hur lång tid som gått så att vi kan utföra en specifik instruktion.
om ( nuvarandeMillis - föregåendeMillis > = intervall ) {föregåendeMillis = aktuellMillis;
}
Denna kod subtraherar föregående millis() från nuvarande millis() om den subtraherade tiden är lika med att definiera intervallet som en specifik instruktion kommer att exekveras. Låt oss säga att vi vill blinka en LED i 10 sekunder. Efter var 5:e minut kan vi ställa in tidsintervallet lika med 5 minuter (300000ms). Koden kommer att kontrollera intervallet varje gång koden körs, när den väl når kommer den att blinka med lysdioden i 10 sekunder.
Notera: Här kommer vi att använda funktionen millis() för att koppla ESP32 med PIR-sensor. Den främsta anledningen till att använda milli och inte delay är att funktionen millis() inte blockerar koden som delay()-funktionen gjorde. Så när PIR detekterar rörelse kommer ett avbrott att genereras. Användning av interrupt millis()-funktionen kommer att trigga lysdioden under en definierad tid efter att om rörelsen stoppas kommer millis()-funktionen att återställas och vänta på nästa avbrott.
Om vi använde funktionen delay() kommer den att blockera koden fullständigt och eventuella avbrott kommer inte att läsas av ESP32 vilket resulterar i att projektet misslyckas.
3: Gränssnitt PIR-sensor med ESP32
Här kommer vi att använda funktionen millis() i Arduino IDE-kod eftersom vi vill trigga LED varje gång PIR-sensorn upptäcker någon rörelse. Denna lysdiod kommer att lysa under en viss tid efter att den återgår till normalt tillstånd.
Här är en lista över komponenter som vi kommer att behöva:
-
- ESP32 utvecklingskort
- PIR-rörelsesensor (HC-SR501)
- LED
- 330 Ohm motstånd
- Anslutningsledningar
- Bakbord
Schematisk för PIR-sensor med ESP32:
Stiftanslutningar av ESP32 med PIR-sensor är:
| ESP32 | PIR-sensor |
| komma | Vcc |
| GPIO13 | UT |
| GND | GND |
3.1: PIR-rörelsesensor (HC-SR501)
PIR är en akronym för passiv infraröd sensor . Den använder ett par pyroelektriska sensorer som känner av värme runt omgivningen. Båda dessa pyroelektriska sensorer ligger efter varandra och när ett föremål kommer inom deras räckvidd gör en förändring i värmeenergin eller signalskillnaden mellan båda dessa sensorer att PIR-sensorns utsignal blir LÅG. När PIR-utgångsstiftet blir LÅG, kan vi ställa in en specifik instruktion att exekvera.
Följande är egenskaperna hos PIR-sensorn:
-
- Känslighet kan ställas in beroende på platsen för projektet (som att känna av mus- eller bladrörelser).
- PIR-sensorn kan ställas in för hur länge den upptäcker ett föremål.
- Används i stor utsträckning i hemsäkerhetslarm och andra termiska applikationer för rörelsedetektering.
3.2: Pinout HC-SR501
PIR HC-SR501 kommer med tre stift. Två av dem är strömstift för Vcc och GND och ett är utgångsstiftet för triggersignalen.
Följande är beskrivningen av PIR-sensorstift:
| Stift | namn | Beskrivning |
| 1 | Vcc | Ingångsstift för sensor Anslut till ESP32 Vin Pin |
| två | UT | Sensorutgång |
| 3 | GND | Sensor GND |
3.3: Kod
Nu för att programmera ESP32, skriv den givna koden i Arduino IDE-editor och ladda upp den till ESP32.
#define timeSeconds 10const int led = 4 ; /* GPIO PIN 4 definierat för LED */
const int PIR_Out = 13 ; /* GPIO-stift 13 för PIR ut */
unsigned long Current_Time = millis ( ) ; /* variabel definierad för lagra millisvärden */
unsigned long Previous_Trig = 0 ;
boolesk starttid = falsk ;
void IRAM_ATTR upptäcker rörelse ( ) { /* kolla upp för rörelse */
Serial.println ( 'RÖRELSE DETEKTERAD' ) ;
digitalWrite ( led, HÖG ) ; /* Slå PÅ LED om skick är Sann */
Starttid = Sann ;
Previous_Trig = millis ( ) ;
}
ogiltig installation ( ) {
Serial.begin ( 115200 ) ; /* baudhastighet för seriell kommunikation */
pin-läge ( PIR_Out, INPUT_PULLUP ) ; /* PIR-rörelsesensorläge definierat */
/* PIR är konfigurerad i STIGANDE läge, uppsättning rörelsesensorstift som produktion */
bifoga Avbrott ( digitalPinToInterrupt ( PIR_Ut ) , upptäcker rörelse, STIGNING ) ;
pin-läge ( led, OUTPUT ) ; /* uppsättning LED till LÅG */
digitalWrite ( led, LÅG ) ;
}
tom slinga ( ) {
Current_Time = millis ( ) ; /* lagra ström tid */
om ( Starttid && ( Current_Time - Previous_Trig > ( timeSeconds * 1000 ) ) ) { /* Tidsintervall efter som LED kommer att släckas */
Serial.println ( 'RÖRELSE STOPPAD' ) ; /* Utskriftsrörelse stoppad om ingen rörelse upptäckt */
digitalWrite ( led, LÅG ) ; /* Ställ in LED på LÅG om skick är falsk */
Starttid = falsk ;
}
}
Koden började med att definiera GPIO-stift för LED- och PIR-utgång. Därefter skapade vi tre olika variabler som hjälper till att slå på LED när rörelse upptäcks.
Dessa tre variabler är Current_Time, Previous_Trig, och Starttid. Dessa variabler kommer att lagra aktuell tid, tidpunkt då rörelse detekteras och timer efter att rörelsen har detekterats.
I installationsdelen definierade vi först seriell baudhastighet för kommunikation. Nästa användning pinMode() ställ in PIR-rörelsesensorn som INPUT PULLUP. För att ställa in PIR-avbrottet bifogaInterrupt() är beskrivet. GPIO 13 beskrivs för att detektera rörelse i RISING-läge.
Nästa i loop()-delen av koden, med hjälp av millis()-funktionen slog vi PÅ och AV lysdioden när en trigger uppnås.
3.4: Utgång
I utgångssektionen kan vi se att objektet är utanför PIR-sensorns räckvidd, så att LED är vänt AV .
Nu kommer rörelsen som detekteras av PIR-sensorns LED att vända PÅ för 10 sek efter att om ingen rörelse upptäcks kommer den att finnas kvar AV tills nästa trigger tas emot.
Följande utdata visas av den seriella monitorn i Arduino IDE.
Slutsats
En PIR-sensor med ESP32 kan hjälpa till att upptäcka rörelse hos föremål som passerar genom dess räckvidd. Genom att använda avbrottsfunktionen i ESP32-programmering kan vi utlösa ett svar på någon specifik GPIO-stift. När förändring upptäcks kommer avbrottsfunktionen att triggas och en lysdiod tänds.