ArduinoElettronica digitale

Timer hardware dell’ATmega328P su Arduino UNO: prescaler, CTC, PWM a frequenza precisa e Input Capture

Come funzionano Timer0, Timer1 e Timer2 di Arduino UNO, come si impostano prescaler e modalità con i registri, con un interrupt a 1 kHz, un PWM a 25 kHz per ventole a 4 fili e un frequenzimetro a Input Capture.

Dietro millis(), analogWrite(), tone() e la libreria Servo di Arduino UNO lavorano i timer di Arduino, tre periferiche hardware dell’ATmega328P chiamate timer/contatori: Timer0, Timer1 e Timer2. Sono contatori che avanzano al ritmo del clock, indipendentemente dal programma, e che possono generare interrupt a intervalli esatti, produrre segnali PWM di frequenza arbitraria o registrare con precisione l’istante in cui arriva un fronte su un pin. Le funzioni Arduino ne usano una configurazione fissa; programmandoli direttamente si ottengono prestazioni che il codice nel loop() non può raggiungere.

In questa guida vediamo chi usa ciascun timer sulla UNO, come si impostano prescaler e modalità con i registri TCCRnA e TCCRnB, le formule per calcolare frequenze e risoluzioni e tre applicazioni complete: un interrupt periodico a 1 kHz con ISR(TIMER1_COMPA_vect), un PWM a 25 kHz per le ventole a 4 fili e un frequenzimetro basato sull’Input Capture del Timer1. Per la manipolazione dei bit nei registri si rimanda alla guida Arduino registri e bit manipulation.

I tre timer dell’ATmega328P e chi li usa

I tre timer hanno una struttura simile: un contatore (TCNTn), due registri di confronto (OCRnA e OCRnB) collegati ad altrettanti pin di uscita, un prescaler che divide il clock e una logica che decide la modalità di conteggio. Si differenziano per la dimensione e per alcune funzioni speciali: il Timer1 è a 16 bit e ha l’unità di Input Capture, il Timer2 ha un prescaler con più valori e può funzionare con un quarzo da orologio esterno (non sulla UNO, dove i pin TOSC1/TOSC2 sono occupati dal risonatore a 16 MHz).

Timer Bit Uscite (pin UNO) Uso nel core Arduino PWM di analogWrite()
Timer0 8 OC0A = D6, OC0B = D5 millis(), micros(), delay() Fast PWM, 976,6 Hz
Timer1 16 OC1A = D9, OC1B = D10, ingresso ICP1 = D8 libreria Servo Phase Correct 8 bit, 490,2 Hz
Timer2 8 OC2A = D11, OC2B = D3 tone() Phase Correct 8 bit, 490,2 Hz

Le frequenze derivano dalla configurazione impostata dalla funzione init() del core prima di setup(): prescaler 64 per tutti e tre i timer, Fast PWM a 8 bit per il Timer0 (16 MHz / (64 · 256) = 976,56 Hz) e Phase Correct a 8 bit per i Timer1 e 2 (16 MHz / (64 · 510) = 490,2 Hz), gli stessi valori citati nell’articolo su ingressi analogici e uscite PWM. La regola pratica che ne deriva è semplice: il Timer0 non si tocca, perché tutte le funzioni di tempo dipendono da lui; il Timer1 e il Timer2 si possono riprogrammare, rinunciando però alle funzioni che li usano.

Prescaler e registri

Il contatore non avanza necessariamente a ogni ciclo di clock: il prescaler divide la frequenza di sistema per un fattore N scelto con i bit CSn2:0 del registro TCCRnB. Il tempo di un conteggio e la durata massima prima dell’overflow valgono:

\(t_{tick} = \frac{N}{f_{clk}} \qquad T_{ovf} = \frac{N \cdot 2^{n}}{f_{clk}}\)

dove n è il numero di bit del timer. Con il Timer1 a 16 bit e N = 1024 il periodo massimo arriva a 65 536 · 1024 / 16 MHz = 4,19 s; con N = 1 un conteggio dura 62,5 ns.

