Chapitre 7Livre « Arduino sous le capot »

Les timers

Régler un compteur matériel pour cadencer le programme et générer des signaux, sur Uno et Mega

Un timer est un compteur matériel qui avance tout seul au rythme de l’horloge, pendant que le programme fait autre chose. C’est lui qui fait fonctionner millis(), analogWrite(), tone() ou la bibliothèque Servo. En le programmant directement, on obtient des interruptions parfaitement périodiques et des signaux de fréquence et de rapport cyclique quelconques, sans aucune charge pour le processeur.

Ce chapitre présente d’abord le principe d’un timer, les timers de la Uno et de la Mega et leur structure interne. Il détaille ensuite les modes de fonctionnement – normal, CTC et les trois modes PWM – avec leurs formules, puis les registres qui les configurent et les précautions à prendre. Il se termine par quatre exemples complets : une interruption par seconde, une base de temps de 1 ms, un signal carré produit sans programme et une PWM à 25 kHz pour un ventilateur.

Objectifs du chapitre

  • Expliquer le fonctionnement d’un timer : horloge, prédiviseur, compteur, comparateurs et drapeaux.
  • Connaître les timers de la Uno et de la Mega et les fonctions Arduino qui les utilisent.
  • Distinguer les modes normal, CTC, PWM rapide, PWM phase correcte et PWM phase et fréquence correctes.
  • Calculer le prédiviseur et la valeur de comparaison pour une durée ou une fréquence donnée.
  • Configurer un timer par ses registres TCCRnA/B, OCRnx, ICRn et TIMSKn.

Prérequis

Les registres et les masques (chapitre 3), la PWM et analogWrite() (chapitre 3), le fonctionnement de millis() (chapitre 4) et les interruptions (chapitre 6).

Plan du chapitre

  1. Partie I – Principe
  2. 7.1Qu’est-ce qu’un timer ?
  3. 7.2Structure et registres d’un timer
  4. 7.3Les modes de fonctionnement
  5. 7.4Paramétrer et calculer
  6. Partie II – Les modes en détail
  7. 7.5Modes normal et CTC
  8. 7.6Les modes PWM
  9. Partie III – Programmer
  10. 7.7Précautions
  11. Partie IV – Exemples
  12. 7.8Interruptions périodiques
  13. 7.9Produire des signaux
  14. Partie V – Évaluation et ressources
  15. 7.10À retenir et QCM
  16. 7.11Sources et références

Chapitre 7 · Partie I

Principe

Ce qu’est un timer, quels timers équipent la Uno et la Mega, comment ils sont construits, quels modes ils proposent et comment on calcule leurs réglages.

Chapitre 7 · Section 7.1

Qu’est-ce qu’un timer ?

Un timer – ou compteur-temporisateur – est un périphérique du microcontrôleur dont le registre de comptage augmente de 1 à chaque impulsion d’horloge. Comme la fréquence de l’horloge est connue, compter des impulsions revient à mesurer le temps.

Figure 7.1 interactif – Le timer en marche : choisissez le prédiviseur et observez le compteur TCNT et le drapeau de débordement TOV.

7.1.1Un compteur matériel

Jusqu’ici, pour respecter une durée, le programme attendait avec delay() ou vérifiait sans cesse millis() dans loop(). Un timer est le circuit qui compte le temps à sa place, en parallèle du programme – millis() repose d’ailleurs sur l’un d’eux :

  • Le registre TCNT du timer augmente de 1 à chaque impulsion de l’horloge qui lui est fournie.
  • Il compte tout seul, pendant que le programme fait autre chose : pas de delay(), pas de boucle d’attente.
  • Il prévient le programme par des drapeaux et des interruptions : quand il déborde, ou quand il atteint une valeur de comparaison.

Ses usages sont nombreux : mesurer le temps (millis()), lancer une tâche à intervalle régulier, produire des signaux (PWM, tone()), mesurer une durée (chapitre 9).

Définition – Débordement

Passage d’un compteur de sa valeur maximale à 0. Un timer 8 bits déborde lorsqu’il passe de 255 à 0, un timer 16 bits de 65 535 à 0. Le drapeau TOV (Timer Overflow) passe alors à 1.

7.1.2Le prédiviseur

À 16 MHz, un timer 8 bits déborderait toutes les 16 µs, ce qui est trop rapide pour la plupart des usages. Un prédiviseur divise donc l’horloge par N avant le compteur. La figure 7.1 montre son effet sur un timer 8 bits :

Prédiviseur NDurée d’un pasDébordement tous les
162,5 ns16 µs
80,5 µs128 µs
644 µs1,024 ms (le rythme de millis())
102464 µs16,384 ms

