Chapitre 9Livre « Arduino sous le capot »

L’Input Capture

Mesurer une période, une fréquence ou une largeur d’impulsion avec l’unité de capture des timers

Mesurer la fréquence d’un capteur, la vitesse d’un moteur ou la durée d’un écho ultrasonore revient toujours à dater précisément les fronts d’un signal. Une interruption externe le fait à quelques microsecondes près, avec un retard qui dépend de ce que fait le programme. L’unité de capture des timers 16 bits le fait au cycle d’horloge près, sans aucune intervention du programme.

Ce chapitre présente le principe de l’Input Capture, les broches et timers qui en disposent, et le choix du prédiviseur. Il détaille ensuite les registres et le filtre antiparasite, puis les trois mesures de base : période et fréquence, largeur d’impulsion et rapport cyclique, durées longues par comptage des débordements. Une comparaison avec pulseIn() et attachInterrupt() précède deux exemples complets : un télémètre à ultrasons et un compte-tours.

Objectifs du chapitre

  • Expliquer le principe de la capture d’un instant par le matériel et son intérêt.
  • Identifier les entrées de capture de la Uno et de la Mega et les conflits avec les fonctions Arduino.
  • Choisir le prédiviseur en fonction de la durée à mesurer et de la précision souhaitée.
  • Configurer l’unité de capture par ses registres et écrire la routine d’interruption.
  • Mesurer une période, une fréquence, une largeur d’impulsion et une durée longue.

Prérequis

Les interruptions et la copie protégée des variables (chapitre 6), les timers et leurs registres (chapitre 7).

Plan du chapitre

  1. Partie I – Principe
  2. 9.1Capturer un instant
  3. 9.2Broches, timers et résolution
  4. Partie II – Registres
  5. 9.3Configurer la capture
  6. Partie III – Mesures
  7. 9.4Mesurer une période et une fréquence
  8. 9.5Largeur d’impulsion et mesures longues
  9. 9.6Comparer les méthodes de mesure
  10. Partie IV – Exemples et évaluation
  11. 9.7Télémètre et compte-tours
  12. 9.8À retenir et QCM
  13. 9.9Sources et références

Chapitre 9 · Partie I

Principe

Pourquoi et comment le timer « photographie » son compteur au moment d’un front, quels timers en sont capables, et comment le prédiviseur règle le compromis entre finesse et plage de mesure.

Chapitre 9 · Section 9.1

Capturer un instant

Pour mesurer le temps d’un signal externe, il faut connaître l’instant exact où il change d’état. La question est de savoir qui note cet instant : le programme, avec un retard variable, ou le matériel, au moment même du front.

Figure 9.1 interactif – Le même signal daté de deux façons : par logiciel dans une ISR, et par l’Input Capture. Changez la charge d’interruptions et tirez un nouveau signal.

9.1.1Logiciel ou matériel ?

Les besoins sont nombreux : fréquence d’un capteur, vitesse de rotation, durée d’un écho ultrasonore, impulsion d’un récepteur de radiocommande. Avec attachInterrupt() et micros() (chapitre 6), l’heure est lue quand la routine d’interruption démarre : quelques microsecondes après le front, et plus encore si une autre interruption est en cours. La résolution de micros() est en outre de 4 µs.

Avec l’Input Capture, c’est le timer lui-même qui « photographie » son compteur au moment du front : la précision est d’un cycle d’horloge (62,5 ns à 16 MHz), et elle ne dépend pas du programme (figure 9.1). C’est la photo-finish d’une course : l’arrivée est enregistrée par l’appareil, pas par le chronométreur.

9.1.2Le principe

Figure 9.2 interactif – Animation de la capture : le Timer1 compte en continu et sa valeur est copiée dans ICR1 à chaque front choisi sur ICP1.
  1. Le Timer1 compte sans s’arrêter.
  2. À chaque front choisi sur l’entrée ICP1 (D8 sur la Uno), le matériel copie la valeur de TCNT1 dans le registre ICR1.
  3. Le drapeau ICF1 passe à 1 ; si le bit ICIE1 est activé, la routine ISR(TIMER1_CAPT_vect) est appelée.
  4. Le programme lit ICR1 quand il veut : la valeur ne bouge plus jusqu’au front suivant.