CSn2:0 Timer0 e Timer1 Timer2 (CS22:0)
000 timer fermo timer fermo
001 N = 1 N = 1
010 N = 8 N = 8
011 N = 64 N = 32
100 N = 256 N = 64
101 N = 1024 N = 128
110 clock esterno su T0/T1, fronte di discesa N = 256
111 clock esterno su T0/T1, fronte di salita N = 1024

I registri di controllo del Timer1, che useremo negli esempi, sono questi:

  • TCCR1A: bit COM1A1:0 e COM1B1:0 (comportamento dei pin OC1A e OC1B) e WGM11:10, i due bit bassi della modalità.
  • TCCR1B: ICNC1 (filtro antirumore dell’Input Capture), ICES1 (fronte di cattura), WGM13:12 (bit alti della modalità) e CS12:0 (prescaler).
  • TCNT1, OCR1A, OCR1B, ICR1: contatore, registri di confronto e registro di cattura, tutti a 16 bit.
  • TIMSK1: abilitazione degli interrupt (ICIE1 cattura, OCIE1A e OCIE1B confronto, TOIE1 overflow).
  • TIFR1: flag corrispondenti (ICF1, OCF1A, OCF1B, TOV1), che si cancellano scrivendo 1.

I registri a 16 bit si leggono e scrivono attraverso un registro temporaneo condiviso: in lettura va letto prima il byte basso, che “congela” quello alto. Il compilatore genera l’ordine corretto quando si scrive OCR1A = 1999, ma se lo stesso registro è usato anche in una ISR l’accesso dal programma principale va fatto con gli interrupt disabilitati, come raccomanda il datasheet.

Le modalità: Normal, CTC, Fast PWM e Phase Correct

I bit WGM (Waveform Generation Mode), divisi tra TCCRnA e TCCRnB, stabiliscono fino a dove conta il timer (il valore TOP) e come si comportano le uscite. Il Timer1 ha 15 modalità utilizzabili; queste sono le più usate.

Modo WGM13:10 Tipo TOP
0 0000 Normal 0xFFFF
1 0001 Phase Correct 8 bit (configurazione di Arduino) 0x00FF
4 0100 CTC OCR1A
5 0101 Fast PWM 8 bit 0x00FF
8 1000 Phase and Frequency Correct ICR1
10 1010 Phase Correct ICR1
12 1100 CTC ICR1
14 1110 Fast PWM ICR1
15 1111 Fast PWM OCR1A

Andamento teorico del contatore TCNT1 e dell'uscita OC1A nelle modalità Normal, CTC, Fast PWM e Phase Correct

In modalità Normal il contatore va da 0 a 0xFFFF, riparte da zero e imposta il flag di overflow TOV1: serve per misurare tempi e, con l’Input Capture, per estendere il conteggio oltre i 16 bit. In CTC (Clear Timer on Compare) il contatore si azzera quando raggiunge OCR1A: è il modo naturale per ottenere un interrupt periodico o un’onda quadra con il pin in modalità toggle. Nel Fast PWM il contatore sale da 0 a TOP con una sola rampa: in modalità non invertente l’uscita va a 1 all’inizio del periodo e a 0 al confronto con OCR1x. Nel Phase Correct il contatore sale e poi scende, l’uscita cambia al confronto in salita e in discesa e l’impulso risulta centrato nel periodo; la frequenza massima è la metà, ma la forma simmetrica è preferita nel controllo dei motori. Le formule, con N fattore di prescaler, sono:

\(f_{ISR,CTC} = \frac{f_{clk}}{N\,(1+OCR1A)} \qquad f_{OC1A,toggle} = \frac{f_{clk}}{2N\,(1+OCR1A)}\)

\(f_{FastPWM} = \frac{f_{clk}}{N\,(1+TOP)} \qquad f_{PhaseCorrect} = \frac{f_{clk}}{2N \cdot TOP} \qquad R = \frac{\log(TOP+1)}{\log 2}\)

