Ang Arduino ay nakakagambala sa tutorial

Ang mga pagkagambala ay isang malakas na tampok ng mga microcontroller na nagbibigay -daan sa iyo upang mahawakan ang mga kaganapan nang hindi sinasadya. Hindi tulad ng botohan, na patuloy na sinusuri para sa mga kaganapan, ang mga pagkagambala ay tumugon kaagad kapag naganap ang isang tukoy na kaganapan, tulad ng isang pindutan ng pindutan o isang pag -apaw ng timer. Ang tutorial na ito ay gagabay sa iyo sa pamamagitan ng pag -unawa at paggamit ng mga pagkagambala kay Arduino.

Ano ang kakailanganin mo

Arduino uno (o isang katugmang board)
Pindutan ng push
10k-ohm risistor (para sa pull-down na pagsasaayos)
LED at 220-OHM risistor (opsyonal)
Mga wire ng tinapay at jumper
Ang Arduino IDE ay naka -install sa iyong computer

Hakbang 1: Ano ang mga pagkagambala?

Ang isang nakakagambala ay pansamantalang ihinto ang pagpapatupad ng pangunahing programa upang mahawakan ang isang tiyak na kaganapan. Kapag naproseso ang kaganapan, ang programa ay magpapatuloy kung saan ito tumigil. Ang mga pagkagambala ay pinamamahalaan gamit ang mga espesyal na pag -andar na tinatawag Matakpan ang mga gawain sa serbisyo (ISR).

Mga uri ng mga pagkagambala sa Arduino

Panlabas na pagkagambala: Na -trigger ng mga kaganapan sa mga tiyak na pin (hal., Pin 2 o 3 sa Arduino uno).
Nag -abala ang PIN Change: Na -trigger ng isang pagbabago sa anumang digital pin.
Nagagambala ang Timer: Na -trigger ng mga overflows ng timer o ihambing ang mga tugma.

Hakbang 2: Paggamit ng mga panlabas na pagkagambala

Sinusuportahan ng Arduino Uno ang mga panlabas na pagkagambala sa mga pin 2 at 3. Maaari mong i -configure ang mga nakakagambala na ito upang mag -trigger sa:

Tumataas: Ang signal ay pupunta mula sa mababa hanggang mataas.
Pagbagsak: Ang signal ay napupunta mula sa mataas hanggang mababa.
Baguhin: Ang mga pagbabago sa signal ay estado (mababa hanggang mataas o mataas hanggang mababa).
Mababa: Ang signal ay nananatiling mababa.

Halimbawa ng code: Pag -alis ng pindutin ng pindutan

Ang halimbawang ito ay toggles isang LED kapag ang isang pindutan na konektado sa pin 2 ay pinindot.

#define buttonPin 2 // Interrupt pin
#define ledPin 13   // Built-in LED

volatile bool ledState = false; // Shared variable between ISR and main code

void handleInterrupt() {
  ledState = !ledState; // Toggle LED state
  digitalWrite(ledPin, ledState);
}

void setup() {
  pinMode(buttonPin, INPUT_PULLUP); // Enable internal pull-up resistor
  pinMode(ledPin, OUTPUT);

  attachInterrupt(digitalPinToInterrupt(buttonPin), handleInterrupt, FALLING); // Trigger on button press
}

void loop() {
  // Main loop does nothing; interrupt handles the LED
}

Paliwanag

attachInterrupt(digitalPinToInterrupt(pin), ISR, mode): I -configure ang makagambala.
- pin: Ang nakakagambalang pin (hal., Pin 2 o 3 sa Arduino uno).
- ISR: Ang nakagambala na gawain sa serbisyo upang maisagawa.
- mode: Ang kondisyon ng pag -trigger (RISING, FALLING, CHANGE, o LOW).
digitalPinToInterrupt(pin): Nag -convert ng isang numero ng PIN sa nakakagambalang numero nito.

Hakbang 3: Ang paggamit ng pagbabago ng PIN ay nakakagambala

Pinapayagan ka ng mga pagbabago sa PIN na makita ang mga pagbabago sa anumang digital pin. Nangangailangan ito ng mga karagdagang aklatan, tulad ng Paganahin.

