Przerwania

Najpierw w rejestrze MCUCR (ang. Micro Controler Unit Control Register - rejestr sterujący jednostką mikrokontrolera) ustawiamy sposób generacji przerwania przez linię INT0.

Do tego celu przeznaczone są dwa bity ISC1 i ISC0 (ang. Interrupt Sense Control – sterowanie sposobem wykrywania przerwania). Mogą one przybrać jedną z czterech kombinacji wartości:

Gdy określimy sposób generowania przerwania w zależności od stanu linii INT0, musimy uaktywnić przerwanie przez ustawienie na 1 bitu INT0 w rejestrze GIMSK (ang. General Interrupt Mask Register – rejestr maskowania przerwań zewnętrznych).

Ostatnią rzeczą pozostaje włączenie przerwań za pomocą funkcji sei().

Poniższy program umożliwi ci pobawienie się z przerwaniem INT. Podłącz do płytki bazowej płytkę aplikacyjną APP001 i ustaw zworkę J1 w położeniu dolnym. W ten sposób do linii PB1 będzie dołączony przycisk W1 z płytki. Za pomocą tego przycisku możesz zmieniać stan linii PB1, czyli INT0. gdy przycisk nie jest naciśniety, na linii INT0 mamy stan logiczny 1. Gdy przycisk naciśniesz, stan ten zmieni się na 0.

/*
 * main.c
 *
 *  Created on: 7 lut 2016
 *      Author: Jerzy
 *  Opis:
 *  obsługuje naciśnięcie przycisku W1 za pomocą przerwania INT0.
 *  Przy każdym naciśnięciu zapala się lub gaśnie dioda D0.
 *  Konfiguracja jumperów:
 *  J0: góra
 *  J1: dół
 */

#include <avr/interrupt.h>
#include <avr/delay.h>

// Obsługa przerwania INT0
ISR(INT0_vect)
{
    PORTB ^= 1;    // zmieniamy stan diody D0 na przeciwny
    _delay_ms(10); // czekamy na wygaśnięcie drgań styków
}

int main(void)
{
    uint8_t licznik = 0;

    cli();    // na wszelki wypadek blokujemy przyjmowanie przerwań
    MCUCR = (MCUCR & 0b1111100) | 0b10; // przerwanie przy zmianie INT0 1->0
    GIMSK |= (1<<INT0); // Uaktywniamy przerwanie INT0
    DDRB  = 0b11101;    // Linie PB4..PB2 i PB0 jako wyjścia
    PORTB = 0b00010;    // Do PB1 opornik podciągający
    sei();   // odblokowujemy przyjmowanie przerwań
    while(1)
    {
        _delay_ms(50);
        licznik++;
        PORTB = (licznik & 0b11100) | (PORTB & 0b00001)|0b10;
    }
}

W programie ustawiamy obsługę przerwań INT0 przy zmianie stanu linii PB1 z 1 na 0, co odpowiada naciśnięciu przycisku. Program główny w pętli zlicza obiegi co 50 ms w zmiennej licznik. Następnie do portu B są przesyłane 3 górne bity licznika i sterują one diodami D2...D4. Przycisk W1 jest obsługiwany niezależnie przez przerwanie INT0. W momencie naciśnięcia tego przycisku zmienia się stan linii PB1 (INT0) z 1 na 0 i następuje wygenerowanie przerwania. W procedurze obsługi mikrokontroler zapala lub gasi diodę D0. W programie nie obsługujemy drgań styków, dlatego czasami reakcja na przycisk nie jest prawidłowa. To cena prostoty. W praktycznych projektach musisz jednak pamiętać o tym niekorzystnym zjawisku i wprowadzać odpowiednie opóźnienia przy odczycie stanu przycisków mechanicznych.

Poeksperymentuj w tym programie z innymi ustawieniami bitów ISC1 i ISC2 w porcie MCUCR.

Uwaga. Przerwanie INT0 jest generowane bez względu na to czy linia PB1 pracuje jako wejście, czy jako wyjście danych. Jeśli ustawimy ją jako wyjście, to mikrokontroler poprzez zmianę jej stanu będzie mógł programowo generować przerwanie INT0. To samo dotyczy opisanego dalej przerwania PCINT.