R è la risoluzione del PWM in bit: va da 2 bit (TOP = 3) a 16 bit (TOP = 0xFFFF). Nel Fast PWM non invertente il duty cycle vale (OCR1x + 1) / (TOP + 1): con OCR1x = 0 si ottiene un impulso stretto di un conteggio per periodo, con OCR1x = TOP un’uscita sempre alta. Scegliendo ICR1 come TOP (modi PWM 8, 10 e 14) restano liberi sia OCR1A sia OCR1B, quindi si hanno due uscite PWM con la stessa frequenza; ICR1 però non ha doppio buffer, per cui conviene impostarlo una volta e non cambiarlo mentre il timer conta.

Esempi di calcolo

Esempi con fclk = 16 MHz (valori ricalcolati)

1) Interrupt a 1 kHz, Timer1 in CTC (modo 4)
   N = 8  ->  1 + OCR1A = 16 000 000 / (8 x 1000) = 2000  ->  OCR1A = 1999
   (con N = 1 servirebbe OCR1A = 15 999, anche questo valido sul Timer1 a 16 bit)

2) Lo stesso 1 kHz con il Timer2 a 8 bit (CTC, TOP = OCR2A)
   N = 64 ->  1 + OCR2A = 16 000 000 / (64 x 1000) = 250  ->  OCR2A = 249

3) PWM a 25 kHz, Timer1 Fast PWM (modo 14, TOP = ICR1)
   N = 1  ->  1 + ICR1 = 16 000 000 / 25 000 = 640  ->  ICR1 = 639
   risoluzione: log2(640) = 9,32 bit (640 livelli di duty)
   variante Phase Correct (modo 10): TOP = 16 000 000 / (2 x 25 000) = 320

4) PWM a 50 Hz per servocomandi, Timer1 Fast PWM (modo 14)
   N = 8  ->  ICR1 = 16 000 000 / (8 x 50) - 1 = 39 999
   un conteggio = 0,5 us: impulso da 1,5 ms -> OCR1A = 3000 - 1 = 2999

5) Onda quadra a 38 kHz (portante IR) con Timer2 CTC in toggle, N = 1
   1 + OCR2A = 16 000 000 / (2 x 38 000) = 210,5  ->  non intero
   OCR2A = 209 -> 38 095 Hz (+0,25 %)   OCR2A = 210 -> 37 915 Hz (-0,22 %)

6) Overflow del Timer1 in modo Normal
   N = 8    -> 65 536 x 0,5 us = 32,768 ms
   N = 1024 -> 65 536 x 64 us  = 4,194 s

Interrupt periodico a 1 kHz con ISR(TIMER1_COMPA_vect)

Un interrupt periodico è la base di molte applicazioni: campionamento a frequenza costante, multiplexing di display, generazione di segnali, controllori digitali. Il programma seguente imposta il Timer1 in CTC con prescaler 8 e OCR1A = 1999: il contatore si azzera ogni 2000 conteggi da 0,5 µs, cioè ogni millisecondo, e a ogni azzeramento scatta l’interrupt di confronto A. La ISR inverte il pin D7, che quindi presenta un’onda quadra a 500 Hz facile da controllare con un oscilloscopio, e conta i tick; il loop() stampa ogni secondo quanti tick sono arrivati.

// Timer1 in modalita' CTC: interrupt di compare A a 1 kHz esatti.
// La ISR inverte D7 (onda quadra a 500 Hz, utile per l'oscilloscopio) e conta i tick.

#include <util/atomic.h>

volatile uint32_t tick = 0;

ISR(TIMER1_COMPA_vect) {
  PIND = (1 << PIND7);                   // inverte D7 (scrittura di 1 su PINx)
  tick++;
}

void setup() {
  Serial.begin(115200);
  pinMode(7, OUTPUT);

  noInterrupts();
  TCCR1A = 0;                            // nessuna uscita OC1A/OC1B, WGM11:10 = 00
  TCCR1B = 0;
  TCNT1 = 0;
  OCR1A = 1999;                          // 16 MHz / (8 * (1 + 1999)) = 1000 Hz
  TCCR1B = (1 << WGM12) | (1 << CS11);   // modo 4 (CTC, TOP = OCR1A), prescaler 8
  TIMSK1 = (1 << OCIE1A);                // abilita l'interrupt di compare A
  interrupts();
  Serial.println(F("Timer1 CTC a 1 kHz"));
}