La durée entre deux fronts est la différence entre deux captures successives. Dans l’animation de la figure 9.2, un tour de compteur dure 65 536 pas et le signal n’en dure que 52 000 : TCNT1 repasse par 0 entre certains fronts, et la seconde capture est alors plus petite que la première. La soustraction sur 16 bits non signés (unsigned int) donne quand même le bon écart, car elle se calcule modulo 65 536 – exactement comme pour millis() au chapitre 4.

Définition – Input Capture

Fonction d’un timer qui copie automatiquement la valeur de son compteur dans un registre de capture (ICRn) au moment d’un front sur une broche dédiée (ICPn), et lève un drapeau qui peut déclencher une interruption.

✎ Signaler une erreur dans cette section

Chapitre 9 · Section 9.2

Broches, timers et résolution

Seuls les timers 16 bits ont une unité de capture, et toutes leurs entrées ne sont pas câblées sur les cartes. Le choix du prédiviseur fixe ensuite la finesse de la mesure et la durée maximale mesurable.

9.2.1Quelles broches, quels timers ?

CarteTimerEntréeBrocheRegistreInterruption
UnoTimer1ICP1 = PB0D8ICR1TIMER1_CAPT_vect
MegaTimer1ICP1 = PD4non câbléeICR1–
Timer3ICP3 = PE7non câbléeICR3–
Timer4ICP4 = PL0D49ICR4TIMER4_CAPT_vect
Timer5ICP5 = PL1D48ICR5TIMER5_CAPT_vect

Les Timers 0 et 2, sur 8 bits, n’ont pas d’entrée de capture. Sur la Mega, les registres ont la même structure : on remplace le chiffre 1 par 4 ou 5 (TCCR4B, ICES4, ICIE4…). Le Timer1 peut aussi capturer sur la sortie du comparateur analogique (bit ACIC du registre ACSR), pour dater le passage d’une tension par un seuil.

Attention – Conflits

Utiliser un timer pour la capture modifie son réglage : les fonctions Arduino qui s’en servent ne fonctionnent plus normalement. Timer1 (Uno) : analogWrite() sur D9 et D10, bibliothèque Servo. Timer4 (Mega) : analogWrite() sur D6, D7, D8. Timer5 (Mega) : analogWrite() sur D44, D45, D46 et Servo. Le Timer0 n’est jamais touché : millis() et delay() continuent de fonctionner.

9.2.2Résolution et plage de mesure

La valeur capturée dans ICR1 est un nombre de pas du Timer1, et la durée d’un pas dépend du prédiviseur. Ce réglage fixe donc à la fois la finesse de la mesure et la plus longue durée mesurable avant que le compteur ne déborde : un petit prédiviseur mesure finement mais sur une courte plage, un grand prédiviseur l’inverse.

Figure 9.3 interactif – Simulateur : choisissez le prédiviseur et la fréquence du signal, et lisez le nombre de pas par période et l’erreur relative.
PrédiviseurCS12..CS10Un pasDébordement après
÷ 100162,5 ns4,1 ms
÷ 80100,5 µs32,8 ms
÷ 640114 µs262 ms
÷ 25610016 µs1,05 s
÷ 102410164 µs4,19 s

Un pas dure N / 16 MHz, et le compteur fait le tour en 65 536 pas. L’erreur sur une mesure est d’environ ±1 pas : plus la durée mesurée contient de pas, plus l’erreur relative est faible (figure 9.3). On choisit donc le plus petit prédiviseur dont la plage couvre la durée à mesurer, ou l’on compte les débordements (section 9.5).

Exercices

1. On veut mesurer un signal de 50 Hz. Quel prédiviseur choisir ? Quelle est l’erreur relative ?

La période vaut 20 ms. ÷ 8 couvre 32,8 ms : c’est le plus petit qui convient. 20 ms correspondent à 40 000 pas de 0,5 µs ; une erreur de ±1 pas représente ±0,0025 %.

2. Sur une Mega, on veut mesurer un signal tout en gardant la PWM sur D6. Quelle entrée de capture utiliser ?

D6 est une sortie PWM du Timer4 : on utilise le Timer5, entrée ICP5 sur D48. Il faut alors renoncer à la PWM sur D44 à D46 et à la bibliothèque Servo.

✎ Signaler une erreur dans cette section

Chapitre 9 · Partie II

Registres

Quatre registres configurent l’unité de capture. On y ajoute un filtre antiparasite, et un configurateur génère le programme pour chaque type de mesure.

Chapitre 9 · Section 9.3

