LED sterowany przez Timer

Autor: drzasiek
Redakcja: dondu


Drzaśkowy pamiętnik: Spis treści

Jak do tej pory, uruchomiłem już sobie pierwszy układ, napisałem kilka prostych programów, które jak na razie nie robią nic, prócz mrugania diodami.

Nie po to jednak wymyślono mikrokontrolery i nie po to również ja sam zapragnąłem nauczyć się z nimi „rozmawiać”, żeby używać je tylko i wyłącznie do tak prostych operacji.

Układ z mikroprocesorem (CPU) ma przede wszystkim liczyć a pośrednio analizować, obrabiać, pobierać, wysyłać dane, mierzyć itd. Zdecydowana większość tych operacji nie jest deterministyczna. Zrodziło się więc pytanie:

Jak odmierzać czas jeśli CPU zajęty jest innymi, czasochłonnymi operacjami?

No więc tu trzeba było się trochę zagłębić, poszukać, poczytać artykuły, forum, dokumentację procesora. Timer - to jest to odpowiedź na moje pytanie. :-)


W mikrokontrolerach można spotkać timery 8 lub 16 bitowe. To wewnętrzne układy liczące impulsy, który niezależnie od działającego programu zliczają impulsy lub odliczają dokładnie (w zależności od dokładności wybranego źródła sygnału zegarowego dla timera) czas.

Timer zastosować chciałem do sterowania dwoma diodami LED. Układ ten sam, którego schemat znajduje się w poprzedniej części mojego pamiętnika:

Szukając na forum znalazłem kilka przykładów jak uruchomić timer. Jednak z samych przykładów, komentowanych nieraz w mało zrozumiałe formułki niewiele można się dowiedzieć.

Dlatego moim sposobem na zrozumienie działania programu oraz następnie dostosowanie go do swoich potrzeb jest poszukanie przykładowego programu, a następnie analizowanie go krok po kroku z dokumentacją mikrokontrolera.


W przypadku mikrokontrolera ATmega8 jest on wyposażony w trzy timery - dwa 8-bitowe i jeden 16-bitowy.





Zainteresowałem się 8-bitowym układem „Timer/Counter0”:

Nieodzownym elementem większości timerów jest preskaler czyli dzielnik sygnału zegarowego taktującym timer. W przypadku Timer0 w Atmega8 preskaler jest połączony z preskalerem Timer1:

Dlatego mnie interesuje ta część układu preskalera zaznaczona na czerwono

Za pomocą fusebitów ustawionych fabrycznie na wewnętrzny generator RC o częstotliwości 1MHz, sygnał ten jest jednocześnie sygnałem clki/o taktującym preskaler timera (patrz rysunek powyżej). Mam do wyboru dzielniki preskalera o wartościach 8, 64, 256 i 1024. Mogę wybrać jeden z dzielników, który będzie dzielił częstotliwość wejściową preskalera przez wybraną wartość. Zdecydowałem się na 1024, co daje:

Czyli z preskalera impulsy na Timer0 będą wychodzić z częstotliwością około 1000Hz, co daje mi czas jednego impulsu równy:

Przerwania
Zanim napisałem dalszą część, musiałem się dowiedzieć: Co to jest przerwanie?
Znalazłem więc na Wikipedii: Przerwanie
Czyli przerwanie to sygnał, który powoduje przerwanie wykonywania programu przez procesor i przejście do wykonywania programu obsługi danego przerwania, a po jego zakończeniu powrót do przerwanego programu.

Timer0 jest timerem 8-bitowym liczącym od 0 do 255, i potrafi generować przerwanie w przypadku jego przepełnienia. Czyli przerwanie z przepełnienia Timer0 będzie się pojawiać co:

czyli około 4 razy na sekundę:

Zacząłem więc pisać mój program.
Najpierw wybrałem źródło taktowania Timer0 oraz preskaler, a następnie włączyłem przerwania od przepełnienia Timer0:

TCCR0 |= (1<<CS02) | (1<<CS00); // źródłem CLK, preskaler 1024
TIMSK |= (1<<TOIE0);           //Przerwanie overflow (przepełnienie timera)

Teraz musiałem przygotować część programu, która wykonywana będzie gdy Timer się przepełni i zgłosi przerwanie. W moim przypadku, miało to być zmiana stanu świecenia LED na przeciwny. Dowiedziałem się, że należy zdefiniować specjalną funkcję obsługi przerwania o nazwie ISR(), w której w nawiasach podajemy nazwę przerwania (tzw. wektor przerwania). Więcej przeczytałem tutaj: AVR Interrupts

Zdefiniowałem więc swoją funkcję następująco:

ISR(TIMER0_OVF_vect) 
{
 PORTB ^=(1<<LED1); //suma modulo 2 (XOR) stanu poprzedniego na porcie
                    //czyli zmiana stanu pinu LED1 na przeciwny  
     
 PORTB ^=(1<<LED2); //suma modulo 2 (XOR) stanu poprzedniego na porcie   
                    //czyli zmiana stanu pinu LED2 na przeciwny  
}

