Chapitre 6 — Timers AVR
en Assembleur et en C

Ce cours fait partie du cursus Génie en Cybersécurité et Systèmes Embarqués (Semestre 2) dispensé à l'Université Abdelmalek Essaadi – ENSA Tétouan, Département Intelligence Artificielle et Digitalisation.

L'enseignant responsable est Pr. Baghouri Mostafa (Mostafa.baghouri@ensam-casa.ma).

Cette diapositive annonce le Chapitre 6 : Timers AVR en Assembleur et en C. Il s'agit du chapitre central consacré aux mécanismes de temporisation et de comptage sur la famille AVR.

Le microcontrôleur ciblé est l'ATmega328 (base de l'Arduino Uno). Les programmes seront écrits en assembleur AVR et en C (avr-gcc).

Un même module matériel peut fonctionner en mode Timer ou en mode Compteur :

• Timer (chronomètre interne) : le registre s’incrémente automatiquement à chaque coup d’horloge interne du microcontrôleur. On mesure ainsi le temps qui passe, on génère des délais ou des interruptions périodiques.
• Compteur (compteur externe) : le registre s’incrémente uniquement lorsqu’une impulsion arrive sur une broche dédiée (T0 pour Timer0, T1 pour Timer1). On compte donc des événements physiques extérieurs (capteur, moteur, etc.).

À l'issue de ce chapitre, l'étudiant doit être capable de :

• Énumérer les timers de l'ATmega328 et leurs registres associés (Timer0, Timer1, Timer2).
• Décrire les modes Normal et CTC (Clear Timer on Compare Match).
• Programmer les timers en assembleur et en C pour générer des délais temporels précis.
• Programmer les compteurs pour compter des événements extérieurs arrivant sur une broche.

Un compteur est basé sur un registre compteur (Counter Register). Ce registre peut être :

• Incrémenté (UP) à chaque front actif de l'horloge.
• Chargé (Load) avec une valeur initiale pour définir le point de départ du comptage.
• Lu (C_OUT) pour connaître la valeur courante du compteur.

Ce modèle simplifié est la brique fondamentale de tout timer/compteur dans un microcontrôleur.

Premier exemple concret : un compteur de personnes à l'entrée d'un bâtiment. Un capteur (sensor) envoie une impulsion à chaque passage.

• Chaque impulsion du capteur → signal UP → le registre s'incrémente.
• Un comparateur compare la valeur du registre avec une constante (ici 4).
• Quand le compteur atteint 4 → sortie du comparateur activée → action déclenchée (alarme, fermeture de porte, etc.).

Pour générer un délai temporel avec un compteur, on exploite la fréquence régulière de l'horloge système :

• L'horloge CLK alimente le signal UP du compteur.
• On charge une valeur initiale (ici $FC = 252) dans le registre.
• Le compteur s'incrémente à chaque coup d'horloge jusqu'au débordement (overflow à 256 pour un compteur 8 bits).
• Nombre de cycles attendus = 256 − 252 = 4 cycles.

Le timer/compteur d'un microcontrôleur est un module matériel autonome qui compte les fronts d'horloge. Il joue plusieurs rôles :