Halimbawa Code: Makagambala ang pagbabago ng PIN

#include <EnableInterrupt.h>
#define pin 4 // Pin to monitor

void handlePinChange() {
  Serial.println("Pin state changed!");
}

void setup() {
  Serial.begin(9600);
  enableInterrupt(pin, handlePinChange, CHANGE); // Trigger on any state change
}

void loop() {
  // Main loop does nothing; interrupt handles the event
}

Pag -install ng Library

Upang magamit ang mga pagbabago sa pagbabago ng PIN, i -install ang Paganahin Library sa pamamagitan ng Arduino Library Manager.

Hakbang 4: Nag -abala ang Timer

Ang mga pagkagambala sa Timer ay kapaki -pakinabang para sa pag -iskedyul ng mga gawain sa tumpak na agwat. Sumangguni sa Arduino Timer Tutorial Para sa mga detalye sa pag -configure ng mga pagkagambala sa timer.

Halimbawa: kumikislap ng isang LED na may makagambala sa Timer1

#define ledPin 13

void setup() {
  pinMode(ledPin, OUTPUT);

  // Configure Timer1
  noInterrupts(); // Disable interrupts during setup
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1 = 0;

  OCR1A = 15624; // Compare match value for 1Hz (1-second interval)
  TCCR1B |= (1 << WGM12); // CTC mode
  TCCR1B |= (1 << CS12) | (1 << CS10); // 1024 prescaler
  TIMSK1 |= (1 << OCIE1A); // Enable Timer1 compare interrupt

  interrupts(); // Enable interrupts
}

ISR(TIMER1_COMPA_vect) {
  digitalWrite(ledPin, !digitalRead(ledPin)); // Toggle LED
}

void loop() {
  // Main loop does nothing; Timer1 handles the LED
}

Hakbang 5: Pinakamahusay na kasanayan para sa paggamit ng mga pagkagambala

Panatilihing maikli ang ISRS: Iwasan ang mga pagkaantala o kumplikadong mga kalkulasyon sa mga ISR upang matiyak ang mabilis na tugon.
Iwasan ang serial na komunikasyon sa ISRS: Ang mga serial function ay maaaring hindi gumana nang maaasahan sa loob ng isang ISR.
Gumamit volatile Para sa mga ibinahaging variable: Mark variable na ibinahagi sa pagitan ng ISRS at ang pangunahing programa bilang volatile Upang maiwasan ang mga isyu sa pag -optimize ng compiler.
Debounce input: Pangasiwaan ang debounce logic sa software o hardware para sa maingay na mga signal tulad ng mga pindutan ng pindutan.
Huwag paganahin ang mga pagkagambala sa panahon ng mga kritikal na seksyon: Gumamit noInterrupts() at interrupts() Upang maprotektahan ang mga seksyon ng kritikal na code.

Mga aplikasyon ng mga pagkagambala

Ang pagpindot sa pindutan ng pagpindot nang walang botohan
Pagbasa ng mga rotary encoder
Timing Kritikal na Kaganapan (hal., Tumpak na kontrol sa motor)
Pag -iskedyul ng mga pana -panahong gawain
Reaksyon sa mga panlabas na signal (hal., Sensor, mga kaganapan sa komunikasyon)

Pag -aayos

Makagambala hindi nag -trigger: Tiyakin na ang tamang pin at mode ay na -configure.
Hindi matatag na pag -uugali: Debounce maingay na mga signal at maiwasan ang mga mahahabang ISR.
Mga salungatan sa mga aklatan: Ang ilang mga aklatan ay gumagamit ng mga nakakagambala sa loob (hal., Servo, PWM). Tiyakin na walang salungatan sa iyong code.

Konklusyon

Ang mga pagkagambala ay nagbibigay -daan sa tumutugon at mahusay na paghawak ng mga kaganapan sa mga proyekto ng Arduino. Sa pamamagitan ng pag -aaral na gumamit ng panlabas, pagbabago ng PIN, at pagkagambala ng timer, maaari kang lumikha ng matatag at tumpak na mga aplikasyon. Eksperimento sa iba't ibang uri ng mga pagkagambala upang mapahusay ang iyong mga proyekto at ma -optimize ang pagganap!