Pinutol ng Arduino ang tutorial

Isaalang-alang ang isang mabilis na gumagalaw na kotse, kung bigla itong na-hit ng isa pang kotse sa kabaligtaran ng direksyon, ang unang bagay na nangyari ay iyon, ang sensor ng accelerometer na naroroon sa kotse ay nakakaramdam ng isang biglaang de-acceleration at nagpapalitaw ng isang panlabas na makagambala sa microcontroller na naroroon ang kotse. Pagkatapos ay batay sa makagambala na ang microcontroller ay gumagawa ng isang electric signal upang i-deploy kaagad ang mga airbag. Ang mga microcontroller na naroroon sa kotse ay sinusubaybayan ang maraming bagay nang sabay-sabay tulad ng pakiramdam ng bilis ng kotse, pag-check sa iba pang mga sensor, pagkontrol sa temperatura ng air conditioner atbp. Kaya't ano ang biglaang pagbubukas ng isang airbag sa ilang segundo? Ang sagot ay nakakagambala, ginagamit ang isang nakakagambalang signal dito na may pinakamataas na priyoridad sa lahat.

Ang isa pang simpleng halimbawa ng Mga Nakagambala ay ang mga touch screen na mobile phone na may pinakamataas na priyoridad sa "Touch" na kahulugan. Halos bawat elektronikong aparato ay may ilang uri upang makagambala upang 'makagambala' sa regular na proseso at gumawa ng ilang mas mataas na pangunahing bagay na bagay sa isang partikular na kaganapan. Ipinagpatuloy ang regular na proseso pagkatapos ihatid ang Nakagambala.

Kaya't ayon sa teknikal, ang Mga Nakagagambala ay isang mekanismo kung saan maaaring suspindihin ng isang I / O o tagubilin ang normal na pagpapatupad ng processor at masisilbi ang sarili tulad ng mas mataas ang priyoridad. Halimbawa, ang isang processor na gumagawa ng isang normal na pagpapatupad ay maaaring magambala ng ilang sensor upang magpatupad ng isang partikular na proseso na naroroon sa ISR (Nakagambala sa Rutin ng Serbisyo). Matapos maipatupad ang ISR processor ay maaaring muling ipagpatuloy ang normal na pagpapatupad.

Mga Uri ng Pagkagambala

Mayroong dalawang uri ng mga nakakagambala:

Nakagambala ang Hardware: Ito ay nangyayari kapag ang isang panlabas na kaganapan ay nagaganap tulad ng isang panlabas na makagambala na pin na binago ang estado nito mula sa LOW to HIGH o HIGH sa LOW.

Nakagambala ang Software: Nangyayari ito ayon sa tagubilin mula sa software. Halimbawa Ang mga nakakagambala na timer ay nakakagambala ng software.

Nakagambala sa Arduino

Ngayon makikita natin kung paano gumamit ng mga nakakagambala sa Arduino Board. Mayroon itong dalawang uri ng mga nakakagambala:

• Panlabas na Makagambala
• Pin Baguhin ang Makagambala

Panlabas na Makagambala:

Ang mga nakakagambala na ito ay binibigyang kahulugan ng hardware at napakabilis. Ang mga pagkakagambala na ito ay maaaring itakda upang mag-trigger sa kaganapan ng RISING o FALLING o Mababang antas.

Lupon ng Arduino	Panlabas na makagambala na mga pin:
UNO, NANO	2,3
Mega	2,3,18,19,20,21

Pinagpagambala ang Pagbabago ng Pin:

Ang Arduinos ay maaaring magkaroon ng mas maraming mga nakakagambala na mga pin na pinagana sa pamamagitan ng paggamit ng mga interrupt ng pagbabago ng pin. Sa ATmega168 / 328 batay sa Arduino boards anumang mga pin o lahat ng 20 signal pin ay maaaring magamit bilang makagambala na mga pin. Maaari din silang mai-trigger gamit ang RISING o FALLING edge.

Paggamit ng Mga Nakagambala sa Arduino

Upang magamit ang mga pagkagambala sa Arduino ang mga sumusunod na konsepto ay kailangang maunawaan.

Makagambala sa Rutin ng Serbisyo (ISR)