7.1.3Les timers de la Uno et de la Mega

Un timer 8 bits compte de 0 à 255, un timer 16 bits de 0 à 65 535 : il permet des durées 256 fois plus longues, ou plus précises à durée égale. La Mega dispose de quatre timers 16 bits à trois sorties (A, B et C).

Chaque sortie d’un timer – OCnA, OCnB et, sur la Mega, OCnC pour le timer n – est câblée à une broche précise du microcontrôleur : c’est par elle que le timer produit directement un signal, sans intervention du programme. C’est pourquoi analogWrite() ne fonctionne que sur certaines broches : chacune dépend d’un timer, et les broches d’un même timer partagent sa fréquence. Le tableau suivant donne, pour chaque timer, ses broches et son usage par Arduino :

TimerTailleBroches UnoBroches MegaRéglage ArduinoUtilisé par
Timer08 bitsD6 (A), D5 (B)D13 (A), D4 (B)PWM rapide, N = 64 : 976 Hzmillis(), micros(), delay() : ne pas modifier
Timer116 bitsD9 (A), D10 (B)D11, D12, D13phase correcte, N = 64 : 490 HzServo sur la Uno
Timer28 bitsD11 (A), D3 (B)D10 (A), D9 (B)phase correcte, N = 64 : 490 Hztone()
Timer316 bits–D5, D2, D3phase correcte : 490 HzServo (à partir du 25e)
Timer416 bits–D6, D7, D8phase correcte : 490 HzServo (à partir du 37e)
Timer516 bits–D46, D45, D44phase correcte : 490 HzServo sur la Mega

Attention – Conflits

Reprogrammer un timer change la PWM de ses broches et dérègle les fonctions qui l’utilisent. Sur la Mega, on préfère les timers 3, 4 et 5, qui sont libres tant qu’on n’utilise pas de nombreux servomoteurs.

✎ Signaler une erreur dans cette section

Chapitre 7 · Section 7.2

Structure et registres d’un timer

Tous les timers des AVR sont construits sur le même modèle : un prédiviseur, un compteur, deux comparateurs et un générateur de signaux. Une poignée de registres en règle le fonctionnement.

Schéma simplifié d’un timer : prédiviseur, compteur, comparateurs, générateur de signaux et drapeaux.
Figure 7.2 – Schéma simplifié d’un timer : prédiviseur, compteur, comparateurs, générateur de signaux et drapeaux.

7.2.1Les blocs d’un timer

La figure 7.2 suit le chemin de l’horloge :

  1. le prédiviseur, réglé par les bits CS, divise l’horloge de 16 MHz par N ;
  2. la logique de comptage, réglée par les bits WGM (Waveform Generation Mode), fait avancer TCNTn, le remet à 0 ou le fait redescendre selon le mode ;
  3. deux comparateurs testent en permanence l’égalité de TCNTn avec les registres OCRnA et OCRnB ;
  4. le générateur de signaux, réglé par les bits COM, agit sur les sorties OCnA et OCnB à chaque égalité : mettre à 1, à 0 ou basculer ;
  5. les drapeaux du registre TIFRn signalent le débordement (TOVn) et les égalités (OCFnA, OCFnB) ; s’ils sont autorisés dans TIMSKn, ils déclenchent les routines ISR(TIMERn_OVF_vect), ISR(TIMERn_COMPA_vect) et ISR(TIMERn_COMPB_vect).
RegistreRôle
TCNTnvaleur du compteur
TCCRnA/Bmode (WGM), prédiviseur (CS), action sur les sorties (COM)
OCRnA/Bvaleurs de comparaison
ICRncapture, ou TOP réglable (16 bits)
TIMSKnautorisation des interruptions
TIFRndrapeaux TOV, OCFA, OCFB

La lettre n désigne le numéro du timer : TCNT0, TCNT1, TCNT2… Les timers 16 bits de la Mega ont une troisième sortie C, avec son registre OCRnC.

7.2.2Les registres du Timer1

Le Timer1 sert ici d’exemple : c’est un timer 16 bits présent sur les deux cartes, avec les mêmes registres sur la Uno et sur la Mega. Les timers 3, 4 et 5 de la Mega se programment de la même façon, en remplaçant le 1 par leur numéro, avec en plus une troisième sortie C ; les timers 8 bits 0 et 2 suivent le même principe, avec moins de modes.

Les bits des registres TCCR1A, TCCR1B et TIMSK1, et les tableaux des prédiviseurs, des actions sur les sorties et des modes.
Figure 7.3 – Les bits des registres TCCR1A, TCCR1B et TIMSK1, et les tableaux des prédiviseurs, des actions sur les sorties et des modes.

