Entrées analogiques et capteurs

Le CAN — Convertisseur Analogique-Numérique

Le monde réel est analogique : une tension varie en continu entre 0 V et 5 V. L'Arduino ne comprend que des nombres entiers. C'est le rôle du CAN (Convertisseur Analogique-Numérique) de transformer cette tension en une valeur numérique utilisable dans ton programme.

Le CAN de l'Arduino Uno est un convertisseur 10 bits. Il divise la plage 0–5 V en 2¹⁰ = 1024 niveaux, soit des valeurs entières de 0 à 1023.

• 0 V → valeur 0
• 2,5 V → valeur ~512
• 5 V → valeur 1023

Les broches analogiques de l'Arduino Uno sont notées A0, A1, A2, A3, A4 et A5 — six entrées au total. Ces broches ne peuvent lire qu'une tension ; elles ne génèrent pas de signal.

analogRead(pin) — lire une tension

La fonction analogRead(pin) lit la tension présente sur une broche analogique et renvoie un entier entre 0 et 1023. La lecture prend environ 100 µs, ce qui permet environ 10 000 lectures par seconde.

// Lire la tension sur A0
int valeur = analogRead(A0);

// Convertir en tension (en millivolts)
float tension = valeur * (5000.0 / 1023.0);  // résultat en mV

Serial.print("Valeur brute : ");
Serial.println(valeur);
Serial.print("Tension (mV) : ");
Serial.println(tension);

Pas besoin de configurer la broche avec pinMode() pour une lecture analogique — les broches A0–A5 sont en entrée analogique par défaut.

Potentiomètre — brancher et lire

Un potentiomètre est une résistance variable réglée par un bouton rotatif ou un curseur. Il possède trois broches :

• Broche 1 → 5 V
• Broche centrale (curseur) → broche A0 de l'Arduino
• Broche 3 → GND

En tournant le potentiomètre, la tension sur le curseur varie de 0 V à 5 V. La fonction map() permet de convertir cette valeur brute (0–1023) vers n'importe quelle plage utile.

// Potentiomètre sur A0 → contrôle de la luminosité d'une LED sur pin 9
int potPin  = A0;
int ledPin  = 9;

void setup() {
  Serial.begin(9600);
}

void loop() {
  int brut       = analogRead(potPin);           // 0 – 1023
  int luminosite = map(brut, 0, 1023, 0, 255); // 0 – 255 pour PWM
  analogWrite(ledPin, luminosite);
  Serial.print("Brut : ");
  Serial.print(brut);
  Serial.print("\tLuminosité : ");
  Serial.println(luminosite);
  delay(50);
}

Capteur de température NTC (thermistance)

Une thermistance NTC (Negative Temperature Coefficient) est une résistance dont la valeur diminue quand la température augmente. On la câble en diviseur de tension avec une résistance fixe de 10 kΩ.

• 5 V → résistance fixe R1 = 10 kΩ → point de mesure → NTC → GND
• Le point de mesure se connecte à A0

La température s'obtient via la loi de Steinhart-Hart simplifiée (approximation du modèle β) :

// Thermistance NTC 10k sur A0, résistance série R1 = 10 000 Ω
const float R1        = 10000.0;  // résistance fixe en Ω
const float BETA      = 3950.0;   // coefficient β de la thermistance
const float T0        = 298.15;   // 25 °C en Kelvin
const float R0        = 10000.0;  // résistance nominale à 25 °C

void setup() {
  Serial.begin(9600);
}

void loop() {
  int   brut = analogRead(A0);

  // Calculer la résistance de la NTC
  float Rntc = R1 * (1023.0 / brut - 1.0);

  // Équation de Steinhart-Hart simplifiée (modèle β)
  float tempK = 1.0 / (1.0/T0 + (1.0/BETA) * log(Rntc / R0));
  float tempC = tempK - 273.15;

  Serial.print("Température : ");
  Serial.print(tempC, 1);
  Serial.println(" °C");
  delay(1000);
}

Capteur LM35 — 10 mV/°C

