Capitole utile din Datasheet ATmega324

• 1. Pin Configurations
  • secțiunea 1.1 - pag. 2
• 7. AVR CPU Core
  • secțiunea 7.3 - pag. 11
  • secțiunea 7.7 - pag. 16
• 12. Interrupts
  • tabelul 12-1 - pag. 61
• 13. External Interrupts
  • secțiunea 13.1 - pag. 67
  • secțiunile 13.2.4-13.2.9 - pag. 69
• 16. 16-bit Timer/Counter1 and Timer/Counter3 with PWM
  • secțiunile 16.1-16.3 - pag. 111
  • secțiunea 16.5 - pag. 117
  • secțiunea 16.7 - pag. 120
  • secțiunile 16.9.1-16.9.2 - pag. 123
  • secțiunea 16.11 - pag. 132

Acest laborator are ca scop familiarizarea voastră cu lucrul cu întreruperile hardware și cu timer-ele prezente în microcontroller-ul Atmega324. 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 laboratorul următor.

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.

Tabela de vectori de întrerupere pentru ATmega324

După cum se observă din tabelul de mai sus, pe lângă întreruperile componentelor interne uC-ului (timer-e, interfețe seriale, convertor analog-digital), există și câteva linii pentru întreruperi de la periferice externe: INT0-INT2 și PCINT0-PCINT3. Diferența dintre aceste două tipuri de întreruperi externe este dată de capabilitățile suportate și de granularitatea lor.

• Semnalele pentru întreruperile INTn vin pe portul D pinii 2, 3 respectiv portul B pinul 2 și pot genera o întrerupere la tranziție (crescătoare, descrescătoare sau ambele) sau pe nivel 0, în funcție de configurarea întreruperii.

• Întreruperile PCINTn se declanșează la ambele tranziții (de unde și numele Pin Change INTerrupt) și câte 8 pini sunt multiplexați pe o singură întrerupere. Semnalele de întrerupere PCINT se pot activa individual, însă pentru a afla exact ce semnal a declanșat o anumită întrerupere trebuie verificat registrul PINn corespunzător. Dacă mai multe semnale se declanșează în același timp, ele nu vor putea fi deosebite.

Pini întreruperi externe pe capsula ATmega324

Î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();

În exemplu, pentru INT0, INT1 și INT2, configurarea se face din registrul EICRA (External Interrupt Control Register A, secțiunea 13.2.1, pagina 67 din datasheet), în timp ce pentru întreruperi de tip pin change se folosește registrul PCICR.

Registrul EICRA

Modurile în care pot fi configurate întreruperile

// întreruperi externe
EICRA |= (1 << ISC00);    // set INT0 to trigger on ANY logic change
// întreruperi de tip pin change (activare vector de întreruperi)
PCICR |= (1 << PCIE1); // enable the pin change interrupt, set PCIE1 to enable PCMSK1 scan
// alte întreruperi

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 de tip INT0 și respectiv PCINT1, codul va arăta în felul următor:

ISR(INT0_vect)
{
  // cod întrerupere externă
}
 
ISR(PCINT1_vect){
  // cod întrerupere de tip pin change
 
  if ((PINB & (1 << PB1)) == 0){
     // întrerupere generată de pinul PB1
  }
}

În cazul de față, pentru activarea întreruperilor externe, se configurează registrul External Interrupt Mask Register (EIMSK) astfel:

• biții INT2:0 controlează dacă întreruperile externe (INT0-INT2) sunt activate

Pentru celelalte întreruperi, se configurează registrul corespunzător (e.g. PCMSK1 pentru activarea întreruperilor de tip pin change pe fiecare pin)

// întrerupere externă
EIMSK |= (1 << INT0);     // Turns on INT0
// întrerupere de tip pin change
PCMSK1 |= (1 << PCINT9); // Turns on PCINT9 (PB1)
// alte întreruperi
// ...
// activare întreruperi la nivel global
sei();

avr-libc oferă interfața din avr/interrupt.h pentru definirea rutinelor de tratare a întreruperilor. Tabela de vectori specifică fiecărui microcontroller (în cazul nostru pentru ATMega324) este declarată în header-ul de IO specific (ex: iom324.h)

Exemple de întreruperi

Definirea rutinei de tratare se face cu macro-ul ISR:

#include <avr/interrupt.h>
 
ISR(INT0_vect)
{
    // ...
}

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 trebuiesc marcate ca volatile pentru ca accesele la acestea să nu fie optimizate de către compilator

#include <avr/interrupt.h>
 
ISR(vector, flag)
{
    // cod întrerupere
}

#include <avr/interrupt.h>
 
ISR(INT0_vect)
{
    // cod întrerupere
}
 