Przy takim sposobie zmiany stanu świecenia diod LED ich częstotliwość mrugania jest dwa razy mniejsza niż wynika to z powyższych obliczeń , ponieważ co drugie przerwanie gasi diody, a co drugie je zapala.

Następnie przerobiłem swój program z poprzedniej części pamiętnika i otrzymałem:

#include <avr/io.h>  
#include <avr/interrupt.h> 
     
//definicja LED1 (do którego pinu podłączony LED1)  
#define LED1 PB0  
  
//definicja LED2 (do którego pinu podłączony LED2)  
#define LED2 PB1  
     
        
void main(void)  
{  
 //########### I/O ###########  
 DDRB  |= (1<<LED1) | (1<<LED2); //Ustawienie pinów sterujących diodami  
                                                 // jako wyjścia  
 PORTB |= (1<<LED1); //Ustawienie stanu wysokiego na wyjściu sterującym LED1   
                                  //(stan początkowy)  
 //##########################  

 //######## konfiguracja timera ##############
 TCCR0 |= (1<<CS02) | (1<<CS00); // źródłem CLK, preskaler 1024
 TIMSK |= (1<<TOIE0);           //Przerwanie overflow (przepełnienie timera)
 //###########################################

 sei(); //Globalne uruchomienie przerwań

 while(1); //główna pętla programu

} 


//############ Procedura obsługi przerwania od przepełnienia timera ############
ISR(TIMER0_OVF_vect) 
{
 PORTB ^=(1<<LED1); //suma modulo 2 (XOR) stanu poprzedniego na porcie
                              //czyli zmiana stanu pinu LED1 na przeciwny  
     
 PORTB ^=(1<<LED2); //suma modulo 2 (XOR) stanu poprzedniego na porcie   
                             //czyli zmiana stanu pinu LED2 na przeciwny 
}
//##############################################################################

Efekt był właściwy, czyli diody migały z częstotliwością 2Hz.



Następnie chciałem uzyskać dokładniejsze czasy mrugania diodami.
Z pomocą tutaj przyszedł rejestr TCNT0 do którego można wpisać początkową wartość, od której zaczyna liczyć Timer.

Postanowiłem uzyskać częstotliwość możliwie najbardziej zbliżoną do 1 Hz. Standardowo licznik liczy od 0 do 255. Ale ustawiając rejestr TCNT0 na inną początkową wartość, mogę zawęzić zakres liczenia.

Na przykład ustawiając wartość tego TCNT0 równą 6, licznik liczy od 6 do 255. Uzyskuję więc 250 odcinków czasu po około 1ms (obliczony wyżej) każdy, czyli prawie dokładnie 250 ms do przepełnienia, po czym generuje przerwanie.

Nie mając już możliwość ustawienia większego preskalera posłużyłem się zmienną-licznikiem:

#include <avr/io.h>
#include <avr/interrupt.h> 
     
//definicja LED1 (do którego pinu podłączony LED1)  
#define LED1 PB0  
  
//definicja LED2 (do którego pinu podłączony LED2)  
#define LED2 PB1  
     
//definicja początkowej wartości timera
#define timer_start 6

//zmienna pomocnicza-licznik używana w przerwaniu  
volatile uint8_t cnt=0; 
        
void main(void)  
{  
 //########### I/O ###########  
 DDRB  |= (1<<LED1) | (1<<LED2); //Ustawienie pinów sterujących diodami  
                                                  // jako wyjścia  
 PORTB |= (1<<LED1); //Ustawienie stanu wysokiego na wyjściu sterującym LED1   
                                  //(stan początkowy)  
 //##########################  

 //######## konfiguracja timera ##############
 TIMSK |= (1<<TOIE0);           //Przerwanie overflow (przepełnienie timera)
 TCCR0 |= (1<<CS02) | (1<<CS00); // źródłem CLK, preskaler 1024
 TCNT0 = timer_start;//          //Początkowa wartość licznika
 //###########################################

 sei();//Globalne uruchomienie przerwań

 while(1);//główna pętla programu

} 


//############ Procedura obsługi przerwania od przepełnienia timera ############
ISR(TIMER0_OVF_vect) 
{
  TCNT0 = timer_start;          //Początkowa wartość licznika

  cnt++;     //zwiększa zmienną licznik
  if(cnt>3)  //jeśli 4 przerwania (czyli ok 1 s)
  {
    PORTB ^=(1<<LED1); //suma modulo 2 (XOR) stanu poprzedniego   
                              //na porcie i pinu LED1 (zmiana stanu na przeciwny)  
     
    PORTB ^=(1<<LED2); //suma modulo 2 (XOR) stanu poprzedniego na porcie   
                             //pinu LED2 (zmiana stanu na przeciwny) 
    cnt=0;     //zeruje zmienną licznik
  }
}
//##############################################################################

Przeczytaj także: Czas - odmierzanie

Drzaśkowy pamiętnik: Spis treści

Autor: drzasiek
Redakcja: dondu