Configurer la capture

La capture utilise les mêmes registres que le reste du timer (chapitre 7) : le timer est laissé en mode normal, et quelques bits supplémentaires choisissent le front, le filtre et l’interruption.

9.3.1Quatre registres à connaître

TCCR1ACOM1A1COM1A0COM1B1COM1B0––WGM11WGM10
TCCR1BICNC1ICES1–WGM13WGM12CS12CS11CS10
TIMSK1––ICIE1––OCIE1BOCIE1ATOIE1
TIFR1––ICF1––OCF1BOCF1ATOV1
  • TCCR1A est mis à 0 : mode normal, sorties OC1A et OC1B déconnectées ;
  • TCCR1B : ICNC1 active le filtre antiparasite ; ICES1 choisit le front (1 = montant, 0 = descendant) ; CS12..10 fixent le prédiviseur ;
  • TIMSK1 : ICIE1 autorise l’interruption de capture, TOIE1 celle de débordement (mesures longues) ;
  • TIFR1 : ICF1 signale une capture. Il est remis à 0 automatiquement à l’entrée de l’ISR, ou en y écrivant 1 ;
  • ICR1 (16 bits) contient la valeur de TCNT1 au moment du front.
noInterrupts();
TCCR1A = 0;                                 // mode normal
TCCR1B = (1 << ICNC1) | (1 << ICES1)       // filtre, front montant
       | (1 << CS11);                       // ÷ 8 : pas de 0,5 µs
TCNT1  = 0;
TIFR1  = (1 << ICF1);                       // effacer un ancien drapeau
TIMSK1 = (1 << ICIE1);                      // interruption de capture
interrupts();

ISR(TIMER1_CAPT_vect) {
  unsigned int instant = ICR1;              // lire au plus tôt
}

Attention

  • Utilisez le mode normal (WGM = 0000) : dans les modes où ICR1 sert de valeur maximale (TOP), la capture est désactivée.
  • Après avoir changé ICES1, effacez ICF1 : le changement de front peut déclencher une fausse capture.

9.3.2Le filtre antiparasite ICNC1

Un fil long ou un moteur proche peuvent créer des pics très brefs sur l’entrée : sans précaution, chacun déclenche une fausse capture, et ICR1 est écrasé par l’instant du parasite. Avec ICNC1 = 1, l’entrée est échantillonnée à chaque cycle d’horloge, et un front n’est accepté que si quatre échantillons successifs sont identiques (figure 9.4).

Le prix à payer est un retard de 4 cycles (250 ns) sur chaque capture. Comme ce retard est toujours le même, il s’annule dans une différence et n’a aucun effet sur une période ou une largeur d’impulsion. Le filtre élimine les pics de moins de 4 cycles ; contre des rebonds plus longs, ceux d’un contact mécanique par exemple, il faut un filtrage RC ou logiciel.

Figure 9.4 interactif – Le filtre antiparasite au niveau des cycles d’horloge : activez ou non le filtre et ajoutez un parasite.

9.3.3Générer un programme de mesure complet

Le configurateur de la figure 9.5 assemble ces réglages et produit un programme complet pour la Uno (Timer1, D8) ou la Mega (Timer4, D49 ou Timer5, D48), et pour trois mesures : période et fréquence, largeur d’impulsion, rapport cyclique. Les sections suivantes expliquent ces programmes.

Figure 9.5 interactif – Configurateur de l’Input Capture : choisissez la carte, la mesure, le prédiviseur et le filtre, et lisez le programme généré.

✎ Signaler une erreur dans cette section

Chapitre 9 · Partie III

Mesures

Trois mesures de base – période, largeur d’impulsion, durée longue – puis une comparaison avec les autres méthodes de mesure disponibles sur Arduino.

Chapitre 9 · Section 9.4

Mesurer une période et une fréquence

La période est l’écart entre deux fronts de même sens. Il suffit de soustraire la capture précédente de la capture actuelle, ce que la routine d’interruption fait à chaque front.

Figure 9.6 interactif – Simulation d’un fréquencemètre : réglez la fréquence réelle et observez les captures, les différences et la fréquence calculée.
volatile unsigned int ancien = 0, periode = 0;
volatile bool nouvelle = false;

