Ang ESP32 ay isang IoT based microcontroller board na maaaring magamit upang mag-interface, makontrol at magbasa ng iba't ibang mga sensor. Ang PIR o motion sensor ay isa sa mga device na maaari naming i-interface sa ESP32 para makita ang paggalaw ng isang bagay sa hanay ng motion sensor gamit ang ESP32.
Bago natin simulan ang interfacing ng ESP32 sa PIR sensor dapat nating malaman kung paano gumagana ang mga interrupts at kung paano basahin at pangasiwaan ang mga ito sa ESP32. Susunod, dapat nating maunawaan ang pangunahing konsepto ng delay() at millis() function sa ESP32 programming.
Talakayin natin ang paggana ng PIR sa ESP32 nang detalyado.
Narito ang nilalaman para sa artikulong ito:
1: Ano ang Mga Pagkagambala
Karamihan sa mga kaganapan na nangyayari sa ESP32 programming ay tumatakbo nang sunud-sunod na nangangahulugang linya sa linya ng pagpapatupad ng code. Upang pangasiwaan at kontrolin ang mga kaganapan na hindi kailangang tumakbo sa sunud-sunod na pagpapatupad ng code an Nakakaabala ay ginamit.
Halimbawa, kung gusto naming magsagawa ng isang partikular na gawain kapag may naganap na anumang espesyal na kaganapan, o isang trigger signal ang ibinibigay sa mga digital na pin ng microcontroller na ginagamit namin sa interrupt.
Sa pagkaantala, hindi namin kailangang patuloy na suriin ang digital na estado ng ESP32 input pin. Kapag may naganap na interrupt, ihihinto ng processor ang pangunahing programa at tinatawag ang isang bagong function na kilala bilang ISR ( Makagambala sa Routine ng Serbisyo ). Ito ISR pinangangasiwaan ng function ang interrupt na dulot pagkatapos na bumalik sa pangunahing programa at simulan itong isagawa. Isa sa mga halimbawa ng ISR ay PIR motion sensor alin bubuo ng interrupt kapag natukoy ang paggalaw .
1.1: Nakakaabala sa Mga Pin sa ESP32
Ang isang panlabas o hardware interrupt ay maaaring sanhi ng anumang hardware module tulad ng touch sensor o push button. Nangyayari ang mga touch interrupts kapag may na-detect na touch sa mga ESP32 pin o maaari ding gamitin ang GPIO interrupt kapag pinindot ang isang key o push button.
Sa artikulong ito, magti-trigger kami ng interrupt kapag natukoy ang paggalaw gamit ang PIR sensor na may ESP32.
Halos lahat ng GPIO pin maliban sa 6 na SPI integrated pin na kadalasang pumapasok sa 36 -pin na bersyon ng ESP32 board ay hindi maaaring gamitin para sa layunin ng interrupt na pagtawag. Kaya, upang matanggap ang panlabas na interrupt na sumusunod ay ang mga pin na naka-highlight sa kulay na lila na magagamit ng isa sa ESP32:
Ang larawang ito ay isang 30 pin na ESP32.
1.2: Pagtawag ng Interrupt sa ESP32
Para sa paggamit ng interrupt sa ESP32 maaari kaming tumawag attachInterrupt() function.
Ang function na ito ay tumatanggap ng sumusunod na tatlong argumento:
-
- GPIO pin
- Function na isasagawa
- Mode
1: GPIO pin ay ang unang argumento na tinatawag sa loob ng attachInterrupt() function. Halimbawa, para magamit ang digital pin 12 bilang isang interrupt source na matatawag natin itong gamit digitalPinToInterrupt(12) function.
2: Pag-andar ang ipapatupad ay ang programang ipapatupad sa tuwing naabot o na-trigger ng isang panlabas o panloob na pinagmulan ang interrupt. Maaari itong maging alinman sa pag-blink ng LED o pag-on ng alarma sa sunog.
3: Mode ay ang pangatlo at huling argumento na kailangan ng interrupt function. Inilalarawan nito kung kailan magti-trigger ng interrupt. Ang mga sumusunod ay ang mga mode na maaaring gamitin:
-
- mababa: I-trigger ang interrupt sa tuwing mababa ang tinukoy na GPIO pin.
- Mataas: I-trigger ang interrupt sa tuwing mataas ang tinukoy na GPIO pin.
- Baguhin: Trigger interrupt sa tuwing babaguhin ng GPIO pin ang value nito mula sa mataas patungo sa mababa o vice versa.
- nahuhulog: Ito ang mode upang mag-trigger ng interrupt kapag ang isang partikular na pin ay nagsimulang bumagsak mula sa mataas na estado hanggang sa mababa.
- Tumataas: Ito ang mode para mag-trigger ng interrupt kapag ang isang partikular na pin ay nagsimulang tumaas mula sa mababang estado hanggang sa mataas.
Ngayon ay gagamitin natin Tumataas mode bilang pangatlong argumento para sa interrupt function sa tuwing nakita ng PIR sensor ang interrupt LED o sensor ay sisindi dahil ito ay mula sa mababang estado patungo sa mataas.
2: Mga Timer sa ESP32 Programming
Ang mga timer sa microcontroller programming ay may mahalagang papel para sa pagpapatupad ng mga tagubilin para sa isang partikular na panahon ng timer o sa partikular na pagkakataon ng oras.
Dalawang pangunahing function na karaniwang ginagamit upang ma-trigger ang output ay pagkaantala() at millis() . Ang pagkakaiba sa pagitan ng dalawa bilang delay() function ay humihinto sa natitirang bahagi ng program kapag nagsimula itong mag-execute habang ang millis() ay tumatakbo para sa tinukoy na yugto ng panahon pagkatapos ay babalik ang program sa mga pangunahing function.
Dito kami ay gagamit ng LED na may PIR sensor at hindi namin nais na patuloy itong liwanagin pagkatapos ng isang interrupt na pag-trigger. Gagamitin namin ang millis() function na nagbibigay-daan sa amin na liwanagin ito para sa ilang tinukoy na oras at pagkatapos ay babalik muli sa orihinal na programa kapag lumipas ang time stamp.
2.1: delay() Function
delay() function ay medyo simple ito ay nangangailangan lamang ng isang argument na kung saan ay MS ng unsigned long data type. Ang argumentong ito ay kumakatawan sa oras sa millisecond na gusto naming i-pause ang program hanggang sa lumipat ito sa susunod na linya.
Halimbawa, ihihinto ng sumusunod na function ang program para sa 1 seg .
pagkaantala ( 1000 )
delay() ay isang uri ng blocking function para sa microcontrollers programming. hinaharangan ng delay() ang natitirang code na isasagawa hanggang sa hindi makumpleto ang partikular na oras ng function na ito. Kung gusto naming magsagawa ng maraming mga tagubilin, dapat naming iwasan ang paggamit ng mga function ng pagkaantala sa halip na maaari naming gamitin ang millis o external timer RTC modules.
2.2: millis() Function
Ang millis() function ay nagbabalik ng bilang ng mga millisecond na lumipas mula nang simulan ng ESP32 board ang kasalukuyang programa. Sa pamamagitan ng pagsulat ng ilang linya ng code, madali nating makalkula ang kasalukuyang oras sa anumang pagkakataon habang pinapatakbo ang ESP32 code.
millis ay malawakang ginagamit kung saan kailangan nating magpatakbo ng maraming gawain nang hindi hinaharangan ang natitirang bahagi ng code. Narito ang syntax ng millis function na ginagamit para sa pagkalkula kung gaano katagal ang lumipas upang maisagawa namin ang isang partikular na pagtuturo.
kung ( kasalukuyangMillis - nakaraangMillis > = pagitan ) {nakaraangMillis = kasalukuyangMillis;
}
Ibinabawas ng code na ito ang nakaraang millis() mula sa kasalukuyang millis() kung ang bawas na oras ay katumbas ng pagtukoy sa pagitan ng isang partikular na pagtuturo na isasagawa. Sabihin nating gusto nating mag-blink ng LED sa loob ng 10 segundo. Pagkatapos ng bawat 5 minuto maaari naming itakda ang agwat ng oras na katumbas ng 5 minuto (300000ms). Susuriin ng code ang agwat sa tuwing tatakbo ang code, kapag umabot na ito, kukurap nito ang LED sa loob ng 10 segundo.
Tandaan: Dito kami ay gagamit ng millis() function para sa interfacing ESP32 sa PIR sensor. Ang pangunahing dahilan sa likod ng paggamit ng milli at hindi pagkaantala ay ang millis() function ay hindi hinaharangan ang code gaya ng ginawa ng delay() function. Kaya kapag nakita ng PIR ang paggalaw, magkakaroon ng interrupt. Ang paggamit ng interrupt millis() function ay magti-trigger sa LED para sa tinukoy na oras pagkatapos noon kung ang paggalaw ay huminto millis() function ay magre-reset at maghihintay para sa susunod na interrupt.
Kung sakaling gumamit kami ng delay() function na ganap nitong haharangin ang code at ang anumang interrupt na dulot ay hindi mababasa ng ESP32 na magreresulta sa pagkabigo ng proyekto.
3: Interfacing PIR Sensor sa ESP32
Dito gagamitin namin ang millis() function sa Arduino IDE code dahil gusto naming mag-trigger ng LED sa tuwing may nakitang paggalaw ang PIR sensor. Ang LED na ito ay liliwanag sa loob ng isang takdang oras pagkatapos nito ay babalik ito sa normal na kondisyon.
Narito ang isang listahan ng mga sangkap na kakailanganin namin:
-
- ESP32 development board
- PIR motion sensor (HC-SR501)
- LED
- 330 Ohm risistor
- Pagkonekta ng mga wire
- Breadboard
Schematic para sa PIR sensor na may ESP32:
Ang mga koneksyon sa pin ng ESP32 na may PIR sensor ay:
| ESP32 | PIR Sensor |
| halika | Vcc |
| GPIO13 | LABAS |
| GND | GND |
3.1: PIR Motion Sensor (HC-SR501)
Ang PIR ay isang acronym para sa passive infrared sensor . Gumagamit ito ng isang pares ng pyroelectric sensor na nakakakita ng init sa paligid nito. Ang parehong mga pyroelectric sensor na ito ay magkasunod na namamalagi at kapag ang isang bagay ay pumasok sa kanilang hanay, isang pagbabago sa enerhiya ng init o ang pagkakaiba ng signal sa pagitan ng parehong mga sensor na ito ay nagiging sanhi ng PIR sensor output na maging MABA. Kapag ang PIR out pin ay naging LOW, maaari tayong magtakda ng isang tukoy na pagtuturo na isasagawa.
Ang sumusunod ay ang mga katangian ng PIR sensor:
-
- Maaaring itakda ang sensitivity depende sa lokasyon ng proyekto (tulad ng sensing mouse o leaf movement).
- Ang sensor ng PIR ay maaaring itakda kung gaano katagal ito nakakakita ng isang bagay.
- Malawakang ginagamit sa mga alarma sa seguridad sa bahay at iba pang mga application sa pagtuklas ng paggalaw na nakabatay sa thermal.
3.2: Pinout HC-SR501
Ang PIR HC-SR501 ay may tatlong pin. Dalawa sa mga ito ay power pin para sa Vcc at GND at ang isa ay ang output pin para sa trigger signal.
Ang sumusunod ay ang paglalarawan ng PIR sensor pins:
| Pin | Pangalan | Paglalarawan |
| 1 | Vcc | Input pin para sa sensor Kumonekta sa ESP32 Vin Pin |
| dalawa | LABAS | Output ng Sensor |
| 3 | GND | Sensor GND |
3.3: Code
Ngayon sa programa ng ESP32 isulat ang ibinigay na code sa Arduino IDE editor at i-upload ito sa ESP32.
#define timeSecons 10const int led = 4 ; /* GPIO PIN 4 tinukoy para sa LED */
const int PIR_Out = 13 ; /* GPIO pin 13 para sa PIR out */
unsigned long Current_Time = millis ( ) ; /* tinukoy ang variable para sa pag-iimbak ng mga halaga ng millis */
unsigned long Previous_Trig = 0 ;
boolean Starting_Time = mali ;
void IRAM_ATTR detects Movement ( ) { /* suriin para sa galaw */
Serial.println ( 'NA-DETECTED ANG MOTION' ) ;
digitalWrite ( pinangunahan, MATAAS ) ; /* I-ON ang LED kung kondisyon ay totoo */
Simula_Oras = totoo ;
Nakaraang_Trig = millis ( ) ;
}
walang bisang setup ( ) {
Serial.magsimula ( 115200 ) ; /* baud rate para sa serial na komunikasyon */
pinMode ( PIR_Out, INPUT_PULLUP ) ; /* Tinukoy ang mode ng sensor ng paggalaw ng PIR */
/* Ang PIR ay na-configure sa RISING mode, itakda pin ng sensor ng paggalaw bilang output */
attachInterrupt ( digitalPinToInterrupt ( PIR_Out ) , nakakakita ng Movement, RISING ) ;
pinMode ( pinangunahan, OUTPUT ) ; /* itakda LED sa LOW */
digitalWrite ( pinangunahan, LOW ) ;
}
walang laman na loop ( ) {
Kasalukuyang_Oras = millis ( ) ; /* kasalukuyang tindahan oras */
kung ( Simula_Oras && ( Kasalukuyang_Oras - Nakaraang_Trig > ( timeSecons * 1000 ) ) ) { /* Agwat ng oras pagkatapos alin Ang LED ay patayin */
Serial.println ( 'TUMIGIL ANG MOTION' ) ; /* Huminto ang galaw ng pag-print kung walang nakitang paggalaw */
digitalWrite ( humantong, LOW ) ; /* Itakda ang LED sa LOW kung kondisyon ay mali */
Simula_Oras = mali ;
}
}
Nagsimula ang code sa pamamagitan ng pagtukoy sa mga GPIO pin para sa output ng LED at PIR. Susunod, gumawa kami ng tatlong magkakaibang variable na makakatulong upang i-on ang LED kapag nakita ang paggalaw.
Ang tatlong Variable na ito ay Kasalukuyang_Oras, Nakaraang_Trig, at Simula_Oras. Ang mga variable na ito ay mag-iimbak ng kasalukuyang oras, oras kung kailan natukoy ang paggalaw at ang timer pagkatapos matukoy ang paggalaw.
Sa unang bahagi ng pag-setup, tinukoy namin ang serial baud rate para sa komunikasyon. Susunod na paggamit pinMode() itakda ang PIR motion sensor bilang INPUT PULLUP. Upang itakda ang PIR interrupt attachInterrupt() ay inilarawan. Ang GPIO 13 ay inilarawan upang makita ang paggalaw sa RISING mode.
Susunod sa loop() na bahagi ng code, gamit ang millis() function na I-ON at OFF namin ang LED kapag nakamit ang isang trigger.
3.4: Output
Sa seksyon ng output makikita natin ang bagay na wala sa saklaw ng sensor ng PIR, kaya ang LED ay nakabukas NAKA-OFF .
Ngayon ang paggalaw na nakita ng PIR sensor LED ay liliko NAKA-ON para sa 10 sec pagkatapos nito kung walang nakitang paggalaw ay mananatili ito NAKA-OFF hanggang sa matanggap ang susunod na trigger.
Ang sumusunod na output ay ipinapakita ng serial monitor sa Arduino IDE.
Konklusyon
Ang isang PIR sensor na may ESP32 ay makakatulong upang makita ang paggalaw ng mga bagay na dumadaan sa saklaw nito. Gamit ang interrupt function sa ESP32 programming maaari tayong mag-trigger ng tugon sa ilang partikular na GPIO pin. Kapag natukoy ang pagbabago, ang interrupt function ay ma-trigger at ang isang LED ay mag-o-ON.