void loop() {
  static uint32_t tPrec = 0, tickPrec = 0;
  if (millis() - tPrec >= 1000) {
    tPrec += 1000;
    uint32_t t;
    ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
      t = tick;
    }
    Serial.print(F("tick nell'ultimo secondo: "));
    Serial.print(t - tickPrec);
    Serial.print(F("  totale: "));
    Serial.println(t);
    tickPrec = t;
  }
}

La configurazione segue sempre lo stesso schema: interrupt disabilitati, registri di controllo azzerati (per cancellare la configurazione PWM impostata dal core), valori di confronto, modalità e prescaler, abilitazione dell’interrupt. Il prescaler va scritto per ultimo, perché è lui ad avviare il conteggio. L’inversione del pin si ottiene scrivendo 1 nel bit corrispondente del registro PIND: una sola scrittura, senza leggere prima lo stato del pin.

In simulazione il programma ha stampato 1000 tick in ciascuno dei 5 secondi della prova. Dal CSV dei fronti di D7 la frequenza media della ISR risulta 1000,000 Hz su 5989 periodi; i singoli periodi però oscillano fino a ±6,1 µs. È il jitter dovuto alla latenza variabile: se al momento del confronto la CPU sta eseguendo un’altra ISR (l’overflow del Timer0 per millis() o la trasmissione seriale), l’interrupt del Timer1 aspetta. Il conteggio del timer non ne risente, quindi la frequenza media resta esatta; se serve un segnale senza jitter si lascia che sia l’hardware a commutare il pin, configurando OC1A (D9) in modalità toggle con COM1A0.

Grafico di simulazione: onda quadra a 500 Hz su D7 generata dalla ISR del Timer1 e istogramma del jitter del periodo

PWM a 25 kHz per ventole a 4 fili

Le ventole a 4 fili per computer hanno un ingresso PWM dedicato. Il white paper di Noctua sulle specifiche PWM indica una frequenza di 25 kHz (intervallo ammesso 21–28 kHz), livello basso sotto 0,8 V, un pull-up interno alla ventola verso 3,3 V o 5 V con tensione a vuoto massima di 5,25 V e corrente massima di 5 mA; il segnale tachimetrico è un’uscita open collector con due impulsi per giro. A 25 kHz il PWM è oltre la banda udibile, mentre i 490 Hz di analogWrite() producono un ronzio. Il collegamento è diretto: il pin D9 della UNO pilota l’ingresso PWM, la ventola è alimentata da un alimentatore esterno a 12 V con la massa in comune e l’uscita tachimetrica ha un pull-up da 10 kΩ verso i 5 V di Arduino, non verso i 12 V.

Schema di collegamento di una ventola PWM a 4 fili ad Arduino UNO: PWM su D9, tachimetrica su D8 con pull-up da 10 kOhm, potenziometro su A0

Il Timer1 in modo 14 (Fast PWM con TOP = ICR1) e prescaler 1 conta da 0 a 639 a 16 MHz: 640 conteggi da 62,5 ns danno esattamente 40 µs, cioè 25 kHz, con 640 livelli di duty. D9 (OC1A) segue un potenziometro su A0, D10 (OC1B) riceve il duty da seriale con un comando come b40.

// PWM a 25 kHz su D9 (OC1A) e D10 (OC1B) con Timer1 in Fast PWM, TOP = ICR1.
// D9: duty dal potenziometro su A0 (ventola PWM a 4 fili). D10: duty da seriale ("b40" = 40 %).

const uint16_t TOP = 639;                // 16 MHz / (1 * (1 + 639)) = 25 kHz