ISR(TIMER1_CAPT_vect) {
  unsigned int t = ICR1;
  periode = t - ancien;           // en pas de 0,5 µs
  ancien = t;
  nouvelle = true;
}
void loop() {
  if (nouvelle) {
    noInterrupts();               // copie atomique (16 bits)
    unsigned int p = periode;
    nouvelle = false;
    interrupts();
    float f = 2000000.0 / p;      // 16 MHz / 8 = 2 MHz
    Serial.println(f);
  }
}

Avec un prédiviseur de 8, le timer avance à 2 MHz : la fréquence vaut 2 000 000 divisé par le nombre de pas d’une période. Si le compteur a débordé entre deux fronts, t est inférieur à ancien ; la soustraction sur 16 bits non signés donne quand même le bon écart, tant que la période reste inférieure à 32,8 ms (figure 9.6). La plage s’étend de 31 Hz à quelques dizaines de kilohertz : au-delà, les interruptions deviennent trop rapprochées pour que la routine ait le temps de s’exécuter.

À retenir

durée = (ICR1 − capture précédente) × N / 16 MHz, calculée sur 16 bits non signés. Les variables partagées sont volatile et copiées entre noInterrupts() et interrupts().

✎ Signaler une erreur dans cette section

Chapitre 9 · Section 9.5

Largeur d’impulsion et mesures longues

Pour mesurer une largeur d’impulsion, il faut dater deux fronts de sens opposés avec un seul registre de capture. Pour une durée de plus de 65 536 pas, il faut prolonger le compteur en comptant ses débordements.

Figure 9.7 interactif – Mesure de la largeur d’impulsion et du rapport cyclique d’un signal PWM à 1 kHz.

9.5.1Changer de front à chaque capture

Il n’y a qu’un registre ICR1 : on ne peut attendre qu’un type de front à la fois. On inverse donc ICES1 dans la routine, après chaque capture :

volatile unsigned int montant = 0, periode = 0, largeur = 0;

ISR(TIMER1_CAPT_vect) {
  unsigned int t = ICR1;
  if (TCCR1B & (1 << ICES1)) {          // front montant
    periode = t - montant;
    montant = t;
    TCCR1B &= ~(1 << ICES1);            // prochain : descendant
  } else {                              // front descendant
    largeur = t - montant;
    TCCR1B |= (1 << ICES1);             // prochain : montant
  }
  TIFR1 = (1 << ICF1);                  // effacer la capture parasite
}
// dans loop(), après une copie atomique :
// rapport = 100.0 * largeur / periode;   // en %

Le rapport cyclique s’obtient en divisant la largeur par la période (figure 9.7). La routine doit se terminer avant le front suivant : la largeur mesurable minimale est de quelques microsecondes.

9.5.2Mesures longues : compter les débordements

Figure 9.8 interactif – Une période de plusieurs débordements, et le cas critique d’un front juste après un débordement.

Pour mesurer des durées plus longues que 65 536 pas sans dégrader la résolution, on compte les débordements du timer dans une seconde routine, et l’on forme un instant sur 32 bits :

volatile unsigned int debordements = 0;
volatile unsigned long ancien = 0, periode = 0;

ISR(TIMER1_OVF_vect) {
  debordements++;
}
ISR(TIMER1_CAPT_vect) {
  unsigned int t = ICR1;
  unsigned int d = debordements;
  // débordement survenu juste avant le front, pas encore compté ?
  if ((TIFR1 & (1 << TOV1)) && t < 32768) d++;
  unsigned long instant = ((unsigned long)d << 16) | t;
  periode = instant - ancien;
  ancien = instant;
}
// setup : TIMSK1 = (1 << ICIE1) | (1 << TOIE1);

L’instant vaut débordements × 65 536 + ICR1 : c’est un compteur de 32 bits, qui fait le tour en plus de 35 minutes avec un pas de 0,5 µs. Un cas délicat subsiste : l’interruption de capture est prioritaire sur celle du débordement. Si un front arrive juste après un débordement, la capture est traitée alors que le débordement n’a pas encore été compté ; ICR1 contient une petite valeur, mais debordements a un tour de retard. Le test sur le drapeau TOV1, combiné à une capture inférieure à 32 768, détecte cette situation et corrige le compte (figure 9.8).

Exercices

1. Avec un prédiviseur de 8, on lit largeur = 300 et periode = 2 000. Quels sont la fréquence, la largeur d’impulsion et le rapport cyclique ?

Période : 2 000 × 0,5 µs = 1 ms, soit 1 kHz. Largeur : 300 × 0,5 µs = 150 µs. Rapport cyclique : 300 / 2 000 = 15 %.