Les bits CS12:10 choisissent l’horloge : 000 arrête le timer, 001 à 101 donnent N = 1, 8, 64, 256 et 1024, et 11x fait compter les fronts de la broche T1 (comptage externe). Les bits COM1x1:0 fixent l’action sur la sortie OC1x en PWM : 00 la déconnecte, 10 donne une PWM non inversée, 11 une PWM inversée ; en mode non PWM, 01 fait basculer la sortie à chaque égalité. Les quatre bits WGM13:10 choisissent l’un des quinze modes du Timer1 :

WGM13:10ModeTOP
0000Normal0xFFFF
0001 à 0011PWM phase correcte 8, 9, 10 bits0x00FF, 0x01FF, 0x03FF
0100CTCOCR1A
0101 à 0111PWM rapide 8, 9, 10 bits0x00FF, 0x01FF, 0x03FF
1000 / 1001PWM phase et fréquence correctesICR1 / OCR1A
1010 / 1011PWM phase correcteICR1 / OCR1A
1100CTCICR1
1110 / 1111PWM rapideICR1 / OCR1A

À savoir

  • Les bits WGM sont répartis sur deux registres : WGM11:10 dans TCCR1A, WGM13:12 dans TCCR1B.
  • Arduino a déjà réglé les timers : on écrit TCCR1A = 0; et TCCR1B = 0; avant de configurer.
  • Timer0 et Timer2 suivent les mêmes principes avec TCCR0A/B et TCCR2A/B, et trois bits WGM (WGM02 et WGM22 dans TCCRnB).
  • Le Timer2 a ses propres prédiviseurs : 1, 8, 32, 64, 128, 256 et 1024.
  • Sur la Mega, les timers 3, 4 et 5 sont identiques au Timer1 (TCCR3A…, sorties A, B et C).

✎ Signaler une erreur dans cette section

Chapitre 7 · Section 7.3

Les modes de fonctionnement

Le mode, choisi par les bits WGM, fixe la façon dont le compteur évolue : jusqu’où il monte, s’il repart à 0 ou redescend, et à quel moment les drapeaux sont levés. Chaque mode correspond à une famille d’applications.

Figure 7.4 interactif – Les modes des timers 8 bits et les quatre façons de compter : choisissez un mode et observez TCNT et la sortie.

7.3.1Quatre façons de compter

On note BOTTOM la valeur 0, MAX la valeur maximale du compteur (255 ou 65 535) et TOP la valeur la plus haute atteinte dans le mode choisi (figure 7.4) :

  • Normal : TCNT compte de 0 à MAX, puis repart à 0 ;
  • CTC (Clear Timer on Compare) : TCNT repart à 0 dès qu’il atteint OCRA. La période se règle finement ; la sortie peut basculer à chaque égalité ;
  • PWM rapide : dent de scie de 0 à TOP. La sortie passe à 1 au début du cycle et à 0 à l’égalité avec OCR ;
  • PWM phase correcte : triangle de 0 à TOP puis de TOP à 0. L’impulsion est centrée dans la période.
WGM2:0Mode (Timer0, Timer2)TOPTOV à
000Normal0xFFMAX
001PWM phase correcte0xFFBOTTOM
010CTCOCRAMAX
011PWM rapide (réglage Arduino du Timer0)0xFFMAX
101PWM phase correcteOCRABOTTOM
111PWM rapideOCRATOP

Les combinaisons 100 et 110 sont réservées. Les timers 16 bits ont quatre bits WGM et quinze modes, dont la PWM phase et fréquence correctes et des modes où TOP est réglé par ICRn.

7.3.2Comparatif et applications

Chaque mode impose sa propre formule de fréquence et laisse régler des grandeurs différentes : la période seule, ou la période et le rapport cyclique. Le choix d’un mode dépend donc d’abord de ce que l’on veut obtenir. Le tableau suivant les compare, pour un timer 16 bits cadencé à 16 MHz, et donne pour chacun ses applications courantes.

ModeComptageFréquence (16 MHz)On règleApplications
Normalde 0 à MAX, puis débordement16 MHz / (N × 65 536)N seulementmesurer une durée en lisant TCNT1, compter des impulsions externes, Input Capture (chapitre 9)
CTCremise à 0 sur égalité16 MHz / (N × (OCR1A + 1)), ÷ 2 en sortie basculéeN et OCR1A : la périodeinterruption périodique (horloge, échantillonnage, multiplexage d’afficheurs), signal carré (buzzer, tone())
PWM rapiderampe montante16 MHz / (N × (TOP + 1))TOP : la fréquence ; OCR : le rapport cycliqueLED, moteur CC, ventilateur 25 kHz, servomoteur 50 Hz, analogWrite() sur D5 et D6
PWM phase correctetriangle16 MHz / (2 × N × TOP)TOP et OCRimpulsions centrées, ponts en H à deux sorties, analogWrite() sur D3, D9, D10, D11
Phase et fréquence correctestriangle, TOP mis à jour en bas16 MHz / (2 × N × TOP)TOP modifiable en marchefréquence variable : moteur pas à pas, son, alimentation à découpage