void impostaDuty(uint8_t canale, uint8_t percento) {
  if (percento > 100) percento = 100;
  // Fast PWM non invertente: duty = (OCR1x + 1) / (TOP + 1)
  uint16_t ocr = (uint32_t)percento * (TOP + 1) / 100;
  if (canale == 'a') {
    if (percento == 0) {
      TCCR1A &= ~(1 << COM1A1);          // 0 %: scollega OC1A e tieni il pin basso
    } else {
      OCR1A = ocr - 1;
      TCCR1A |= (1 << COM1A1);
    }
  } else {
    if (percento == 0) {
      TCCR1A &= ~(1 << COM1B1);
    } else {
      OCR1B = ocr - 1;
      TCCR1A |= (1 << COM1B1);
    }
  }
}

void setup() {
  Serial.begin(115200);
  digitalWrite(9, LOW);
  digitalWrite(10, LOW);
  pinMode(9, OUTPUT);                    // OC1A
  pinMode(10, OUTPUT);                   // OC1B

  TCCR1A = (1 << WGM11);                 // modo 14: Fast PWM, TOP = ICR1
  TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS10);   // prescaler 1
  ICR1 = TOP;
  impostaDuty('a', 0);
  impostaDuty('b', 25);
  Serial.println(F("PWM 25 kHz su D9 (A0) e D10 (comando bNN)"));
}

void loop() {
  static uint32_t tLettura = 0;
  static uint8_t dutyA = 255;

  if (millis() - tLettura >= 50) {       // potenziometro letto 20 volte al secondo
    tLettura += 50;
    uint8_t d = (uint32_t)analogRead(A0) * 100 / 1023;
    if (d != dutyA) {
      dutyA = d;
      impostaDuty('a', d);
      Serial.print(F("D9 duty "));
      Serial.print(d);
      Serial.println(F(" %"));
    }
  }

  if (Serial.available() >= 3) {         // comando "bNN" (due cifre, b00 ... b99)
    if (Serial.read() == 'b') {
      char c1 = Serial.read();
      char c2 = Serial.read();
      if (isDigit(c1) && isDigit(c2)) {  // scarta comandi malformati come "b5" + a capo
        uint8_t d = (c1 - '0') * 10 + (c2 - '0');
        impostaDuty('b', d);
        Serial.print(F("D10 duty "));
        Serial.print(d);
        Serial.println(F(" %"));
      }
    }
  }
}

Il duty in percento viene convertito nel valore di confronto con la formula OCR1x = d · 640 / 100 − 1. Il caso 0 % è gestito scollegando l’uscita (bit COM1x1 a zero): il pin torna sotto il controllo di digitalWrite(), che lo tiene basso, invece di produrre l’impulso di un conteggio che darebbe OCR1x = 0. Molte ventole, comunque, non si fermano con il PWM a zero ma girano alla velocità minima: è un comportamento della ventola, da verificare sul modello usato. La moltiplicazione è eseguita in uint32_t per evitare l’overflow degli int a 16 bit (100 · 640 = 64 000).

In simulazione le uscite sono state registrate al ciclo di clock in cinque finestre con il potenziometro a 2,5 V, 1,0 V, 0 V, 5 V e 3,3 V e con i comandi b40 e b75. La frequenza misurata è risultata 25 000 Hz con scarti inferiori a 0,1 Hz in tutte le finestre, i duty hanno seguito i comandi (50, 19, 0, 100 e 65 % su D9, 25, 40 e 75 % su D10) e l’uscita a 0 % è rimasta bassa. C’è però una differenza sistematica di un conteggio: il simulatore avr8js riporta a zero l’uscita quando TCNT1 raggiunge OCR1x, un clock prima di quanto prevede il datasheet, per cui in simulazione il 50 % risulta circa 49,8 % invece di 50 % (il modello del simulatore prevede 319/640 = 49,84 %; i fronti sono registrati a fine istruzione, con un’incertezza di qualche ciclo) e il 100 % presenta un impulso basso di un clock (62,5 ns) per periodo invece di un’uscita fissa alta. Sull’hardware vale la formula del datasheet; è un dettaglio da 0,16 % che non cambia nulla per una ventola, ma mostra perché una simulazione non sostituisce la verifica con l’oscilloscopio.

Grafico di simulazione delle uscite PWM a 25 kHz su D9 e D10 con duty diversi

Misurare frequenza e periodo con l’Input Capture