Makagambala sa Rutin ng Serbisyo o isang Interrupt handler ay isang kaganapan na mayroong maliit na hanay ng mga tagubilin dito. Kapag nangyari ang isang panlabas na pagkagambala, unang isinasagawa ng processor ang code na ito na naroroon sa ISR at babalik sa estado kung saan iniwan ang normal na pagpapatupad.

Ang ISR ay sumusunod sa syntax sa Arduino:

attachInterrupt (digitalPinToInterrupt (pin), ISR, mode);

digitalPinToInterrupt (pin): Sa Arduino Uno, NANO ang mga pin na ginamit para makagambala ay 2,3 at sa mega 2,3,18,19,20,21. Tukuyin ang input pin na ginagamit para sa panlabas na makagambala dito.

ISR: Ito ay isang pagpapaandar na tinatawag kapag tapos na ang isang panlabas na pagkagambala.

Mode: Uri ng paglipat upang mag-trigger, hal. Pagbagsak, pagtaas, atbp.

• RISING: Upang mag-trigger ng isang nakakagambala kapag ang pin ay naglilipat mula LOW to HIGH.
• FALLING: Upang mag-trigger ng isang nakakagambala kapag ang pin ay lumilipat mula sa Mataas hanggang sa LOW.
• PAGBABAGO: Upang magpalitaw ng isang nakakagambala kapag ang pin ay naglilipat mula sa LOW to HIGH o HIGH sa LOW (ibig sabihin, kapag nagbago ang estado ng pin).

Ang ilang mga Kundisyon habang gumagamit ng Nakagambala

• Makagambala sa pagpapaandar sa Karaniwang Serbisyo (ISR) ay dapat na maikli hangga't maaari.
• Ang pagka-antala () ay hindi gumagana sa loob ng ISR at dapat na iwasan.

Sa Arduino Interrupt tutorial na ito, ang isang numero ay nadagdagan mula sa 0 at dalawang push button ang ginagamit upang ma-trigger ang Interrupt, ang bawat isa ay konektado sa D2 & D3. Ginagamit ang isang LED upang ipahiwatig ang Makagambala. Kung ang isang push button ay pinindot ang led led ON at ang display ay nagpapakita ng interrupt2 at papatay, at kapag ang isa pang push button ay pinindot ang led ay OFF at ang display ay nagpapakita ng interrupt1 at off.

Kinakailangan ang Mga Bahagi

• Lupon ng Arduino (Sa tutorial na ito ay ginagamit ang Arduino NANO)
• Button ng push - 2
• LED - 1
• Resistor (10K) - 2
• LCD (16x2) - 1
• Lupon ng Tinapay
• Mga Koneksyon sa Mga Wires

Diagram ng Circuit

Koneksyon ng Circuit sa pagitan ng Arduino Nano at 16x2 LCD display:

LCD	Arduino Nano
VSS	GND
VDD	+ 5V
V0	Sa Potentiometer Center PIN Para sa Pagkontrol ng Contrast ng LCD
Ang RS	D7
RW	GND
E	D8
D4	D9
D5	D10
D6	D11
D7	D12
A	+ 5V
K	GND

Dalawang pindutan ng push ang nakakonekta sa Arduino Nano sa pin D2 & D3. Ginagamit ang mga ito para sa paggamit ng dalawang panlabas na pagkagambala, isa para sa pag-ON ng LED at isa pa para i-OFF ang isang LED. Ang bawat pindutan ng push ay may isang pull down risistor ng 10k na konektado sa lupa. Kaya't kapag pinindot ang pindutan ng itulak ay lohika ang TAAS (1) at kapag hindi pinindot ito ay lohong LOW (0). Ang isang hilahin na risistor ay sapilitan kung hindi man ay may mga lumulutang na halaga sa input pin na D2 & D3.

Ginagamit din ang isang LED upang ipahiwatig na ang isang Nakagambala ay na-trigger o ang isang pindutan ay pinindot.

Nakagambala sa Programming ng Arduino

Sa tutorial na ito ang isang numero ay nadagdagan mula sa 0 na patuloy na ipinapakita sa (16x2) LCD na konektado sa Arduino Nano, tuwing ang kaliwang pindutan ng itulak (makagambala ang pin D3) ay pinindot ang LED ay ON at ipinapakita ang display Interrupt2, at kapag ang tamang pindutan ng push (makagambala pin D2) ay pinindot ang LED napupunta OFF at ipinapakita ang nagpapakita ng Interrupt1.