Quel mode pour quel besoin ?

  • Une action à intervalle régulier : CTC + interruption sur égalité.
  • Un signal carré : CTC + basculement de OC1A.
  • Un rapport cyclique : PWM rapide (fréquence la plus haute).
  • Un moteur, deux sorties : PWM phase correcte.
  • Une fréquence qui change : PWM phase et fréquence correctes.

✎ Signaler une erreur dans cette section

Chapitre 7 · Section 7.4

Paramétrer et calculer

Configurer un timer revient à choisir un mode, un prédiviseur, une valeur de TOP ou de comparaison, l’action sur la sortie et les interruptions. Le calcul des valeurs suit toujours la même démarche.

Figure 7.5 interactif – Générateur de programme : choisissez le mode, le prédiviseur, TOP, la sortie et l’interruption du Timer1, et lisez le programme correspondant.

7.4.1Le paramétrage

Le générateur de la figure 7.5 écrit le programme de configuration du Timer1 pour n’importe quelle combinaison de réglages. Tous les programmes produits ont la même structure : effacer TCCR1A et TCCR1B, mettre la sortie en OUTPUT si elle est utilisée, écrire TOP et OCR1A, puis écrire les bits COM et WGM, les bits CS – qui démarrent le timer – et enfin TIMSK1.

7.4.2Les formules

Figure 7.6 interactif – Calculateur : choisissez le timer et la durée voulue, et comparez les prédiviseurs.

Avec une horloge de 16 MHz :

durée d’un pas = N / 16 MHz
débordement = (MAX + 1) × N / 16 MHz
CTC : T = (OCR + 1) × N / 16 MHz  ⟹  OCR = T × 16 MHz / N − 1

Pour obtenir une durée T, on choisit N, on calcule OCR avec la dernière formule et on l’arrondit à l’entier. Il faut OCR ≤ 255 pour un timer 8 bits et OCR ≤ 65 535 pour un timer 16 bits. On choisit le plus petit N qui convient : la résolution est alors la meilleure et l’erreur d’arrondi la plus faible (figure 7.6).

Exemple : une période de 1 ms avec le Timer1. Il faut 1 ms × 16 MHz = 16 000 pas, ce qui tient dans 16 bits : N = 1 suffit, et OCR1A = 16 000 − 1 = 15 999. Avec le Timer2 (8 bits), 16 000 pas ne tiennent pas : avec N = 64, il faut 250 pas, donc OCR2A = 249.

Exercices

1. Le Timer2 est réglé avec N = 1024 en mode normal. Toutes les combien de temps déborde-t-il ?

256 × 1 024 / 16 MHz = 16,384 ms, soit environ 61 débordements par seconde.

2. Quels prédiviseur et OCR1A choisir pour une interruption toutes les 50 ms avec le Timer1 en CTC ?

50 ms × 16 MHz = 800 000 pas : trop pour N = 1 et N = 8 (100 000 > 65 536). Avec N = 64 : 12 500 pas, donc OCR1A = 12 499, sans erreur d’arrondi.

3. Quelle valeur faut-il écrire dans TCCR1B pour le mode 4 (CTC, TOP = OCR1A) avec N = 256 ?

Mode 4 = WGM13:10 = 0100 : WGM12 = 1, dans TCCR1B. N = 256 : CS12:10 = 100. TCCR1B = (1 << WGM12) | (1 << CS12);, soit 0x0C. TCCR1A reste à 0.

✎ Signaler une erreur dans cette section

Chapitre 7 · Partie II

Les modes en détail

Chaque mode est présenté avec sa simulation, ses formules et un exemple de configuration par les registres.

Chapitre 7 · Section 7.5

Modes normal et CTC

Les modes normal et CTC servent à mesurer le temps et à déclencher des actions périodiques. Le second est presque toujours préférable au premier dès qu’une période précise est nécessaire.

Figure 7.7 interactif – Simulation du mode normal sur un timer 8 bits : réglez OCRA, le prédiviseur et l’action sur la sortie.

7.5.1Mode normal

TCNT compte de 0 à MAX (255 ou 65 535), puis repart à 0 : c’est le débordement. Le drapeau TOV passe à 1 et lance ISR(TIMERn_OVF_vect) si le bit TOIEn est à 1. La période ne dépend que de N. Pour obtenir une durée précise, il faut recharger TCNT dans la routine d’interruption, de façon que le compteur n’ait plus qu’un nombre donné de pas à faire avant de déborder. Pour une seconde avec le Timer1 :

