Modulul de măsurare a timpului (Timer)

1Obiectivele lucrării

• Înțelegerea rolului prescalerului și calculul frecvenței de numărare
• Configurarea modului CTC pentru generarea unei baze de timp precise
• Utilizarea întreruperii de comparare pentru execuție periodică
• Generarea semnalelor PWM și controlul factorului de umplere
• Înlocuirea funcției delay() cu temporizare neblocantă

2Materiale necesare

• 1 Arduino Uno
• 1 Breadboard
• 2 LED-uri + rezistoare 220 Ω
• 1 Potențiometru 10 kΩ
• 1 Buzzer pasiv (opțional)
• 6 Fire jumper

3Noțiuni teoretice

Principiul de funcționare

Un timer este un numărător care crește cu 1 la fiecare impuls de ceas primit. Când atinge valoarea maximă (255 pentru 8 biți, 65 535 pentru 16 biți), se resetează și setează un fanion de depășire. Fiind implementat în hardware, numără în paralel cu execuția programului.

Timerele disponibile pe ATmega328P

Prescalerul

Ceasul de 16 MHz este prea rapid pentru intervale lungi: un timer pe 16 biți s-ar umple în doar 4,1 ms. Prescalerul împarte frecvența înainte de a ajunge la numărător:

Moduri de funcționare

4Calculator interactiv de timer

Modificați parametrii și urmăriți cum se schimbă perioada și frecvența. Graficul arată numărătorul crescând până la valoarea de comparare și semnalul rezultat la pin.

5Generarea semnalului PWM

PWM (Pulse Width Modulation) produce o tensiune medie variabilă prin comutarea rapidă între 0 și 5 V. Raportul dintre timpul „pornit" și perioada totală se numește factor de umplere. Un LED comandat astfel pare că își schimbă intensitatea, iar un motor își schimbă turația.

PWM la nivel de registru - ce face analogWrite()

Funcția analogWrite() ascunde configurarea a trei regiștri. Scrisă explicit, aceeași operație arată astfel - și devine complet controlabilă: puteți alege frecvența, rezoluția și polaritatea, lucruri imposibile prin bibliotecă.

void pwmInit() {
  DDRB |= (1 << PB1);              // pinul 9 (OC1A) ca iesire

  // COM1A1 = 1, COM1A0 = 0  -> iesire necinversata: HIGH la start, LOW la compare
  TCCR1A |= (1 << COM1A1);
  TCCR1A &= ~(1 << COM1A0);

  // WGM13:WGM10 = 0101  -> Fast PWM pe 8 biti (TOP = 255)
  TCCR1A |=  (1 << WGM10);
  TCCR1A &= ~(1 << WGM11);
  TCCR1B |=  (1 << WGM12);
  TCCR1B &= ~(1 << WGM13);

  // prescaler 64 -> f_PWM = 16 MHz / (64 * 256) = 976 Hz
  TCCR1B &= ~((1 << CS12) | (1 << CS11) | (1 << CS10));   // curata campul
  TCCR1B |=   (1 << CS11) | (1 << CS10);                   // scrie 011
}

void pwmSet(uint8_t duty) {
  OCR1A = duty;                    // 0 = mereu stins, 255 = aproape mereu aprins
}

void setup() {
  pwmInit();
  pwmSet(128);                     // 50% - echivalent cu analogWrite(9, 128)
}

void loop() { }

Portarea configurării unui timer

6Cod sursă

Bază de timp de 1 secundă în mod CTC

volatile bool secundaTrecuta = false;

ISR(TIMER1_COMPA_vect) {      // se execută exact la fiecare secundă
  secundaTrecuta = true;
  PORTB ^= (1 << PB5);        // comută LED-ul de pe pinul 13
}

void setup() {
  DDRB |= (1 << PB5);

  cli();                      // oprește întreruperile pe durata configurării
  TCCR1A = 0;                 // curăță registrele
  TCCR1B = 0;
  TCNT1  = 0;                 // resetează numărătorul

  OCR1A = 62499;              // (16 000 000 / 256) - 1 = 1 secundă
  TCCR1B |= (1 << WGM12);     // mod CTC
  TCCR1B |= (1 << CS12);      // prescaler 256
  TIMSK1 |= (1 << OCIE1A);    // activează întreruperea de comparare
  sei();                      // reactivează întreruperile

  DDRB |= (1 << PB4);         // pinul 12: martor pentru bucla principală
}

void loop() {
  if (secundaTrecuta) {
    secundaTrecuta = false;
    PORTB ^= (1 << PB4);      // dovada că bucla a primit evenimentul
  }
}

Temporizare neblocantă - alternativa la delay()

delay() oprește complet programul. Cu millis() se pot rula mai multe activități cu perioade diferite, în paralel:

const uint8_t LED_1 = 8, LED_2 = 9;
unsigned long ultimul1 = 0, ultimul2 = 0;
const unsigned long PERIOADA_1 = 250;   // ms
const unsigned long PERIOADA_2 = 1000;  // ms

void setup() {
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
}

void loop() {
  unsigned long acum = millis();

  if (acum - ultimul1 >= PERIOADA_1) {
    ultimul1 = acum;
    digitalWrite(LED_1, !digitalRead(LED_1));
  }

  if (acum - ultimul2 >= PERIOADA_2) {
    ultimul2 = acum;
    digitalWrite(LED_2, !digitalRead(LED_2));
  }

  // bucla rămâne liberă pentru alte sarcini
}

Control PWM al intensității

Factorul de umplere este comandat aici direct din program, printr-o rampă. La lucrarea a cincea îl veți înlocui cu valoarea citită de la un potențiometru, prin convertorul analog-numeric.

const uint8_t PIN_LED = 9;    // pin PWM (Timer1)

void setup() {
  pinMode(PIN_LED, OUTPUT);
}

void loop() {
  // creste treptat: LED-ul se aprinde lin
  for (uint16_t duty = 0; duty <= 255; duty += 5) {
    analogWrite(PIN_LED, duty);
    delay(25);
  }

  // scade treptat: LED-ul se stinge lin
  for (uint16_t duty = 255; duty > 0; duty -= 5) {
    analogWrite(PIN_LED, duty);
    delay(25);
  }
}

7Montaj interactiv

Un timer este un numărător care merge singur. Montajele de mai jos vă arată amândouă utilizările lui: generarea unui semnal PWM (unde vedeți unda și factorul de umplere) și măsurarea unui interval exact în modul CTC. Schimbați prescalerul din regiștri și priviți cum se modifică frecvența.

#include <avr/io.h>
#include <util/delay.h>

/* OCR1A hotaraste cat timp din perioada iesirea sta in 1.
   OCR1A = 0   -> LED stins;  OCR1A = 255 -> LED la maxim. */

int main(void)
{
    DDRB |= (1 << PB1);        // pinul 9 = OC1A, iesire

    /* PWM rapid pe 8 biti, TOP = 255, iesire neinversata pe OC1A */
    TCCR1A = (1 << COM1A1) | (1 << WGM10);
    TCCR1B = (1 << WGM12)  | (1 << CS11);   // prescaler 8

    unsigned int d;

    while (1) {
        for (d = 0; d <= 255; d += 5) {     // creste treptat
            OCR1A = d;
            _delay_ms(25);
        }
        for (d = 255; d > 0; d -= 5) {      // scade treptat
            OCR1A = d;
            _delay_ms(25);
        }
    }
}

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

/* Formula:  OCR1A = F_CPU / (prescaler * frecventa_dorita) - 1
   La 16 MHz, prescaler 1024 si o comutare pe secunda:
       OCR1A = 16000000 / (1024 * 1) - 1 = 15624              */

ISR(TIMER1_COMPA_vect)
{
    PORTB ^= (1 << PB5);
}

int main(void)
{
    DDRB |= (1 << PB5);

    TCCR1A = 0;
    TCCR1B = (1 << WGM12) | (1 << CS12) | (1 << CS10);   // CTC, prescaler 1024
    OCR1A  = 15624;
    TIMSK1 = (1 << OCIE1A);
    sei();

    /* Exercitiu: modificati OCR1A astfel incat LED-ul sa comute
       la fiecare 250 ms. Calculati valoarea, nu o ghiciti.
       Verificati pe osciloscop: la viteza 4x, o perioada completa
       trebuie sa dureze 500 ms.                                  */

    while (1) { }
}

8Sarcini de lucru

• Configurați Timer1 în mod CTC pentru a genera o întrerupere la fiecare secundă și verificați precizia cu un cronometru pe 60 de secunde.
• Calculați și verificați valorile OCR1A pentru perioade de 0,5 s, 2 s și 5 s. Ce se întâmplă la 5 s cu prescaler 256?
• Realizați un program care aprinde două LED-uri cu perioade diferite (250 ms și 1 s), fără a folosi delay().
• Comandați intensitatea unui LED prin PWM, cu factorul de umplere dat de un potențiometru.
• Măsurați frecvența semnalului PWM pe pinul 9 și comparați cu valoarea teoretică de 490 Hz.
• Generați un efect de „respirație”: intensitatea LED-ului crește și scade lin, continuu.

9Aplicație de aprofundare

10Întrebări de verificare

11Resurse

• Îndrumarul acestei lucrări (PDF)
• Îndrumarul complet de laborator
• Pagina cursului - toate materialele