Le LM35 est un capteur de température à sortie analogique linéaire. Sa tension de sortie vaut exactement 10 mV par degré Celsius : à 25 °C il délivre 250 mV, à 0 °C il délivre 0 mV. Le branchement est simple : VCC sur 5 V, GND sur GND, et la sortie Vout directement sur A0.

// LM35 sur A0 — référence 5 V (AREF interne)
void setup() {
  Serial.begin(9600);
}

void loop() {
  int   brut    = analogRead(A0);

  // Tension en mV : brut * (5000 mV / 1023)
  float mV      = brut * (5000.0 / 1023.0);

  // LM35 : 10 mV = 1 °C
  float tempC   = mV / 10.0;

  Serial.print("LM35 : ");
  Serial.print(tempC, 1);
  Serial.println(" °C");
  delay(1000);
}

Le LM35 est très pratique pour débuter : pas de calibration, pas de calcul complexe. Sa précision est de ±0,5 °C sur la plage 2–150 °C. Pour des mesures entre 0 °C et 50 °C à l'intérieur, c'est amplement suffisant.

Capteur de lumière LDR

Une LDR (Light Dependent Resistor, ou photorésistance) voit sa résistance diminuer lorsque la lumière augmente : en pleine lumière elle peut tomber à quelques centaines d'ohms ; dans l'obscurité elle peut dépasser 1 MΩ.

On la câble en diviseur de tension avec une résistance de rappel de 10 kΩ :

• 5 V → LDR → point de mesure → 10 kΩ → GND
• Le point de mesure se connecte à A0

Plus la lumière est forte, plus la résistance de la LDR est faible, plus la tension au point de mesure est élevée → la valeur lue par analogRead() est grande.

// LDR sur A0, résistance de rappel 10 kΩ vers GND
void setup() {
  Serial.begin(9600);
}

void loop() {
  int lumiere = analogRead(A0);  // 0 = obscurité, 1023 = pleine lumière

  Serial.print("Lumière : ");
  Serial.print(lumiere);

  // Afficher un label qualitatif
  if (lumiere < 200) {
    Serial.println("  → Obscurité");
  } else if (lumiere < 600) {
    Serial.println("  → Lumière ambiante");
  } else {
    Serial.println("  → Pleine lumière");
  }
  delay(500);
}

La fonction map()

map(valeur, entreeMin, entreeMax, sortieMin, sortieMax) remplace une valeur d'une plage d'entrée vers une plage de sortie proportionnellement. Elle est indispensable pour adapter les lectures analogiques brutes (0–1023) à la plage dont tu as besoin.

// map() — exemples pratiques

// Potentiomètre → angle de servo (0 à 180°)
int brut  = analogRead(A0);
int angle = map(brut, 0, 1023, 0, 180);

// LDR → niveau de luminosité LED PWM (inversé : lumière = LED éteinte)
int lum   = analogRead(A0);
int led   = map(lum, 0, 1023, 255, 0);  // plage inversée
analogWrite(9, led);

// map() ne clamp pas : si brut > 1023, le résultat dépassera sortieMax
// Utilise constrain() pour limiter : constrain(valeur, min, max)
int safe  = constrain(map(brut, 0, 1023, 0, 255), 0, 255);

Afficher les valeurs sur le moniteur série

Le Moniteur Série de l'IDE Arduino (icône loupe, raccourci Ctrl+Shift+M) affiche les données envoyées par Serial.println(). Pour tracer des courbes en temps réel, utilise le Traceur Série (Ctrl+Shift+L) en envoyant des valeurs numériques séparées par des tabulations.

// Envoyer plusieurs canaux pour le Traceur Série
void loop() {
  int pot     = analogRead(A0);
  int ldr     = analogRead(A1);
  int lm35raw = analogRead(A2);
  float tempC = lm35raw * (5000.0 / 1023.0) / 10.0;

  // Format "label:valeur" pour le Traceur Série
  Serial.print("Potentiometre:");
  Serial.print(pot);
  Serial.print("\tLumiere:");
  Serial.print(ldr);
  Serial.print("\tTemperature:");
  Serial.println(tempC);

  delay(100);
}