ISR(INT1_vect, ISR_ALIASOF(INT0_vect))

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.

Principiul de funcționare a unui Timer poate fi descris în linii mari de cele trei unități din <imgref timer>:

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ă.

Componentele și funcționarea unui timer pentru ATmega324

Timer-ele sunt prevăzute cu mai multe canale astfel încât se pot desfășura diferite număratori în paralel. ATmega324 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 laboratorul viitor.

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 tabelul următor sunt prezentate cele două moduri pe care le vom folosi în acest laborator.

Descrierea modurilor de funcționare

Mod	Descriere	Imagine contor	Proprietăți
Normal	* pornește de la 0 * numără până 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-ele 0 și 2 OCR1A sau ICR1 pentru timer-ul 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 15 (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 seta întreruperile trebuie doar să activăm bitul corespunzător din TIMSKx

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

#include <avr/interrupt.h>
 
ISR(TIMER1_COMPA_vect)
{
  // cod întrerupere 
}
void init_timer1()
{
  TIMSK1 |= (1 << OCIE1A);
}
int main()
{
  sei();          // activăm primirea întreruperilor
  init_timer1();  // apelăm funcția de inițializare
  // ...
}

TCNT1, OCR1A/B si ICR1 sunt registre de 16 biți care pot fi accesate de către AVR CPU cu ajutorul bus-ului de date de 8 biți. Un registru de 16 biți poate să fie accesat numai folosind două operatii, fie de scriere, fie de citire pe 8 biți. Pentru a executa o scriere de 16 biți, byte-ul HIGH trebuie să fie scris înaintea byte-ului LOW. Intern, scrierea byte-ului HIGH nu actualizează imediat registrul, el fiind salvat într-o locație temporară. Scrierea byte-ului LOW determină actualizarea întregului registru într-un singur ciclu, folosind valoarea HIGH salvată în zona temporară.

Î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. 12 MHz pentru placa de laborator) și de modul de funcționare ales. Un exemplu de calcul este prezentat mai jos:

// calculate the frequency of the interrupt (f) from the timer configuration and clock speed (f_clk)
f_int = f_clk / (prescaler * (tc + 1))
// calculate the target timer count (tc) for the required interrupt frequency
tc = f_clk / (prescaler * f_int) - 1

Alegerea prescaler-ului se face astfel încât să se poată obține frecvența (exactă) dorită a întreruperilor. De exemplu, pentru o frecvență de 1Hz (f_clk = 12MHz) se obțin următoarele variante pentru determinarea prescaler-ului și a limitei de numărare a timer-ului:

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

Task 1.1

• Implementați o funcție asemănătoare cu millis() din biblioteca Arduino. Aceasta ar trebui să returneze intervalul de timp trecut de la pornirea (sau ultimul reset) al uC-ului. Configurați interfața USART0 cu aceeași parametri folosiți în laboratorul trecut și transmiteți către PC un mesaj ales de voi la intervale de 1 secundă.

HINTS:

• Frecvența de ceas a uC-ului este de 12MHz. Folosiți formulele prezentate anterior pentru a obține valorile potrivite pentru prescaler și registrul de comparație ale timer-ului ales astfel încât întreruperile generate de acesta să se declanșeze la intervalul de timp dorit.
• Timer2 poate fi utilizat cu un număr mai mare de valori ale prescaler-ului.

Task 1.2

• Pentru a putea citi în mod corect apăsări scurte ale butoanelor este necesară o metodă de debouncing. Cum ar putea fi rezolvată problema citirilor eronate cu ajutorul funcției millis()? Concepeți o funcție (în pseudocod) care să ilustreze soluția găsită.

Task 2.

• Reluați exercițiul 3 din primul laborator și implementați-l folosind timer-e și întreruperi pentru citirea butoanelor și efectul de clipire al LED-urilor.

Task 3.

• Folosiți butoanele PD6 și PB2 pentru a controla buzzer-ul:
  • Unul dintre butoane selectează frecvența sunetului generat de buzzer (dintre 3 valori, de ex. 100Hz, 200Hz, 300Hz)
  • Buzzer-ul funcționează doar când mențineți al doilea buton apăsat
  • Puteți folosi LED-ul RGB pentru a indica frecvența aleasă

Task 4. (BONUS)

• Funcția implementată la primul exercițiu va acumula o anumită eroare din cauza faptului că frecvența de ceas nu poate fi divizată perfect.
  • Încercați să calculați după câte cicluri de funcționare a timer-ului eroarea devine semnificativă (peste 1 ms).
  • Propuneți o metodă prin care se poate reduce această eroare
  • Încercați implementarea metodei propuse