Laboratorul 1: Întreruperi, Timere

Acest laborator are ca scop familiarizarea voastră cu lucrul cu întreruperile hardware și cu timer-ele prezente în microcontroller-ul Atmega328p. Vom folosi timer-ele doar pentru a număra, nu și pentru a genera semnal PWM. Această funcționalitate va fi studiată și utilizată în laboratoarele următoare.

O întrerupere hardware reprezintă un semnal sincron sau asincron de la un periferic ce semnalizează apariția unui eveniment care trebuie tratat de către procesor. Tratarea întreruperii are ca efect suspendarea firului normal de execuție al unui program și lansarea în execuție a unei rutine de tratare a întreruperii (RTI).

Întreruperile hardware au fost introduse pentru a se elimina buclele pe care un procesor ar trebui să le facă în așteptarea unui eveniment de la un periferic. Folosind un sistem de întreruperi, perifericele pot comunica cu procesorul, acesta din urma fiind liber să-și ruleze programul normal în restul timpului și să își întrerupă execuția doar atunci când este necesar.

Înainte de a lansa în execuție o RTI, procesorul trebuie sa aibă la dispoziție un mecanism prin care să salveze starea în care se afla în momentul apariției întreruperii. Aceasta se face prin salvarea într-o memorie, de cele mai multe ori organizată sub forma unei stive, a registrului contor de program (Program Counter), a registrelor de stare precum și a tuturor variabilelor din program care sunt afectate de execuția RTI. La sfârșitul execuției RTI starea anterioară a registrelor este refăcută și programul principal este reluat din punctul de unde a fost întrerupt.

Pentru a asocia o întrerupere cu o anumită rutină din program, procesorul folosește tabela vectorilor de întrerupere (TVI), ilustrată în figura de mai jos. În această tabelă, fiecărei întreruperi îi este asociată adresa rutinei sale de tratare, la care programul va face salt în cazul apariției acesteia. Aceste adrese sunt predefinite și sunt mapate în memoria de program într-un spatiu contiguu care alcătuiește TVI. Adresele întreruperilor în TVI sunt setate în funcție de prioritatea lor: cu cât adresa este mai mică cu atât prioritatea este mai mare.

În general, pașii parcurși pentru a activa o întrerupere sunt următorii:

Mecanismul de întreruperi trebuie activat explicit (bitul I - Global Interrupt Enable din registrul SREG). Pentru a seta și reseta acest bit, există și două funcții ajutătoare:

// activează întreruperile
sei();
// dezactivează întreruperile
cli();

// exemplu de configurare pentru Timer 1 în mod CTC, care va genera întreruperi cu frecvența de 2Hz
OCR1A = 31249;            // compare match register 16MHz/256/2Hz-1
TCCR1B |= (1 << WGM12);   // CTC mode
TCCR1B |= (1 << CS12);    // 256 prescaler 

Rutinele de tratare a întreruperii trebuie menționate în memorie la anumite adrese fixe (în vectorul de întreruperi). Pentru a face acest lucru folosim macro-ul de ISR(), care primește ca parametru tipul de întrerupere ce este tratată.

De exemplu, pentru întreruperile generate de Timer 1 în mod CTC, codul va arăta în felul următor:

// implementare rutină de tratare a întreruperii TIMER1_COMPA
ISR(TIMER1_COMPA_vect) {
  // cod întrerupere de la Timer1
}

// activare întrerupere TIMER1_COMPA
TIMSK1 |= (1 << OCIE1A);
// activare întreruperi la nivel global
sei();

Reguli de programare în context întrerupere:

• Nu există o valoare de return. La închierea execuției handler-ului, procesorul execută din nou instrucțiuni de unde rămăsese înainte de declanșarea întreruperii
• Datorită faptului că handler-ul întârzie orice altă activitate din main și inhibă execuția altor întreruperi, se dorește ca timpul de execuție să fie cât mai mic.
• La folosirea unor variabile comune în mai multe handler-e de întrerupere și/sau main trebuie avut în vedere accesul concurent la acestea (în special la variabilele de 16/32 biți a căror modificare necesită mai mulți cicli de procesor).
• Variabilele comune trebuie marcate ca volatile pentru ca accesele la acestea să nu fie optimizate de către compilator

Alte wrapper-e (în jurul unor instrucțiuni ale core-ului AVR) oferite de interfață sunt:

• sei() - setează pe 1 bitul I din SREG, activând întreruperile globale. Apelează instrucțiunea assembler sei
• cli() - setează pe 0 bitul I din SREG, dezactivând întreruperile globale. Apelează instrucțiunea assembler cli
• reti() - întoarcerea dintr-o rutină de tratare a intreruperii, activează întreruperile globale. Ar trebui sa fie ultima instrucțiune apelată într-o rutină care folosește flag-ul ISR_NAKED.

Timer-ul/Counter-ul oferă facilitatea de a măsura intervale fixe de timp și de a genera întreruperi la expirarea intervalului măsurat. Un timer, odată inițializat va funcționa independent de unitatea centrală (UCP). Acest lucru permite eliminarea buclelor de delay din programul principal.

Componentele și funcționarea unui timer pentru ATmega328p pot fi descrise în linii mari de cele trei unități din figura de mai jos:

1. Registrul numărător (Timer Counter, TCNT) - măsoară efectiv intervalele de timp și este incrementat automat cu o frecvență dată.
2. Prescaler-ul - are rolul de a diviza în funcție de necesitățile aplicației frecvența de ceas.
3. La fiecare incrementare a TCNT are loc o comparație între acest registru și o valoare stocată în registrul OCRn. Această valoare poate fi încarcată de către programator prin scrierea registrului OCRn. Dacă are loc egalitatea se generează o întrerupere, în caz contrar incrementarea continuă.

Timer-ele sunt prevăzute cu mai multe canale astfel încât se pot desfășura diferite număratori în paralel. ATmega328p este prevăzut cu 3 unități de timer: două de pe 8 biți și una de 16 biți.

Timer-ele pot funcționa și în moduri PWM, astfel încat să genereze pe un pin de ieșire un semnal de comandă cu tensiune (medie) variabilă. Mai multe detalii veți afla în laboratoarele următoare.

Timer-ele oferă mai multe moduri de funcționare (cu mici diferențe între Timer/Counter0, Timer/Counter1 și Timer/Counter2), ce se diferențiaza prin:

• valorile până la care se face incrementarea
• felul în care se numără (doar crescător, sau alternativ crescător/descrescător)
• când se face resetarea contorului

În următorul tabel sunt prezentate cele două moduri pe care le vom folosi în acest laborator.

Mod	Descriere	Imagine contor	Proprietăți
Normal	- pornește de la 0 - numără până la 0xFFFF		frecvența este fixată la câteva valori predefinite, date de frecvența ceasului și de prescaler
CTC Clear Timer on Compare	- pornește de la 0 - numără până când se atinge un prag (OCRnA pentru Timer 0/2, OCR1A sau ICR1 pentru Timer 1)		frecvența este variabilă, determinată de valoarea pragului, frecvența ceasului și de prescaler

Definiții care apar în datasheet:

• BOTTOM: capătul inferior din intervalul de numărare
• TOP: capătul superior al intervalului de numărare
• MAX: limita superioară a numărării, 255 (0xff) pentru 8 biți, 65535 (0xffff) pentru 16 biți. TOP poate fi MAX în anumite moduri de funcționare (ex: Normal).

Pentru a configura un mod de funcționare, vom seta:

• biții WGM din timer-ul respectiv (care se găsesc în registrele TCCRnA din datasheet, la secțiunile aferente timerelor, “Register Description”)
• pragul de numărare

De exemplu, ca să setăm timer-ul 0 să numere până la 5, ne vom uita în datasheet la capitolul 14 (8-bit Timer/Counter0 with PWM) - secțiunea Register Description → TCCR0A

1. găsim modul CTC ca având biții 0 1 0 pe biții WGM2..0
2. aflăm că modul CTC numără până la OCRA

Presupunând că plecăm de la un registru complet neinițializat (0 este valoarea default pentru majoritatea biților), avem următorul cod:

TCCR0A |= (1 << WGM01);
OCR0A = 5;

Pentru setarea prescaler-ului se vor modifica biții tip CS.. din registrul TCCRnB al timer-ului respectiv.

De exemplu, pentru setarea valorii de prescaler 256 pentru timer-ul 2, vom urmări în datasheet capitolul 17 (8-bit Timer/Counter2 with PWM) - secțiunea Register Description → TCCR2B

1. găsim tabelul pentru valorile CS..
2. aflăm că prescaler-ul 256 corespunde biților 1 1 0 pentru biții CS22 CS21 CS20

Presupunând că plecăm de la un registru complet neinițializat (0 este valoarea default pentru majoritatea biților), avem următorul cod:

TCCR2B |= (1 << CS22) | (1 << CS21);