2. Pourquoi faut-il écrire ((unsigned long)d << 16) et non (d << 16) ?

d est un unsigned int de 16 bits : décalé de 16 rangs dans un calcul sur 16 bits, il donnerait 0. La conversion en unsigned long fait le calcul sur 32 bits.

✎ Signaler une erreur dans cette section

Chapitre 9 · Section 9.6

Comparer les méthodes de mesure

Arduino offre trois façons de mesurer une impulsion : la fonction pulseIn(), une interruption externe associée à micros(), et l’Input Capture. Chacune a son domaine.

Figure 9.9 interactif – Deux cents mesures d’une impulsion de 1 000 µs par les trois méthodes, avec des interruptions rares ou fréquentes.
pulseIn()attachInterrupt + micros()Input Capture
Bloquantouinonnon
Résolution≈ 1 µs4 µs62,5 ns à 64 µs
Instant mesuréboucle logicielledébut de l’ISR (retard variable)front lui-même (matériel)
BrochestoutesUno : D2, D3 (ou PCINT)Uno : D8 · Mega : D48, D49
Ressourceaucuneune interruption externeun timer 16 bits réservé
Usagemesure ponctuelle simplesignaux lents, compteursmesures précises et régulières

La simulation de la figure 9.9 montre la dispersion des mesures : faible pour pulseIn() tant que rien ne l’interrompt, plus large pour micros() lorsque d’autres interruptions retardent l’ISR, minimale pour la capture. La capture est la seule méthode dont la précision ne dépend pas de ce que fait le programme au moment du front.

✎ Signaler une erreur dans cette section

Chapitre 9 · Partie IV

Exemples et évaluation

Deux applications classiques de la capture – un télémètre à ultrasons et un compte-tours – puis une synthèse, un questionnaire et les sources du chapitre.

Chapitre 9 · Section 9.7

Télémètre et compte-tours

Le télémètre mesure une largeur d’impulsion, le compte-tours une période. Dans les deux cas, les fronts sont datés par le matériel, même lorsque loop() est occupée.

Figure 9.10 interactif – Simulation du télémètre HC-SR04 : réglez la distance et observez la durée de l’écho et la distance calculée.

9.7.1Télémètre à ultrasons HC-SR04

Le capteur HC-SR04 émet une salve d’ultrasons lorsqu’il reçoit une impulsion de 10 µs sur TRIG, puis répond par une impulsion sur ECHO dont la largeur est le temps d’aller-retour du son. ECHO est relié à D8 (ICP1), TRIG à D7 :

const int TRIG = 7;
volatile unsigned int debut = 0, largeur = 0;
volatile bool pret = false;

void setup() {
  Serial.begin(9600);
  pinMode(TRIG, OUTPUT);
  TCCR1A = 0;
  TCCR1B = (1 << ICNC1) | (1 << ICES1) | (1 << CS11) | (1 << CS10);  // ÷ 64 : 4 µs
  TIMSK1 = (1 << ICIE1);
}
ISR(TIMER1_CAPT_vect) {
  if (TCCR1B & (1 << ICES1)) { debut = ICR1; TCCR1B &= ~(1 << ICES1); }   // début
  else { largeur = ICR1 - debut; TCCR1B |= (1 << ICES1); pret = true; }   // fin
  TIFR1 = (1 << ICF1);
}
void loop() {
  digitalWrite(TRIG, HIGH); delayMicroseconds(10); digitalWrite(TRIG, LOW);
  delay(60);                                     // laisser revenir l’écho
  if (pret) {
    noInterrupts(); unsigned int l = largeur; pret = false; interrupts();
    Serial.println(l * 4 / 58.0);                // distance en cm
  }
}

Le son fait l’aller-retour à 343 m/s : 1 cm de distance correspond à 2 cm de trajet, parcourus en 58 µs. La largeur en pas de 4 µs, multipliée par 4 et divisée par 58, donne donc la distance en centimètres. Avec ÷ 64, l’écho le plus long – environ 38 ms en l’absence d’obstacle – tient largement dans la plage de 262 ms (figure 9.10).

9.7.2Compte-tours

Figure 9.11 interactif – Simulation du compte-tours : réglez la vitesse et observez la période entre aimants et la vitesse calculée.