void setup() {
  pinMode(13, OUTPUT);
  TCCR1A = 0;                    // mode normal
  TCCR1B = (1 << CS12);          // N = 256 : 1 pas = 16 µs
  TCNT1  = 3036;                 // 65536 - 62500
  TIMSK1 = (1 << TOIE1);         // interruption de débordement
}
ISR(TIMER1_OVF_vect) {
  TCNT1 = 3036;                  // 62 500 pas × 16 µs = 1 s
  digitalWrite(13, !digitalRead(13));
}
void loop() { }

Cette technique a un défaut : le temps qui s’écoule entre le débordement et l’écriture de TCNT dans l’ISR s’ajoute à chaque période. Le mode CTC l’évite.

7.5.2Mode CTC

Figure 7.8 interactif – Simulation du mode CTC : réglez OCRA et observez la remise à zéro et le basculement de la sortie.

En mode CTC, TCNT repart à 0 dès qu’il atteint OCRnA, qui devient le TOP. Le drapeau OCFnA lance ISR(TIMERn_COMPA_vect) si le bit OCIEnA est à 1 : on obtient une interruption périodique, réglée finement, sans recharger TCNT. Avec COMnA = 01, la sortie OCnA bascule à chaque égalité et produit un signal carré de fréquence :

f = 16 MHz / (2 × N × (OCR + 1))

Le programme suivant obtient une interruption par milliseconde avec le Timer2 :

volatile unsigned long ms = 0;
void setup() {
  TCCR2A = (1 << WGM21);          // CTC, TOP = OCR2A
  TCCR2B = (1 << CS22);           // N = 64 (code 100 sur le Timer2)
  OCR2A  = 249;                   // 250 pas × 4 µs = 1 ms
  TIMSK2 = (1 << OCIE2A);         // interruption sur égalité A
}
ISR(TIMER2_COMPA_vect) { ms++; }  // 1 000 fois par seconde
void loop() { }

Attention

tone() utilise aussi le Timer2 : ce programme et tone() ne peuvent pas coexister.

✎ Signaler une erreur dans cette section

Chapitre 7 · Section 7.6

Les modes PWM

En mode PWM, le timer produit seul un signal rectangulaire dont la fréquence dépend de TOP et le rapport cyclique de OCR. C’est ainsi que fonctionne analogWrite() ; en réglant soi-même les registres, on choisit librement la fréquence et la résolution.

Figure 7.9 interactif – Simulation de la PWM rapide : réglez OCR, TOP, le prédiviseur et le sens de la sortie.

7.6.1PWM rapide

TCNT compte de 0 à TOP (255, ou OCRnA, ou ICRn pour un timer 16 bits), puis repart à 0 : une dent de scie. En sortie non inversée (COM = 10), la sortie passe à 1 au début du cycle et à 0 à l’égalité avec OCR (figure 7.9).

f = 16 MHz / (N × (TOP + 1))     rapport cyclique = (OCR + 1) / (TOP + 1)

OCR = 0 donne encore une impulsion d’un pas : la PWM rapide ne descend pas exactement à 0 %. C’est le réglage d’Arduino pour le Timer0 : N = 64, TOP = 255, soit 976 Hz. Pour une PWM à 62,5 kHz sur D3 (OC2B) avec le Timer2 :

pinMode(3, OUTPUT);
TCCR2A = (1 << COM2B1)                     // non inversé
       | (1 << WGM21) | (1 << WGM20);      // PWM rapide, TOP = 255
TCCR2B = (1 << CS20);                      // N = 1
OCR2B  = 64;                               // (64 + 1) / 256 ≈ 25 %

7.6.2PWM phase correcte

Figure 7.10 interactif – Simulation de la PWM phase correcte : le triangle et l’impulsion centrée.

TCNT monte de 0 à TOP puis redescend à 0 : un triangle. En sortie non inversée, la sortie passe à 0 à l’égalité en montant et à 1 à l’égalité en descendant : l’impulsion est centrée dans la période (figure 7.10).

f = 16 MHz / (2 × N × TOP)     rapport cyclique = OCR / TOP

Le rapport cyclique va de 0 % à 100 % exactement, mais la fréquence est deux fois plus faible qu’en PWM rapide. C’est le réglage d’Arduino pour les timers 1 et 2 : N = 64, TOP = 255, soit 490 Hz. Pour un moteur, une fréquence inaudible de 31,4 kHz sur D3 :