Misurare un periodo con micros() in una ISR, come si fa con gli interrupt esterni, ha due limiti: la risoluzione di 4 µs e la latenza variabile della ISR, che sposta l’istante letto. L’Input Capture del Timer1 elimina entrambi: al fronte selezionato sul pin ICP1 (D8) l’hardware copia immediatamente il valore di TCNT1 nel registro ICR1 e imposta il flag ICF1, che può generare l’interrupt TIMER1_CAPT_vect. La ISR può arrivare anche qualche microsecondo dopo: il tempo è già stato fotografato. Il bit ICES1 sceglie il fronte (1 = salita), il bit ICNC1 attiva un filtro che accetta il fronte solo se il livello resta stabile per 4 campioni consecutivi, al costo di 4 cicli di ritardo.

Principio dell'Input Capture: il fronte su ICP1 copia TCNT1 in ICR1 e il periodo si calcola dalla differenza con gli overflow

Con prescaler 8 il timer conta a 2 MHz (0,5 µs per conteggio) e trabocca ogni 32,768 ms. Per misurare periodi più lunghi si contano gli overflow in un’altra ISR e si costruisce un tempo a 32 bit: parte alta dal contatore degli overflow, parte bassa da ICR1. Il programma misura periodo e durata del livello alto alternando il fronte di cattura (salita, poi discesa) e ricava frequenza, duty cycle e, per il segnale tachimetrico di una ventola, i giri al minuto.

// Misura di periodo, frequenza e duty cycle con l'Input Capture del Timer1 (ICP1 = D8).
// Timer1 in modo Normal, prescaler 8: un conteggio = 0,5 us. Gli overflow estendono il tempo a 32 bit.
// Utile anche per il segnale tachimetrico di una ventola (2 impulsi per giro).

volatile uint16_t overflow = 0;          // parte alta del tempo a 32 bit
volatile uint32_t tSalita = 0;           // istante dell'ultimo fronte di salita
volatile uint32_t periodo = 0;           // in conteggi da 0,5 us
volatile uint32_t alto = 0;              // durata del livello alto
volatile bool nuovaMisura = false;

ISR(TIMER1_OVF_vect) {
  overflow++;
}

ISR(TIMER1_CAPT_vect) {
  uint16_t icr = ICR1;                   // leggere subito ICR1 (il prossimo fronte lo sovrascrive)
  uint16_t ov = overflow;
  // overflow avvenuto ma non ancora servito: vale solo se la cattura e' successiva (ICR1 basso)
  if ((TIFR1 & (1 << TOV1)) && icr < 0x8000) ov++;
  uint32_t t = ((uint32_t)ov << 16) | icr;

  if (TCCR1B & (1 << ICES1)) {           // era un fronte di salita
    static bool primoFronte = true;      // dopo il reset tSalita non e' ancora un istante valido
    if (!primoFronte) periodo = t - tSalita;
    primoFronte = false;
    tSalita = t;
    TCCR1B &= ~(1 << ICES1);             // prossimo: fronte di discesa
  } else {                               // fronte di discesa
    alto = t - tSalita;
    nuovaMisura = true;
    TCCR1B |= (1 << ICES1);              // prossimo: fronte di salita
  }
  TIFR1 = (1 << ICF1);                   // cambiando fronte va cancellato il flag (datasheet)
}

void setup() {
  Serial.begin(115200);
  pinMode(8, INPUT);                     // ICP1

  noInterrupts();
  TCCR1A = 0;                            // modo 0 (Normal), nessuna uscita
  TCCR1B = (1 << ICNC1) | (1 << ICES1) | (1 << CS11);   // filtro antirumore, salita, prescaler 8
  TCNT1 = 0;
  TIFR1 = (1 << ICF1) | (1 << TOV1);     // cancella flag pendenti
  TIMSK1 = (1 << ICIE1) | (1 << TOIE1);  // interrupt di cattura e di overflow
  interrupts();
  Serial.println(F("Input capture su D8 pronto"));
}

