Arduino 2 :
capteurs et actionneurs.

• Convertir une valeur brute de capteur en grandeur physique, avec calibration.
• Expliquer la PWM et l’utiliser pour varier une intensité ou une vitesse.
• Piloter un servo et mesurer une distance par ultrasons.
• Réagir instantanément à un événement avec une interruption.

Matériel : Arduino, potentiomètre, photorésistance + 10 kΩ, LED + 220 Ω, servo SG90, capteur HC-SR04, buzzer piézo.

map(512, 0, 1023, 0, 5) donne 2, pas 2,5 : tout est calculé en long. Pour une tension, faites le calcul en float vous-même. Et map ne borne pas : map(1100, 0, 1023, 0, 100) renvoie 107. Combinez avec constrain.

1. Mesurer le brut dans plusieurs conditions connues (avec un instrument de référence). 2. Tracer, choisir un modèle (linéaire, puissance, exponentiel). 3. Ajuster les coefficients (régression, séance 19). 4. Coder la formule dans la carte. 5. Vérifier sur de nouvelles conditions. Un capteur sans calibration donne des nombres, pas des mesures. Pour un capteur non linéaire sans modèle simple, on interpole dans une table (multiMap).

Produire 2,5 V en continu depuis 5 V, c’est dissiper 2,5 V × I en chaleur dans un transistor (comme un régulateur linéaire). En PWM, le transistor est soit totalement ouvert soit totalement fermé : presque aucune perte. C’est pour cela que tous les variateurs de moteur, les alimentations à découpage et les amplificateurs classe D utilisent la PWM. Le rapport cyclique est la grandeur de commande en robotique.

Le deuxième programme est un système en boucle ouverte : entrée → traitement → sortie, sans vérifier le résultat. Ajoutez une photorésistance qui mesure la lumière de la LED et ajuste la PWM pour maintenir une luminosité constante : boucle fermée, et vous avez un régulateur (séance 29). Sur Uno, analogWrite a 8 bits (256 niveaux) ; l’ESP32 offre 16 bits.

Un SG90 tire jusqu’à 700 mA en pointe : sur le 5 V de l’Arduino, un seul passe ; au-delà, alimentation séparée avec masse commune. Il ne fait que 0–180° (les servos « à rotation continue » sont en fait des moteurs à vitesse commandée). Il n’y a pas de retour de position vers l’Arduino : on suppose qu’il y est arrivé. Plage utile réelle : souvent 10–170°, à calibrer avec writeMicroseconds().

pulseIn bloque jusqu’à 30 ms : dans un robot, on préfère une interruption sur ECHO (diapositive suivante) ou une bibliothèque non bloquante (NewPing). Une surface molle, inclinée ou étroite ne renvoie pas d’écho : d’où les mesures aberrantes, et le filtre médian de la séance 19. Portée pratique : 2 cm à 3 m, cône de 15°. Ne pas mesurer plus de 15 fois par seconde (échos parasites).

Un événement matériel (front sur une broche, timer, octet reçu) suspend loop(), exécute une petite fonction, puis reprend là où on en était. On ne peut pas rater une impulsion de 50 µs d’un encodeur de roue, même si loop() est occupé. Règles : l’ISR doit être très courte ; les variables partagées sont volatile ; pour lire une variable de plus d’un octet, on coupe brièvement les interruptions (sinon on peut lire la moitié haute avant et la moitié basse après une modification). C’est votre première rencontre avec la concurrence au niveau matériel — la séance 20 en Python n’en était que le reflet.

Une bibliothèque Arduino est un dossier avec un .h (déclarations : ce qu’on peut appeler) et un .cpp (le code). Ouvrez Servo.h dans le dossier des bibliothèques : vous y verrez une classe C++ (séance 16 !) avec attach, write. Lire le code des bibliothèques qu’on utilise est la meilleure façon de progresser en C++. tone() utilise un timer matériel et la broche 3/11 devient indisponible en PWM pendant ce temps : les ressources sont comptées.

const byte N = 8;
int tampon[N]; byte indice = 0; long somme = 0;

int lisser(int valeur) {
  somme -= tampon[indice];          // retirer la plus ancienne
  tampon[indice] = valeur;
  somme += valeur;
  indice = (indice + 1) % N;        // tableau circulaire
  return somme / N;
}

void loop() {
  int lumiere = lisser(analogRead(A0));            // 0 sombre … 1023 clair
  int pwm = lumiere > 700 ? 0 : map(lumiere, 0, 700, 255, 0);
  analogWrite(9, constrain(pwm, 0, 255));
  delay(20);
}

Le tableau circulaire est la version C du deque(maxlen=N) : O(1) par mesure, mémoire fixe (16 octets). Notez la somme entretenue plutôt que recalculée.

const byte LED = 9, LDR = A0, POT = A1;
float pwm = 0, Kp = 0.05;

void loop() {
  static unsigned long prochain = 0;
  if (millis() < prochain) return;
  prochain += 20;
  int consigne = analogRead(POT);
  int mesure = analogRead(LDR);
  pwm += Kp * (consigne - mesure);
  pwm = constrain(pwm, 0, 255);
  analogWrite(LED, (int)pwm);
  Serial.print(consigne); Serial.print(","); Serial.print(mesure); Serial.print(","); Serial.println(pwm);
}

C’est un régulateur intégral pur (la commande est la somme des erreurs) : il annule l’erreur statique mais oscille si Kp est grand, traîne s’il est petit. Vous venez de fermer votre première boucle sur du vrai matériel ; la séance 29 en fait la théorie. Le return en tête de loop() est une façon compacte de faire une cadence fixe.

const byte TRIG = 7, ECHO = 2;                    // ECHO sur une broche d'interruption
volatile unsigned long t_debut = 0, duree = 0;
volatile bool pret = false;

void echo_isr() {
  if (digitalRead(ECHO) == HIGH) t_debut = micros();
  else { duree = micros() - t_debut; pret = true; }
}

void declencher() {
  digitalWrite(TRIG, HIGH); delayMicroseconds(10); digitalWrite(TRIG, LOW);
}

void setup() {
  pinMode(TRIG, OUTPUT); pinMode(ECHO, INPUT);
  attachInterrupt(digitalPinToInterrupt(ECHO), echo_isr, CHANGE);
  Serial.begin(115200);
}

// Statistiques en une passe (Welford)
long n = 0; float moyenne = 0, m2 = 0;
void ajouter(float x) { n++; float d = x - moyenne; moyenne += d / n; m2 += d * (x - moyenne); }

void loop() {
  static unsigned long prochain = 0;
  if (millis() >= prochain) { prochain += 60; declencher(); }
  if (pret) {
    noInterrupts(); unsigned long d = duree; pret = false; interrupts();
    float cm = d * 0.01715;
    ajouter(cm);
    if (n % 100 == 0) {
      Serial.print("moyenne "); Serial.print(moyenne, 2);
      Serial.print(" cm  ecart-type "); Serial.println(sqrt(m2 / (n - 1)), 3);
    }
  }
  // loop() reste libre pour tout le reste
}

Écart-type typique : 0,1 à 0,3 cm sur une surface dure. Erreur systématique : souvent +0,5 à 1 cm (décalage du capteur, température) → calibration à deux points : mesurer à 10 cm et 50 cm, ajuster cm = a × brut + b. La formule de Welford calcule la variance sans stocker les mesures et sans erreur d’annulation (Σx² − (Σx)² est numériquement catastrophique en float 32 bits) : c’est une question d’analyse numérique de prépa. Ouverture : la fusion de ce capteur avec un infrarouge (Sharp) qui a d’autres défauts — filtre de Kalman.