pinMode(3, OUTPUT);
TCCR2A = (1 << COM2B1) | (1 << WGM20);   // phase correcte, TOP = 255
TCCR2B = (1 << CS20);                     // N = 1 : 16 MHz / 510
OCR2B  = 128;                             // ≈ 50 %

7.6.3PWM phase et fréquence correctes

Changement de fréquence en marche : mise à jour au sommet (en haut) et en bas du triangle (en bas).
Figure 7.11 – Changement de fréquence en marche : mise à jour au sommet (en haut) et en bas du triangle (en bas).

Ce mode est propre aux timers 16 bits (Timer1, et Timers 3 à 5 sur la Mega). Le compteur décrit le même triangle qu’en PWM phase correcte, avec un TOP réglé par ICRn (mode 8) ou OCRnA (mode 9). La différence porte sur l’instant où les nouvelles valeurs de TOP et d’OCR sont prises en compte : en bas du triangle (BOTTOM), et non au sommet. Quand on change la fréquence en marche, le cycle en cours en phase correcte monte avec l’ancien TOP et redescend avec le nouvel OCR : l’impulsion est décalée. En phase et fréquence correctes, chaque période reste symétrique (figure 7.11). Ce mode convient donc à un moteur pas à pas, un émetteur à ultrasons ou un signal audio de fréquence variable.

// 1 kHz, 25 % sur D9 (Uno) ou D11 (Mega) : OC1A
pinMode(9, OUTPUT);
TCCR1A = (1 << COM1A1);                   // non inversé
TCCR1B = (1 << WGM13) | (1 << CS11);     // mode 8, N = 8
ICR1   = 1000;                            // f = 16 MHz / (2 × 8 × 1000) = 1 kHz
OCR1A  = 250;                             // 250 / 1000 = 25 %

Exercices

1. Quelle est la fréquence PWM sur D5 d’une Uno avec le réglage d’Arduino ? Et sur D9 ?

D5 est sur le Timer0, en PWM rapide avec N = 64 et TOP = 255 : 16 MHz / (64 × 256) ≈ 976,6 Hz. D9 est sur le Timer1, en phase correcte : 16 MHz / (2 × 64 × 255) ≈ 490,2 Hz.

2. On veut une PWM de 20 kHz sur le Timer1 en PWM rapide avec TOP = ICR1 et N = 1. Quelle valeur donner à ICR1 ? Combien de niveaux de rapport cyclique obtient-on ?

ICR1 = 16 MHz / 20 kHz − 1 = 799. OCR1A peut prendre 800 valeurs (0 à 799) : une résolution d’environ 9,6 bits, bien meilleure que les 256 niveaux d’analogWrite().

3. Un servomoteur attend une période de 20 ms. Configurez le Timer1 en PWM rapide, mode 14, pour la produire.

Avec N = 1, il faudrait 20 ms × 16 MHz = 320 000 pas : trop pour 16 bits. Avec N = 8, il n’en faut que 40 000, qui tiennent : ICR1 = 40 000 − 1 = 39 999, et chaque pas dure 0,5 µs. Une impulsion de 1,5 ms correspond alors à OCR1A = 3 000 − 1 = 2 999.

✎ Signaler une erreur dans cette section

Chapitre 7 · Partie III

Programmer

Les timers sont partagés avec le cœur Arduino et les bibliothèques. Quelques précautions évitent des conflits difficiles à diagnostiquer.

Chapitre 7 · Section 7.7

Précautions

Un timer reprogrammé à la légère peut fausser toutes les durées d’un programme, désactiver la PWM d’une broche ou empêcher une bibliothèque de fonctionner. Les règles suivantes évitent ces pièges.

7.7.1Ne pas toucher au Timer0

millis(), micros() et delay() comptent ses débordements, toutes les 1,024 ms (chapitre 4). Le reprogrammer fausse toutes les durées du programme et la PWM des broches 5 et 6 (4 et 13 sur la Mega).

7.7.2Un timer, un usage

Reprogrammer un timer change le comportement d’analogWrite() sur ses broches. Plusieurs fonctions et bibliothèques réservent un timer : Servo (Timer1 sur la Uno, Timer5 sur la Mega), tone() (Timer2), certaines bibliothèques comme IRremote. Sur la Mega, on utilise de préférence les timers 3, 4 et 5.

7.7.3Lire un registre 16 bits

Les registres 16 bits TCNT1, OCR1A ou ICR1 sont lus et écrits en deux octets, en passant par un registre temporaire commun à tout le timer. Si une ISR accède à l’un de ces registres entre les deux octets, la valeur est faussée. On protège donc la lecture comme au chapitre 6 :

unsigned int lireTCNT1() {
  noInterrupts();               // lecture en 2 octets
  unsigned int v = TCNT1;       // protégée d’une ISR
  interrupts();
  return v;
}