void loop() {
  static uint32_t tStampa = 0;
  if (millis() - tStampa < 500) return;  // una stampa ogni 0,5 s
  tStampa += 500;

  uint32_t p, h;
  bool valida;
  noInterrupts();
  p = periodo;
  h = alto;
  valida = nuovaMisura;
  nuovaMisura = false;
  interrupts();

  if (!valida || p == 0) {
    Serial.println(F("nessun segnale"));
    return;
  }
  float frequenza = 2000000.0 / p;       // 2 MHz = frequenza dei conteggi
  Serial.print(F("periodo "));
  Serial.print(p / 2.0, 1);
  Serial.print(F(" us  f = "));
  Serial.print(frequenza, 3);
  Serial.print(F(" Hz  duty "));
  Serial.print(100.0 * h / p, 1);
  Serial.print(F(" %  ventola "));
  Serial.print(frequenza * 30.0, 0);     // giri/min = f * 60 / 2 impulsi per giro
  Serial.println(F(" giri/min"));
}

Il punto delicato è la corsa tra cattura e overflow. Se il fronte arriva subito dopo l’overflow, l’interrupt di cattura, che ha priorità più alta (vettore 10 contro 13), viene servito prima di quello di overflow: il contatore overflow non è ancora stato incrementato, ma ICR1 contiene già un valore piccolo. La ISR lo riconosce controllando il flag TOV1 ancora pendente e il valore di ICR1: se il flag è attivo e ICR1 è nella metà bassa, la cattura è avvenuta dopo l’overflow e va contato un overflow in più. Al primo fronte di salita dopo il reset tSalita vale ancora 0 e la differenza non sarebbe un periodo ma il tempo trascorso dall’avvio del timer: il flag statico primoFronte fa scartare quella misura, così periodo resta 0 e il loop() stampa «nessun segnale» finché non arriva il secondo fronte. Un altro dettaglio viene dal datasheet: dopo aver cambiato il fronte con ICES1 il flag ICF1 va cancellato scrivendo 1, perché il cambio stesso può generare una cattura spuria.

L’unità di Input Capture non è implementata nel simulatore avr8js, quindi lo script di stimolo ne contiene un modello minimo: al fronte selezionato da ICES1 copia TCNT1 in ICR1, imposta ICF1 e richiede l’interrupt. Il modello corregge anche due differenze di avr8js rispetto al chip reale (in TIFR1 i flag si cancellano scrivendo 1 senza toccare gli altri, e la scrittura di TCCR1B non azzera il prescaler), mentre non riproduce il ritardo di 4 cicli del filtro ICNC1, uguale per tutti i fronti e quindi ininfluente su periodo e duty. Con questo modello il programma ha misurato esattamente onde rettangolari a 1000 Hz con duty 25 %, 50 Hz al 50 %, 12,5 Hz al 20 % (periodo di 80 ms, più di due overflow), 20 kHz al 50 % e 133,333 Hz al 75 %: in tutte le 11 stampe valutate periodo, frequenza e duty coincidono con i valori generati entro la risoluzione di 0,5 µs. Una seconda prova ha verificato la corsa tra cattura e overflow: 242 fronti posizionati a passi di un ciclo di clock entro ±2 µs da un overflow, con la lettura di periodo dopo ogni fronte. Con il controllo su TOV1 tutte le misure sono corrette; togliendo quella riga compaiono 12 periodi sbagliati di 65 536 conteggi (32,768 ms).

periodo 1000.0 us  f = 1000.000 Hz  duty 25.0 %  ventola 30000 giri/min
periodo 20000.0 us  f = 50.000 Hz  duty 50.0 %  ventola 1500 giri/min
periodo 80000.0 us  f = 12.500 Hz  duty 20.0 %  ventola 375 giri/min
periodo 50.0 us  f = 20000.000 Hz  duty 50.0 %  ventola 600000 giri/min
periodo 7500.0 us  f = 133.333 Hz  duty 75.0 %  ventola 4000 giri/min

La colonna dei giri al minuto ha senso solo per il segnale di una ventola: 133,3 Hz di segnale tachimetrico corrispondono a 4000 giri/min. Per frequenze molto più alte di qualche decina di kHz il numero di interrupt diventa eccessivo e conviene contare gli impulsi con l’ingresso di clock esterno T1 (D5) in una finestra di tempo fissa.