Po określeniu końcówek mikrokontrolera generujących przerwanie PCINT należy włączyć to przerwanie przez ustawienie na 1 bitu PCIE (ang. Pin Change Interrupt Enable – włączenie przerwań zmiany stanu końcówek).

Na koniec włączamy obsługę przerwań przez wywołanie funkcji sei().

Do płytki bazowej podłącz płytkę aplikacyjną APP001 i ustaw obie zworki w dół. W ten sposób do linii PB0 i PB1 zostaną podłączone przyciski, którymi będziesz mógł zmieniać stan tych linii.

/*
 * main.c
 *
 *  Created on: 7 lut 2016
 *      Author: Jerzy
 *  Opis:
 *  Program jest przykładem wykorzystania przerwań zewnętrznych PCINT.
 *  Na diodach D2...D4 jest przesuwany punkt świetlny. Przyciski
 *  W0 i W1 są obsługiwane przez przerwanie PCINT i sterują kierunkiem
 *  przesuwania punktu świetlnego.
 *  J0: dół
 *  J1: dół
 */

#include <avr/interrupt.h>
#include <avr/delay.h>

// Określa kierunek przesuwania punktu
volatile uint8_t dir = 1;

// Obsługa przerwania PCINT
ISR(PCINT0_vect)
{
    if(!(PINB & 0b01)) dir = 0; // Wciśnięty W0
    else
    if(!(PINB & 0b10)) dir = 1; // Wciśnięty W1
}

int main(void)
{
    uint8_t shft = 1;
    cli();    // na wszelki wypadek blokujemy przyjmowanie przerwań
    PCMSK  = 0b000011;  // Przerwanie przy zmianie PB0 i PB1
    GIMSK  = (1<<PCIE); // Uaktywniamy przerwanie PCINT
    DDRB   = 0b11100;   // Linie PB4..PB2 jako wyjścia
    PORTB  = 0b00011;   // Do PB0 i PB1 oporniki podciągające
    sei();   // odblokowujemy przyjmowanie przerwań
    while(1)
    {
        _delay_ms(200);
        if(dir)
        {
            shft <<= 1;
            if(shft == 0b1000) shft = 1;
        }
        else
        {
            shft >>= 1;
            if(!shft) shft = 0b100;
        }
        PORTB = (shft << 2) | 0b11;
    }
}

Program cyklicznie przesuwa punkt świetlny na diodach D2...D4. Przyciski W0 i W1 sterują kierunkiem tego przesuwu. Ich naciśnięcie powoduje wygenerowanie przerwania PCINT. W procedurze obsługi tego przerwania sprawdzamy, który przycisk został naciśniety i odpowiednio ustawiamy zmienną dir, która steruje kierunkiem przesuwu punktu świetlnego. Przyciski można naciskać w dowolnej chwili.

Nowością jest utworzenie zmiennej dir z dyrektywą volatile. Dyrektywa ta jest informacja dla kompilatora, że zawartość zmiennej może się zmieniać w dowolnej chwili i nie należy jej buforować w programie, co kompilator często robi w celu zwiększenia szybkości działania kodu. Jeśli przed definicją zmiennej umieścimy dyrektywę volatile, to program będzie zawsze pobierał zawartość tej zmiennej z pamięci i nie będzie jej sobie zapamiętywał w tymczasowym miejscu. Jest to konieczne, ponieważ zmienną tą zmienia procedura przerwania PCINT w nieprzewidywalnym momencie. Spróbuj uruchomić ten program bez tej dyrektywy, a przestanie on poprawnie działać.

Z przerwaniami INT i PCINT związany jest jeszcze rejestr znaczników przerwań GIFR (ang. General Interrupt Flag Register).

Jak widzisz, ma on podobną budowę do rejestru GIMSK, który maskuje (tzn. uaktywnia lub blokuje) przerwania INT i PCINT na tych samych bitach. Bity INTF0 i PCIF zostają ustawione na 1, gdy wystąpi warunek przerwania INT lub PCINT. Jeśli zostanie przy tym wywołana procedura ISR danego przerwania, to odpowiedni bit rejestru znaczników przerwań zostanie automatycznie wyzerowany. Można też wyzerować dany bit wpisując do niego 1 (nie zero! jak w zwykłych rejestrach). Rejestr ten może czasem być użyteczny, gdy jedna procedura przerwań chce sprawdzić, czy wystąpiło inne przerwanie. Normalnie nie musisz z niego korzystać.