Ang kumpletong Code na may gumaganang video ay ibinibigay sa pagtatapos ng tutorial na ito.

1. Una ang header file para sa LCD display ay kasama at pagkatapos ang mga LCD pin na ginamit sa pagkonekta sa Arduino Nano ay tinukoy.

# isama LiquidCrystal lcd (7,8,9,10,11,12); // Tukuyin ang mga pin na display sa LCD na RS, E, D4, D5, D6, D7

2. Sa loob ng function na void setup (), ipakita muna ang ilang intro message sa LCD display. Dagdagan ang nalalaman tungkol sa interfacing LCD sa Arduino dito.

lcd.begin (16,2); lcd.setCursor (0,0); lcd.print ("CIRCUIT DIGEST"); lcd.setCursor (0,1); lcd.print ("ArduinoInterrupt"); pagkaantala (3000); lcd.clear ();

3. Pagkatapos sa parehong walang bisa na pag-setup () na pag-andar ang input at output pin ay dapat na tinukoy. Ang pin D13 ay konektado sa LED's Anode, kaya't ang pin na ito ay dapat na tinukoy bilang output.

pinMode (13, OUTPUT);

4. Ngayon ang pangunahing mahalagang bahagi sa pag-program ay dumating na ang function na attachInterrupt (), kasama rin ito sa loob ng void setup ().

attachInterrupt (digitalPinToInterrupt (2), buttonPressed1, RISING); attachInterrupt (digitalPinToInterrupt (3), buttonPressed2, RISING);

Narito tinukoy na ang pin 2 ay para sa panlabas na makagambala , at ang pindutan ng buttonPressed1 ay tinatawag na kapag may RISING (LOW to HIGH) sa D2 pin. At ang pin 3 ay para din sa panlabas na makagambala at ang pindutan ng buttonPressed2 ay tinawag kapag mayroong RISING sa D3 pin.

5. Sa loob ng void loop (), isang numero (i) ay nadagdagan mula sa zero at naka-print sa LCD (16x2).

lcd.clear (); lcd.print ("COUNTER:"); lcd.print (i); ++ i; pagkaantala (1000);

Sa parehong void loop (), ang digitalWrite () ay ginagamit sa pin D13 kung saan nakakonekta ang anode ng LED. Nakasalalay sa halaga sa variable output LED ay magbubukas o papatayin

digitalWrite (13, output);

6. Ang pinakamahalagang bahagi ay ang paglikha ng isang nakakaabala na pagpapaandar ng handler ayon sa pangalan na ginamit sa pag- andar ng attachInterrupt () .

Tulad ng dalawang nakakagambala na pin ay ginagamit 2 at 3 kaya't dalawang ISR ang kinakailangan. Dito sa programang ito ang pagsunod sa ISR ay ginagamit

buttonPressed1 ():

void buttonPressed1 () { output = LOW; lcd.setCursor (0,1); lcd.print ("Makagambala 1"); }

Ang pagpapaandar na ito ay naisasagawa kapag ang pindutan ng push sa pin D2 ay pinindot (RISING EDGE). Binabago ng pagpapaandar na ito ang estado ng output sa LOW na sanhi ng LED upang i-OFF at i-print ang "interrupt1" sa LCD display.

buttonPressed2 ():

void buttonPressed2 () {output = MATAAS; lcd.setCursor (0,1); lcd.print ("Makagambala2"); }

Ang pagpapaandar na ito ay naisasagawa kapag ang pindutan ng push sa pin D3 ay pinindot. Ang pagpapaandar na ito ay binabago ang estado ng output sa TAAS na sanhi ng LED upang i-ON at i-print ang "makagambala2" sa LCD display.

Nakagambala na Demonstrasyon ng Arduino

1. Kapag ang PUSH BUTTON sa leftside ay pinindot ang LED ay ON at ang LCD ay nagpapakita ng Interrupt2.

2. Kapag ang PUSH BUTTON sa kanang bahagi ay pinindot ang LED ay OFF at ang LCD ay nagpapakita ng Interrupt1

Ito ay kung paano maaaring maging kapaki-pakinabang ang isang Nakagambala upang ma-trigger ang anumang mahalagang gawain sa pagitan ng normal na pagpapatupad.