Pentru un timer deja configurat, pentru a activa întreruperile trebuie doar să activăm bitul corespunzător din TIMSKx

De exemplu, pentru pragul A al timer-ului 1 vom scrie:

ISR(TIMER1_COMPA_vect) {
  // cod întrerupere 
}
 
void configure_timer1() {
  // exemplu de configurare pentru Timer 1 în mod CTC
  // care va genera întreruperi cu frecvența de 2Hz
  OCR1A = 31249;            // compare match register 16MHz/256/2Hz-1
  TCCR1B |= (1 << WGM12);   // CTC mode
  TCCR1B |= (1 << CS12);    // 256 prescaler 
}
 
void init_timer1() {
  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
}
 
void setup() {
  // dezactivăm întreruperile globale
  cli();  
  configure_timer1();
  init_timer1();
  // activăm întreruperile globale
  sei();
}
 
void loop() {
 
}

În general, pentru configurarea unui Timer, este necesară alegerea unui prescaler și a unei limite de numărare, în funcție de perioada dorită și de frecvența de lucru a procesorului (e.g. 16 MHz pentru Arduino UNO) și de modul de funcționare ales. Un exemplu de calcul este prezentat mai jos:

- calcul frecvență întreruperi în funcție de frecvența ceasului și a pragului de numărare:

f_int = f_clk / (prescaler * (tc + 1))

- calcul prag de numărare al timer-ului pentru a obține frecvența dorită:

tc = f_clk / (prescaler * f_int) - 1

Observăm că trebuie aleasă o valoare convenabilă pentru prescaler (din cele disponibile, ex. 8, 64, 256, 1024) și un prag de numărare (0-255 pentru timer-e pe 8 biți, 0-65535 pentru timer-e pe 16 biți) astfel încât să se obțină frecvența exactă.

Există însă calculatoare care pot fi utile pentru determinarea rapidă a valorilor pentru registrele de configurare ale unui Timer precum:

Folosind Timer-e și întreruperi, veți realiza o variantă îmbunătățită a programului Hello World (blink) și un generator de ton folosind buzzer-ul.

Task 0 Configurați Timer 1 folosind registre și întreruperea TIMER1_COMPA pentru a aprinde un LED o dată pe secundă:

ISR(TIMER1_COMPA_vect) {
  // blink led
}

void setup() {
 // configurați pin-ul de output

 // inițializare timer 1
  cli();

  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1  = 0;
  
  OCR1A = 31249;            // compare match register 16MHz/256/2Hz-1
  TCCR1B |= (1 << WGM12);   // CTC mode
  TCCR1B |= (1 << CS12);    // 256 prescaler 
  TIMSK1 |= (1 << OCIE1A);  // enable timer compare interrupt
  sei();
}

void loop() {

}

Task 1 Configurați Timer 1 folosind registre și întreruperea TIMER1_COMPA pentru a comanda un buzzer la o frecvență audibilă (e.g. un ton/notă muzicală între 440 și 880 Hz). Consultați acest link pentru frecvența notelor muzicale.

Task 2 Rulați programul de mai jos care configurează Timer 0 pentru a aprinde LED-ul periodic fără a folosi întreruperi:

void setup()
{
  DDRD |= 1 << PD6;
  
  TCCR0A  = 0;
  TCCR0B  = 0;
  TCNT0   = 0;

  TCCR0A |= 1 << COM0A0;
  TCCR0A |= 1 << WGM01;
  
  OCR0A   = 0x80; 
  TCCR0B |= 3 << CS00;
}

void loop()
{
  // your program here
}

Task 3 Configurați un Timer folosind biblioteca Arduino TimerOne astfel încât să aprindeți un LED o dată pe secundă

#include "TimerOne.h"
 
void setup()
{
  pinMode(10, OUTPUT);
  Timer1.initialize(500000);         // initialize timer1, and set a 1/2 second period
  Timer1.attachInterrupt(callback);  // attaches callback() as a timer overflow interrupt
}
 
void callback()
{
  // toggle pin
}
 
void loop()
{
  // your program here
}

Task 4 Folosiți funcția de bibliotecă tone() pentru a genera sunet pe un buzzer conectat la pinul 8. Găsiți un exemplu în Arduino IDE la file / examples / digital.

• Datasheet Atmega 328p
• Arduino UNO pinout
• 
• Responsabili: Adrian Mocanu

• AVR Libc - interrupt.h
• Setul de instrucțiuni AVR
• TimerOne
• tone()