Przerwanie przepełnienia licznika TIM0_OVF powstaje, gdy zostanie ustawiony na 1 znacznik TOV0 w rejestrze TIFR0 (ang. Timer/Counter Interrupt Flag Register – rejestr znaczników przerwań licznika).

Znaczniki w tym rejestrze mogą być zerowane programowo przez wpisanie do odpowiedniego bitu 1 (nie zero!). Po przyjęciu przerwania odpowiedni znacznik jest automatycznie zerowany (nie musisz tego specjalnie robić w swojej procedurze ISR).

Znacznik TOV0 jest ustawiany zależnie od trybu pracy licznika, który ustawiamy bitami WGMx w rejestrach sterujących licznika TCCR0A i TCCR0B:

Reguły ustawiania znacznika TOV0, a zatem również generowania przerwania, są następujące:

Zatem, aby wygenerować przerwanie od licznika TCNT0, należy najpierw ustawić pożądany tryb pracy tego licznika (omówiliśmy te tryby w poprzednim rozdziale), a następnie włączyć przerwania od licznika ustawiając na 1 bit TOIE0 w rejestrze maskowania przerwań licznika TIMSK0:

Na koniec uaktywniamy reagowanie na przerwania przez wywołanie funkcji sei().

Do płytki bazowej dołącz płytkę aplikacyjną APP001 i ustaw pierwszą zworkę w dół, aby do linii PB0 był dołączony przycisk W0. Następnie prześlij do mikrokontrolera poniższy program:

/*
 * main.c
 *
 *  Created on: 7 lut 2016
 *      Author: Jerzy
 *  Opis:
 *  Program jest przykładem wykorzystania przerwania wewnętrznego od
 *  przepełnienia licznika. W procedurze obsługi przerwania przesuwane są
 *  w lewo bity portu B. Bit PB0 pochodzi z wejścia i jest negowany przed
 *  wykonaniem przesunięcia. W efekcie każde naciśnięcie przycisku zapala
 *  kolejne diody D1...D4. Zwolnienie przycisku kolejno je gasi.
 *  Konfiguracja jumperów:
 *  J0: dół
 *  J1: góra
 */

#include <avr/interrupt.h>

// Obsługa przerwania TIM0_OVF
ISR(TIM0_OVF_vect)
{
    PORTB = ((PINB ^ 1) << 1) | 1;
}

int main(void)
{
    cli();                // na wszelki wypadek blokujemy przyjmowanie przerwań
    DDRB   = 0b11110;     // Linie PB1..PB4 jako wyjścia
    PORTB  = 0b00001;     // Do PB0 opornik podciągający
    TCCR0B = 0b100;       // 3906,25 Hz -> do licznika, tryb normalny
    TIMSK0 |= (1<<TOIE0); // uaktywniamy przerwania od przepełnienia licznika
    sei();                // odblokowujemy przyjmowanie przerwań
    while(1);             // W pętli nic nie robimy
}

Przerwania od licznika są często wykorzystywane w celu okresowego wykonywania określonej procedury. Tak właśnie działa powyższy program. Do licznika trafiają impulsy zegarowe z preskalera ustawionego na dzielenie częstotliwości zegara 1MHz przez 256. Daje to częstotliwość około 3906 Hz. Gdy licznik zliczy 256 takich impulsów, nastąpi przepełnienie i zostanie wygenerowane przerwanie TIM0_OVF. W procedurze obsługi tego przerwania odczytujemy stan portu B, negujemy bit BP0, który pochodzi od przycisku, przesuwamy wszystkie bity o 1 w lewo i zapisujemy je do portu PORTB. Ostatni bit jest zawsze ustawiany na 1, aby do przycisku był podłączony opornik podciągający, inaczej wejście PB0 będzie zbierało zakłócenia z okolicy. Sprawdź, co się będzie działo, jeśli ten bit nie będzie ustawiany na 1, tzn. w procedurze obsługi przerwania zmień instrukcję na:

PORTB = ((PINB ^ 1) << 1);