• Mesurer le temps écoulé (fonctions delay(), millis() en Arduino)
• Mesurer la durée d'un événement (ex. largeur d'une impulsion)
• Compter des événements extérieurs sur une broche dédiée
• Générer des signaux PWM (Modulation à Largeur d'Impulsion)
• Réaliser des comparaisons de valeurs
• Générer des interruptions à intervalles réguliers

Chaque timer possède un flag d'overflow (TOVn) qui est automatiquement mis à 1 lorsque le compteur déborde (passe de 0xFF à 0x00 pour 8 bits).

Séquence pour Délai = 4 µs avec valeur initiale $FC

• On charge TCNT0 = $FC (252 en décimal).
• Le compteur progresse : FC → FD → FE → FF → (overflow) → 00.
• 4 coups d'horloge se sont écoulés → TOV0 = 1.
• Le programme détecte ce flag en boucle (SBIS TIFR0, TOV0), puis l'efface par logiciel en écrivant 1 dans le bit correspondant de TIFR0.

Le timer/compteur peut recevoir son signal d'horloge depuis deux sources, sélectionnables via les bits CS (Clock Select) du registre TCCRn :

• Mode Timer : Source = oscillateur interne → mesure de temps précis.
• Mode Compteur : Source = broche externe Tn → compte des événements.

Le registre TIFR contient le flag TOVn. Quand le compteur déborde, TOVn = 1. Le programme peut soit lire ce flag en polling, soit configurer une interruption.

L'ATmega328 (Arduino Uno) possède 3 timers :

Chaque timer n dispose d'un ensemble de registres 8 bits accessibles par adresse :

Le Timer 0 est un timer 8 bits, le premier et le plus simple de l'ATmega328. Il compte de 0x00 à 0xFF (0 à 255), puis déborde.

Le Timer 0 expose les registres suivants :

Le registre TIFR0 (Timer Interrupt Flag Register 0) contient 3 bits de flag :

TCCR0A — Bits de mode WGM et sorties COM

TCCR0B — Prescaler CS et bit WGM02

Tableau WGM — Sélection du mode

Tableau CS — Sélection du prescaler

En mode Normal (WGM = 000), le timer compte librement de 0x00 à 0xFF, puis repart de 0x00 (overflow). À chaque overflow, le flag TOV0 passe à 1.

Objectif : écrire un programme qui génère un délai de 14 cycles machine en utilisant le Timer0 en mode Normal.

Configuration des registres :

; Mode Normal (WGM02:00 = 000), prescaler = 1 (CS = 001)
TCCR0A = 0x00;  // WGM01=0, WGM00=0
TCCR0B = 0x01;  // CS02=0, CS01=0, CS00=1 → clk/1

Le prescaler à 1 (CS = 001) signifie que le timer s'incrémente à chaque cycle d'horloge. La chaîne de valeurs est :

; Assembleur AVR
TCCR0A = 0x00;   // Mode Normal
TCCR0B = 0x01;   // Prescaler = 1 (clk/1)

Programme complet : génère un signal carré sur PB5 en utilisant le Timer0 (mode Normal, TCNT0 = 0xF2).

Code Assembleur

LDI    R16, (1<<5)   ; masque pour PB5
SBI    DDRB, 5      ; PB5 = sortie
LDI    R17, 0
OUT    PORTB, R17  ; PB5 = 0

BEGIN:
LDI    R20, 0xF2
OUT    TCNT0, R20  ; charger timer
LDI    R20, 0x00
OUT    TCCR0A, R20 ; mode normal
LDI    R20, 0x01
OUT    TCCR0B, R20 ; démarrer timer (clk/1)

AGAIN:
SBIS   TIFR0, TOV0  ; sauter si TOV0 = 1
RJMP   AGAIN         ; sinon boucler

LDI    R20, 0x00
OUT    TCCR0B, R20 ; arrêter Timer0
LDI    R20, (1<<TOV0)
OUT    TIFR0, R20  ; effacer TOV0
EOR    R17, R16     ; basculer bit 5
OUT    PORTB, R17  ; appliquer sur PB5
RJMP   BEGIN

Code C équivalent

DDRB = 1<<5;
PORTB &= ~(1<<5);
while (1) {
    TCNT0 = 0xF2;
    TCCR0A = 0x00;
    TCCR0B = 0x01;
    while((TIFR0 & (1<<TOV0)) == 0) {}
    TCCR0B = 0;
    TIFR0 = (1<<TOV0);
    PORTB ^= (1<<5);
}

On reprend l'exemple 1 avec XTAL = 10 MHz. Combien de temps dure exactement le délai généré par le timer ?

Cette valeur ne compte que le temps passé dans le timer. Le programme a aussi des instructions à exécuter, qui prennent du temps supplémentaire (voir page suivante).

Chaque instruction assembleur prend 1 ou 2 cycles machine. Pour un calcul précis du délai total, il faut compter tous les cycles :

Procédure générale pour calculer la valeur à charger dans TCNT0 :

• Étape 1 : Calculer la période de l'horloge → T = 1 / f
• Étape 2 : Calculer le nombre de cycles requis → n = délai_voulu / T
• Étape 3 : Calculer la valeur de chargement → TCNT0 = 256 − n

Générer un signal carré de période 10 µs sur PORTB.3 avec XTAL = 10 MHz.

; Assembleur
BEGIN:
  LDI  R20, 206
  OUT  TCNT0, R20
  LDI  R20, 0x01
  OUT  TCCR0B, R20  ; démarrer, clk/1
AGAIN:
  SBIS TIFR0, TOV0
  RJMP AGAIN
  ; arrêter, clear flag, toggle PB3
  RJMP BEGIN

// C
while (1) {
    TCNT0 = 206;
    TCCR0A = 0x00;
    TCCR0B = 0x01;
    while((TIFR0 & 0x01) == 0) {}
    TCCR0B = 0;
    TIFR0 = 1<<TOV0;
    PORTB = PORTB ^ (1<<3);
}

Modifier TCNT0 pour obtenir le plus grand délai possible sans prescaler (XTAL = 10 MHz).

Au-delà de cette limite, il faut soit utiliser un prescaler, soit utiliser le Timer1 (16 bits).

TCNT0 = 0x00;   // Départ à zéro = délai max
TCCR0A = 0x00;
TCCR0B = 0x01;
while((TIFR0 & (1<<TOV0)) == 0) {}
TCCR0B = 0;
TIFR0 = 0x01;
PORTB ^= (1<<3);

Quand le délai souhaité dépasse la capacité du timer, trois techniques sont disponibles :

• Boucle logicielle : On exécute plusieurs fois la routine de délai. Ex : pour 1 ms avec Timer0 à 10 MHz, on boucle 40× (40 × 25,6 µs ≈ 1 ms).
• Prescaler : On divise l'horloge avant le timer (÷8, ÷64, ÷256, ÷1024) → chaque tick dure plus longtemps → délai plus long avec le même compteur.
• Timer 16 bits (Timer1) : Peut compter jusqu'à 65535 valeurs → délais 256× plus longs que Timer0 à prescaler identique.

Le préscaler 10 bits de l'ATmega328 est partagé entre Timer0 et Timer1. Il divise clk_IO par un facteur configurable avant de l'envoyer au timer :

Les bits CS02:CS00 du registre TCCR0B sélectionnent quelle sortie du prescaler alimente le timer. La broche externe T0 (PD4) peut également être utilisée comme source (CS = 110 ou 111).

Programme analysé : TCNT0 = 0x10, prescaler ÷64 (CS = 011), XTAL = 8 MHz.

Le code utilise TCCR0B = 0x03 pour sélectionner CS = 011 (÷64), et appelle une fonction DELAY en subroutine (RCALL/RET).

XTAL = 8 MHz, prescaler 1024. Calculer la période d'horloge et le délai maximal.

XTAL = 8 MHz, prescaler ÷256, signal carré 125 Hz sur PORTB.3.

; Assembleur — sous-routine DELAY
DELAY:
  LDI  R20, 0x83      ; TCNT0 = 131
  OUT  TCNT0, R20
  LDI  R20, 0x04      ; CS = 100 (÷256)
  OUT  TCCR0, R20
AGAIN:
  IN   R20, TIFR
  SBRS R20, TOV0
  RJMP AGAIN
  LDI  R20, 0
  OUT  TCCR0, R20
  LDI  R20, (1<<TOV0)
  OUT  TIFR, R20
  RET

En mode CTC (WGM = 010), le timer ne déborde plus à 255 mais se remet à zéro automatiquement lorsque TCNT0 == OCR0A. Le flag OCF0A est alors mis à 1.

Pour activer le mode CTC sur Timer0, configurer les bits WGM dans TCCR0A et TCCR0B :

// Activer mode CTC
TCCR0A = (1<<WGM01);  // WGM01=1, WGM00=0 → CTC
TCCR0B = 0x01;         // prescaler = 1
OCR0A  = 49;           // valeur de comparaison

Même objectif que l'exemple 3 : signal carré période 10 µs sur PORTB.3, XTAL = 10 MHz. Cette fois en mode CTC.

; Assembleur
LDI  R20, 49
OUT  OCR0A, R20         ; TOP = 49
BEGIN:
LDI  R20, (1<<WGM01)
OUT  TCCR0A, R20        ; CTC mode
LDI  R20, 1
OUT  TCCR0B, R20        ; prescaler = 1
AGAIN:
SBIS TIFR0, OCF0A       ; attendre OCF0A
RJMP AGAIN
; stop, clear, toggle PB3
RJMP BEGIN

// C
OCR0A  = 49;
TCCR0A = (1<<WGM01);
TCCR0B = 1;
while((TIFR0 & (1<<OCF0A)) == 0) {}
TCCR0B = 0;
TIFR0 = 1<<OCF0A;
PORTB ^= 1<<3;

Le Timer2 est également un timer 8 bits, structurellement très similaire au Timer0, avec les mêmes registres :

La différence principale réside dans les options de prescaler. Timer2 permet des granularités intermédiaires (÷32, ÷128) utiles pour certaines applications audio ou RTC.

En dehors des prescalers, la programmation de Timer2 est identique à Timer0 : mêmes modes, même logique de flag, mêmes formules de calcul.

Le Timer1 est le seul timer 16 bits de l'ATmega328. Il compte de 0 à 65535 (0xFFFF).

Il possède 3 registres de contrôle (TCCR1A, TCCR1B, TCCR1C) et des registres 16 bits divisés en deux octets H/L :

Timer1 supporte 16 modes de fonctionnement définis par WGM13:WGM10 (4 bits répartis sur TCCR1A et TCCR1B).

L'ATmega328 ne dispose que d'un bus de données 8 bits. Pour lire/écrire un registre 16 bits (TCNT1, OCR1A…), le matériel utilise un registre TEMP interne transparent au programmeur.

Règle d'écriture d'un registre 16 bits

• Écrire d'abord l'octet fort (H) → stocké dans TEMP.
• Écrire ensuite l'octet faible (L) → déclenche l'écriture atomique des deux octets.

Règle de lecture d'un registre 16 bits

• Lire d'abord l'octet faible (L) → stocke automatiquement H dans TEMP.
• Lire ensuite l'octet fort (H) → provient de TEMP.

// Écriture TCNT1 = 0xF353
TCNT1H = 0xF3;  // → TEMP = 0xF3
TCNT1L = 0x53;  // → écriture atomique

// Lecture TCNT1
uint8_t lo = TCNT1L;  // → TEMP = TCNT1H gelé
uint8_t hi = TCNT1H;  // → lu depuis TEMP

Générer un signal carré de période 2 ms (toggle toutes les 1 ms) sur PB5 avec Timer1 en mode Normal.

; TCNT1H doit être écrit avant TCNT1L
LDI  R20, 0xD8
STS  TCNT1H, R20   ; TEMP = 0xD8
LDI  R20, 0xF0
STS  TCNT1L, R20   ; écriture atomique
LDI  R20, 0x00
STS  TCCR1A, R20   ; mode normal
LDI  R20, 0x01
STS  TCCR1B, R20   ; CS = 1 (clk/1)

Alternative C plus élégante : TCNT1 = -10000; (le compilateur gère les octets H et L automatiquement).

Même délai de 1 ms, mais avec le mode CTC du Timer1.

// C — sous-routine delay1ms
void delay1ms() {
    TCNT1  = 0;
    OCR1A  = 10000 - 1;
    TCCR1A = 0;
    TCCR1B = 0x09;   // CTC, clk/1
    while((TIFR1 & (1<<OCF1A)) == 0) {}
    TCCR1B = 0;
    TIFR1  = 1<<OCF1A;
}

Questions et Réponses

En mode compteur, le timer reçoit son signal d'horloge non plus de l'oscillateur interne mais d'une source externe : la broche T0 (PD4) pour Timer0 ou T1 (PD5) pour Timer1.

Sur l'ATmega328 (28 broches), les entrées d'horloge externe se trouvent sur :

Le prescaler peut également être utilisé en mode compteur : T0 → ÷8 → Timer0. Cela permettrait de ne compter qu'un événement sur 8.

Programme : compter les impulsions sur T0 (front descendant) et afficher TCNT0 sur PORTC.

; Assembleur
CBI  DDRD, 4       ; T0 (PD4) = entrée
LDI  R20, 0xFF
OUT  DDRC, R20    ; PORTC = sortie
LDI  R20, 0x00
OUT  TCCR0A, R20  ; mode normal
LDI  R20, 0x06
OUT  TCCR0B, R20  ; ext. clock, falling edge
AGAIN:
IN   R20, TCNT0
OUT  PORTC, R20   ; afficher la valeur
RJMP AGAIN

// C
DDRC   = 0xFF;
TCCR0A = 0;
TCCR0B = 0x06;  // Count on falling edge
while (1) { PORTC = TCNT0; }

Programme : compteur1 en mode CTC, broche T1 (PD5), mettre PC0 à 1 toutes les 100 impulsions.

; Assembleur
CBI  DDRD, 5        ; T1 = entrée
SBI  DDRC, 0        ; PC0 = sortie
LDI  R20, 0
STS  OCR1AH, R20   ; OCR1A high = 0
LDI  R20, 99
STS  OCR1AL, R20   ; OCR1A = 99
LDI  R20, 0x00
STS  TCCR1A, R20
LDI  R20, 0x0E
STS  TCCR1B, R20   ; CTC + ext falling

// C
TCCR1A = 0;
TCCR1B = 0x0E;
OCR1A  = 99;
while (1) {
    while((TIFR1 & (1<<OCF1A)) == 0);
    TIFR1 = (1<<OCF1A);
    PORTC |=  (1<<0);
    PORTC &= ~(1<<0);
}

Formules essentielles

Choisir le bon mode

Choisir le bon timer