Un capteur à effet Hall placé face à un axe portant deux aimants est relié à D8. Sa sortie à collecteur ouvert tire la broche à 0 V au passage de chaque aimant :

const byte AIMANTS = 2;                     // impulsions par tour
volatile unsigned int ancien = 0, periode = 0;
volatile unsigned long tDernier = 0;        // millis() du dernier front

void setup() {
  Serial.begin(9600);
  pinMode(8, INPUT_PULLUP);                 // sortie collecteur ouvert
  TCCR1A = 0;
  TCCR1B = (1 << ICNC1) | (1 << CS12);      // front descendant, ÷ 256 : 16 µs
  TIMSK1 = (1 << ICIE1);
}
ISR(TIMER1_CAPT_vect) {
  unsigned int t = ICR1;
  periode = t - ancien;
  ancien = t;
  tDernier = millis();
}
void loop() {
  noInterrupts();
  unsigned int p = periode; unsigned long td = tDernier;
  interrupts();
  float tpm = 0;                            // tours par minute
  if (millis() - td < 1000 && p > 0)        // sinon : moteur arrêté
    tpm = 60.0 * 62500.0 / ((float)p * AIMANTS);
  Serial.println(tpm);
  delay(200);
}

Avec ÷ 256, 62 500 pas de 16 µs font une seconde : la vitesse vaut 60 × 62 500 / (periode × AIMANTS) tours par minute. Sans impulsion pendant une seconde, on considère le moteur arrêté ; sinon la dernière période resterait affichée indéfiniment. La plage s’étend d’environ 30 à plus de 10 000 tr/min (figure 9.11).

Exercices

1. Le télémètre mesure largeur = 580. Quelle est la distance ? Quelle est la résolution de la mesure ?

580 × 4 / 58 = 40 cm. Un pas de 4 µs correspond à 4 / 58 ≈ 0,07 cm : la résolution est de moins d’un millimètre, bien meilleure que la précision réelle du capteur (environ 3 mm).

2. Le compte-tours lit periode = 1 250. Quelle est la vitesse ?

tpm = 60 × 62 500 / (1 250 × 2) = 1 500 tr/min.

3. Pourquoi la plage basse du compte-tours est-elle d’environ 30 tr/min ?

Avec ÷ 256, le compteur fait le tour en 1,05 s. Au-delà, la soustraction sur 16 bits ne donne plus le bon écart. Avec deux aimants, une période de 1,05 s entre impulsions correspond à 60 / (2 × 1,05) ≈ 29 tr/min. Pour descendre plus bas, il faut compter les débordements ou augmenter le prédiviseur.

✎ Signaler une erreur dans cette section

Chapitre 9 · Section 9.8

À retenir et QCM

Le tableau suivant résume le fonctionnement et les règles d’utilisation de l’Input Capture. Le questionnaire de la figure 9.12 permet de vérifier que les notions sont acquises.

ÉlémentÀ retenir
PrincipeAu front choisi sur ICPn, le matériel copie TCNTn dans ICRn et met ICFn à 1 (interruption TIMERn_CAPT_vect si ICIEn = 1).
BrochesUno : D8 (Timer1) · Mega : D49 (Timer4), D48 (Timer5)
TCCRnBICNCn : filtre (4 échantillons) · ICESn : 1 = montant, 0 = descendant · CSn2..0 : prédiviseur
Calculdurée = (ICRn − capture précédente) × N / 16 MHz, sur 16 bits non signés
Largeur d’impulsionInverser ICESn dans l’ISR, puis effacer ICFn

Bonnes habitudes

  • Mode normal : Pas de mode où ICRn sert de TOP pendant une capture.
  • Prédiviseur : Le plus petit dont la plage couvre la durée à mesurer.
  • Débordements : Les compter (TOVn) pour des durées plus longues que 65 536 pas.
  • Copie atomique : Lire les variables 16 ou 32 bits entre noInterrupts() et interrupts().

9.8.1Se tester

Le QCM comporte vingt-deux 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 9.12 interactif – QCM d’évaluation du chapitre 9.

✎ Signaler une erreur dans cette section

Chapitre 9 · Section 9.9

Sources et références

La section « Input Capture Unit » des fiches techniques fait foi pour les registres et le filtre ; la référence Arduino décrit les méthodes logicielles avec lesquelles la capture a été comparée.

Fiches techniques

Référence Arduino

Pour aller plus loin

✎ Signaler une erreur dans cette section