Bonnes habitudes

  • Mettre TCCRnA et TCCRnB à 0 avant de configurer : Arduino les a déjà réglés.
  • ISR courte, variables partagées en volatile (chapitre 6).
  • Écrire TOP et OCR avant les bits CS : le timer démarre dès que CS ≠ 000.
  • Pour éviter les registres, les bibliothèques TimerOne et TimerInterrupt offrent des fonctions simples.

✎ Signaler une erreur dans cette section

Chapitre 7 · Partie IV

Exemples

Quatre programmes complets, chacun illustré par une animation en temps réel : deux interruptions périodiques et deux générateurs de signaux.

Chapitre 7 · Section 7.8

Interruptions périodiques

Le mode CTC avec interruption sur égalité est l’outil de base pour exécuter une action à intervalle parfaitement régulier, indépendamment de ce que fait loop().

Figure 7.12 interactif – Une interruption par seconde avec le Timer1 en CTC : le compteur TCNT1 en temps réel.

7.8.1Une interruption par seconde

Avec N = 1024, le Timer1 avance de 16 MHz / 1024 = 15 625 pas par seconde. En CTC avec OCR1A = 15 624, il déclenche donc une interruption par seconde exactement :

const int LED = 13;
volatile bool seconde = false;

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
  noInterrupts();
  TCCR1A = 0; TCCR1B = 0;
  OCR1A  = 15624;                          // 15 625 pas = 1 s
  TCCR1B = (1 << WGM12)                    // CTC, TOP = OCR1A
         | (1 << CS12) | (1 << CS10);      // N = 1024 : 1 pas = 64 µs
  TIMSK1 = (1 << OCIE1A);                  // interruption sur égalité A
  interrupts();
}
ISR(TIMER1_COMPA_vect) {
  digitalWrite(LED, !digitalRead(LED));    // toutes les secondes
  seconde = true;
}
void loop() {
  if (seconde) {
    seconde = false;
    Serial.println("Une seconde de plus");
  }
}

Le programme principal reste libre : loop() ne fait qu’afficher. La précision dépend cependant de l’oscillateur de la carte, de l’ordre de quelques centaines de ppm pour le résonateur de la Uno ; pour une vraie horloge, on utilise un module temps réel comme le DS3231 (chapitre 5).

7.8.2Une base de temps de 1 ms

Figure 7.13 interactif – Une base de temps de 1 ms et un calculateur de période pour les Timers 1 et 2.
volatile unsigned long ticks = 0;
void setup() {
  noInterrupts();
  TCCR1A = 0;
  TCCR1B = (1 << WGM12) | (1 << CS11) | (1 << CS10);   // CTC, ÷ 64
  OCR1A  = 249;                    // 250 pas de 4 µs = 1 ms
  TIMSK1 = (1 << OCIE1A);          // interruption de comparaison A
  interrupts();
}
ISR(TIMER1_COMPA_vect) {
  ticks++;                         // appelée toutes les 1 ms exactement
}
unsigned long lireTicks() {        // lecture atomique (32 bits)
  noInterrupts();
  unsigned long t = ticks;
  interrupts();
  return t;
}

Contrairement à millis(), qui avance par pas de 1 ou 2 (chapitre 4), cette base de temps est exacte à chaque milliseconde. La période ne dépend plus du programme : c’est l’outil idéal pour un échantillonnage régulier (chapitre 8) ou un régulateur numérique.

✎ Signaler une erreur dans cette section

Chapitre 7 · Section 7.9

Produire des signaux

En mode CTC avec basculement de la sortie, ou en mode PWM, le timer fabrique seul le signal sur une broche. Le processeur n’intervient que pour changer les réglages.

Figure 7.14 interactif – Un signal carré de 1 kHz produit par le Timer1, et le calcul d’OCR1A pour une fréquence quelconque.

7.9.1Un signal carré de 1 kHz sans programme

void setup() {
  pinMode(9, OUTPUT);                       // OC1A (D11 sur la Mega)
  TCCR1A = 0; TCCR1B = 0;
  OCR1A  = 999;                             // f = 16 MHz / (2 × 8 × 1000)
  TCCR1A = (1 << COM1A0);                   // OC1A bascule à chaque égalité
  TCCR1B = (1 << WGM12) | (1 << CS11);      // CTC, N = 8
}
void loop() { }                             // rien : le timer produit le signal seul

// Pour changer de fréquence (N = 8 : de 15,3 Hz à 1 MHz)
void frequence(unsigned long f) {
  OCR1A = 16000000UL / (16UL * f) - 1;
}