Conflitti con le librerie e con le funzioni Arduino

Riprogrammare un timer significa toglierlo alle funzioni che lo usavano. I casi da conoscere sulla UNO sono questi:

Se si usa… Timer occupato Conseguenza
registri del Timer0 Timer0 millis(), micros(), delay() sbagliati; PWM su D5 e D6 alterato
registri del Timer1 (esempi di questo articolo) Timer1 analogWrite() su D9 e D10 non funziona come previsto; libreria Servo incompatibile
libreria Servo Timer1 niente PWM con analogWrite() su D9 e D10
tone() Timer2 PWM su D3 e D11 alterato mentre suona
registri del Timer2 Timer2 tone() e analogWrite() su D3 e D11 non utilizzabili

Un errore frequente è chiamare analogWrite() su D9 dopo aver configurato il Timer1 a registri: la funzione riscrive i bit COM1A e OCR1A e il risultato dipende dalla modalità impostata. Altre librerie usano i timer in modo meno evidente (per esempio alcune per i telecomandi a infrarossi o per i LED indirizzabili): prima di riprogrammare un timer conviene cercare nei loro sorgenti i nomi dei registri, come TCCR1B o TIMER2_COMPA_vect. Se due parti dello sketch definiscono la stessa ISR, il linker segnala una definizione multipla del vettore: è il sintomo più chiaro di un conflitto.

Errori comuni

  • Non azzerare TCCR1A e TCCR1B prima di configurare il timer: restano i bit WGM10 e CS11:10 impostati dal core e la modalità risultante non è quella voluta.
  • Dimenticare il −1 nelle formule: TOP e OCR contano da zero, quindi 640 conteggi richiedono ICR1 = 639.
  • Calcolare in int espressioni come percento * 640, che superano 32 767.
  • Usare OCR1A come TOP e insieme come uscita PWM: nei modi 15 e 4 OCR1A fissa la frequenza, quindi su D9 resta solo il toggle; per due PWM indipendenti si usa ICR1 come TOP.
  • Cambiare ICR1 al volo con valori più bassi: non ha doppio buffer e il contatore può superare il nuovo TOP e arrivare fino a 0xFFFF.
  • Leggere TCNT1 o ICR1 a byte separati o senza proteggere l’accesso se una ISR usa lo stesso timer.
  • Dimenticare di cancellare ICF1 dopo aver cambiato ICES1: compaiono catture spurie e duty cycle senza senso.
  • Collegare il +12 V di una ventola o un segnale tachimetrico con pull-up a 12 V a un pin di Arduino: i pin accettano al massimo la tensione di alimentazione.

Fonti e verifiche

Prescaler, modalità, formule, registri dell’Input Capture e regole di accesso ai registri a 16 bit sono stati verificati sul datasheet Microchip della famiglia megaAVR (capitoli Timer/Counter1 e Timer/Counter2, uguali per ATmega328P) e sugli header di avr-libc; l’uso dei timer da parte di init(), tone() e Servo sui sorgenti del core Arduino AVR 1.8.6 e della libreria Servo 1.3.0; i dati delle ventole sul white paper Noctua. Il codice di questo articolo è stato compilato con il core Arduino AVR 1.8.6 (avr-gcc 14.1) ed eseguito in simulazione con avr8js (ATmega328P a 16 MHz); l’Input Capture è stato simulato con un modello nello script di stimolo, perché avr8js non lo implementa. La prova su hardware reale va eseguita con la checklist fornita insieme ai sorgenti.

Articoli collegati

Admin | MST-Tutorial

Appassionato di elettronica, elettrotecnica e programmazione. Fondatore di MST-Tutorial, condivido con entusiasmo conoscenze, esperienze e progetti legati all’innovazione tecnologica, con l’obiettivo di rendere accessibili concetti tecnici complessi attraverso tutorial chiari e pratici.

Articoli Correlati

Pulsante per tornare all'inizio