Une période du signal correspond à deux égalités : la sortie passe à 1 à la première, à 0 à la seconde. Contrairement à tone(), qui bascule la broche dans une routine d’interruption, le signal est fabriqué par le matériel : aucune charge pour le processeur et aucune gigue.

7.9.2Une PWM à 25 kHz pour un ventilateur

Figure 7.15 interactif – Une PWM à 25 kHz réglée par un potentiomètre, avec le Timer1 en PWM rapide (mode 14).
void setup() {
  pinMode(9, OUTPUT);                       // OC1A (D11 sur la Mega)
  TCCR1A = 0; TCCR1B = 0;
  ICR1   = 639;                             // 16 MHz / 640 = 25 kHz
  TCCR1A = (1 << COM1A1) | (1 << WGM11);    // non inversé, mode 14
  TCCR1B = (1 << WGM13) | (1 << WGM12)
         | (1 << CS10);                     // N = 1
}
void loop() {
  OCR1A = map(analogRead(A0), 0, 1023, 0, 639);   // vitesse
  delay(50);
}

Pourquoi ne pas utiliser analogWrite() ? À 490 Hz, le moteur siffle. À 25 kHz, la fréquence est inaudible ; c’est aussi la valeur prévue par la norme des ventilateurs de PC à quatre fils. La résolution passe en outre à 640 pas, contre 256. Le ventilateur est alimenté en 12 V à part, les masses sont reliées, et D9 attaque l’entrée PWM du ventilateur.

Exercices

1. Avec le programme du signal carré, quelle valeur donner à OCR1A pour obtenir un La à 440 Hz ? Quelle fréquence obtient-on réellement ?

OCR1A = 16 000 000 / (16 × 440) − 1 ≈ 2 271,7 − 1 : on prend 2 272 − 1 = 2 271. Fréquence obtenue : 16 MHz / (16 × 2 272) ≈ 440,1 Hz.

2. Modifiez la base de temps de 1 ms pour une période de 100 µs (échantillonnage à 10 kHz).

100 µs × 16 MHz = 1 600 pas : N = 1 suffit. TCCR1B = (1 << WGM12) | (1 << CS10); et OCR1A = 1599;.

3. Sur une Mega, on veut garder le Timer1 libre pour une bibliothèque et produire la PWM à 25 kHz avec le Timer3. Quelle broche et quels registres utiliser ?

OC3A est sur D5. On reprend le même programme en remplaçant tous les registres et bits du Timer1 par ceux du Timer3 : ICR3, TCCR3A (COM3A1, WGM31), TCCR3B (WGM33, WGM32, CS30) et OCR3A, avec pinMode(5, OUTPUT).

✎ Signaler une erreur dans cette section

Chapitre 7 · Partie V

Évaluation et ressources

Une synthèse des modes et des règles du chapitre, un questionnaire et les sources pour aller plus loin.

Chapitre 7 · Section 7.10

À retenir et QCM

Le tableau suivant résume les modes des timers et leurs formules. Le questionnaire de la figure 7.16 permet de vérifier que les notions sont acquises.

ModeComptageFréquenceUsage typique
Normal0 → MAX, débordement16 MHz / (N × (MAX + 1))mesure du temps, millis()
CTC0 → OCRA, remise à 0interruption : 16 MHz / (N × (OCR + 1))interruption périodique, signal carré
PWM rapide0 → TOP, dent de scie16 MHz / (N × (TOP + 1))PWM haute fréquence, ventilateur, LED
PWM phase correcte0 → TOP → 0, triangle16 MHz / (2 × N × TOP)moteurs, impulsions centrées
Phase et fréq. correctestriangle, mise à jour en bas16 MHz / (2 × N × TOP)fréquence variable (16 bits)

Bonnes habitudes

  • Prédiviseur : Plus petit N possible pour la meilleure précision.
  • Registres : WGM : mode · CS : prédiviseur · COM : sortie · TIMSK : interruptions.
  • Timer0 : Réservé à millis() et delay() : ne pas le modifier.
  • Mega : Timers 3, 4, 5 (16 bits) libres pour vos montages.

7.10.1Se tester

Le QCM comporte vingt et une questions. Choisissez une réponse à la souris ou avec les touches 1 à 4, puis validez avec Entrée. En fin de questionnaire, chaque question manquée renvoie à la section qui donne les explications.

Figure 7.16 interactif – QCM d’évaluation du chapitre 7.

✎ Signaler une erreur dans cette section

Chapitre 7 · Section 7.11

Sources et références

Les chapitres « Timer/Counter » des fiches techniques font foi pour les registres et les modes ; les articles cités détaillent les réglages d’Arduino et donnent de nombreux exemples.

Fiches techniques

Arduino

Pour aller plus loin

✎ Signaler une erreur dans cette section