// Blink : la LED clignote   1
const int LED = LED_BUILTIN; 2

void setup() {               3
  pinMode(LED, OUTPUT);      4
}

void loop() {                5
  digitalWrite(LED, HIGH);   6
  delay(1000);               7
  digitalWrite(LED, LOW);
  delay(1000);
}

• 1 commentaire, ignoré à la compilation ; /* … */ sur plusieurs lignes ;
• 2 constante nommée (LED_BUILTIN vaut 13 sur Uno) : la broche se change en un seul endroit ;
• 3 setup() s’exécute une fois, à la mise sous tension ou après RESET ;
• 4 pinMode() déclare la broche en sortie ;
• 5 loop() se répète sans fin, aussi vite que possible ;
• 6 HIGH = 5 V : LED allumée ; LOW = 0 V : éteinte ; chaque instruction finit par ; ;
• 7 pause de 1 000 ms ; delay() bloque tout le programme (solution p. 5).

Un croquis est un dossier Blink/ contenant Blink.ino. L’IDE ajoute #include <Arduino.h>, déclare les fonctions (appelables avant leur définition) et fournit main(), ici simplifié :

int main() {
  init();         // minuteries
  setup();
  for (;;) {      // boucle sans fin
    loop();
    if (serialEventRun)
      serialEventRun();  // réception
  }
}

• 1 Brancher la carte avec un câble USB de données (un câble de charge seule ne fait apparaître aucun port).
• 2 Choisir carte et port dans la liste de la barre d’outils, ou Outils › Carte puis Outils › Port (Windows : COM3, COM4…).
• 3 Vérifier Ctrl+R : compile ; erreurs et taille s’affichent dans la zone Sortie.
• 4 Téléverser Ctrl+U : compile puis envoie ; fin normale : « Téléversement fait. »
• 5 Ouvrir le Moniteur série Ctrl+Shift+M au même débit que Serial.begin().

Point de départ sûr : Fichier › Exemples › 01.Basics › Blink. Activer les avertissements : Fichier › Préférences › Avertissements du compilateur : Tout (Aucun par défaut).

Sur Mac : Cmd au lieu de Ctrl.

• 20 mA au plus par broche (Uno R3, Nano) ; 8 mA sur Uno R4.
• Une LED a toujours sa résistance en série.
• Jamais de moteur, relais ou électroaimant directement sur une broche : transistor ou module (p. 2).
• Masse commune : relier les GND de toutes les alimentations.
• Câbler carte débranchée ; vérifier avant de remettre sous tension.
• Carte 5 V (Uno, Nano, Mega) ≠ carte 3,3 V (Nano ESP32…) : jamais 5 V sur une broche 3,3 V.
• Broches 0 et 1 : liaison USB ; les laisser libres pour téléverser.
• Jamais de 230 V sur une plaque d’essai.

Loi d’Ohm : U = R × I · P = U × I. Série : R = R₁ + R₂ ; parallèle : 1/R = 1/R₁ + 1/R₂. Ex. : 5 V aux bornes de 220 Ω → I = 5 / 220 ≈ 22,7 mA.

Le courant ne circule que dans une boucle fermée, du + vers le −, à travers la charge. Une boucle sans résistance est un court-circuit !

R = (U_alim − U_LED) / I. Ex. : 5 V, LED rouge 2 V, 15 mA → (5 − 2) / 0,015 = 200 Ω → prendre la valeur normalisée supérieure, 220 Ω → I ≈ 13,6 mA.

Valeurs typiques : lire la fiche du composant. Anode (+) : patte longue ; cathode (−) : patte courte, côté méplat. Témoin lumineux : 220 Ω à 1 kΩ.

1 2 chiffres · 3 multiplicateur · 4 tolérance (souvent or, ±5 %)

Ne Mangez Rien Ou Je Vous Brûle Votre Grande Barbe : noir → blanc. Ex. : rouge-rouge-marron = 220 Ω ; marron-noir-rouge = 1 kΩ ; jaune-violet-rouge = 4,7 kΩ ; marron-noir-orange = 10 kΩ. Série E12 : 10 12 15 18 22 27 33 39 47 56 68 82.

• Tension (V⎓) : pointes en parallèle sur le composant.
• Courant (A) : multimètre en série, pointe rouge dans la borne A ou mA !
• Résistance, continuité : circuit hors tension.

• 1 les 5 trous d’une demi-colonne (a–e, f–j) sont reliés ;
• 2 rien ne traverse la rainure : on y place les circuits intégrés et les boutons, à cheval ;
• 3 les lignes + et − courent sur la longueur, parfois coupées au milieu des grandes plaques.

Convention : fil rouge pour le +, noir (ou bleu) pour la masse.

Une entrée reliée à rien flotte : elle lit n’importe quoi. On la tire vers un niveau connu. a) résistance interne (20 à 50 kΩ) activée par INPUT_PULLUP : logique inversée ; b) résistance externe de 10 kΩ vers la masse.

Bouton à 4 pattes : elles sont reliées deux à deux ; câbler deux pattes en diagonale pour être sûr.

Symboles de la norme CEI, en usage en Europe ; aux États-Unis, la résistance est dessinée en zigzag.

• Le transistor est un interrupteur commandé : quelques mA dans la base laissent passer le courant du moteur.
• Diode de roue libre, en inverse aux bornes d’un moteur, d’un relais ou d’un électroaimant : elle absorbe la surtension à la coupure.
• Plus de courant : MOSFET logic level (commandable en 5 V, ex. IRLZ44N) ou module tout fait (pont en H, relais, p. 7).
• Alimentation séparée pour la charge, masses reliées.

Faire le bilan des courants ; moteurs, servos et rubans de LED : alimentation à part.

• Potentiomètre : résistance réglable à 3 bornes ; le curseur, au milieu, forme un diviseur (10 kΩ courant).
• LED RVB : 4 pattes ; cathode commune (vers GND) ou anode commune (vers 5 V, logique inversée).
• Condensateur céramique 100 nF, près des circuits intégrés : découplage ; sans polarité.
• Condensateur chimique : réserve d’énergie ; ! polarisé (bande −), peut éclater s’il est inversé.
• Diode 1N4007 : passage dans un seul sens ; la bague marque la cathode.
• Photorésistance, thermistance CTN : leur résistance baisse avec la lumière, avec la chaleur.
• Buzzer actif : son fixe, digitalWrite() ; passif : tone().

Condensateur marqué 104 : 10 suivi de 4 zéros, en pF → 100 000 pF = 100 nF.

• Seuils (ATmega328P sous 5 V) : LOW sous ≈ 1,5 V, HIGH au-dessus de ≈ 3 V ; entre les deux : indéterminé.
• A0 à A5 servent aussi de broches numériques (= 14 à 19).
• Broche 13 : la LED intégrée fausse les lectures avec INPUT_PULLUP !

const int BOUTON = 2;  // vers GND
const int LED = 13;
bool allumee = false;
int avant = HIGH;      // tour précédent

void setup() {
  pinMode(BOUTON, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}

void loop() {
  int etat = digitalRead(BOUTON);
  if (etat == LOW && avant == HIGH) { 1
    allumee = !allumee;
    digitalWrite(LED, allumee);
    delay(20);                        2
  }
  avant = etat;
}

• 1 on réagit au changement (front descendant = appui), pas à l’état ;
• 2 anti-rebond sommaire : un contact « rebondit » quelques ms ; version sans delay() p. 5.

• Jamais plus de 5 V, ni de tension négative, sur une entrée !
• Entrée non câblée : la valeur fluctue ; lecture bruitée : moyenne de plusieurs mesures.
• R4 analogReadResolution(14) : jusqu’à 14 bits (10 par défaut) ; référence interne AR_INTERNAL = 1,5 V.

• Signal carré : la part du temps à 5 V (rapport cyclique) vaut v/255 ; une LED ou un moteur ne « voient » que la moyenne.
• Broches ~3, 5, 6, 9, 10, 11 (Uno R3 et R4) ; 490 Hz, 980 Hz sur 5 et 6 (Uno R3).
• Sur 5 et 6, la valeur 0 n’éteint pas toujours tout à fait (minuterie partagée avec millis()).
• R4 vraie sortie analogique (CNA 12 bits) sur A0 avec analogWrite().

int v = analogRead(A0);     // 0…1023
int lum = map(v, 0, 1023, 0, 255);
analogWrite(9, lum);        // 0…255
int x = map(512, 0, 1023, 0, 255);
                            → 127
int inv = map(v, 0, 1023, 255, 0);
int c = constrain(lum + 50, 0, 255);

map() calcule en entiers (partie décimale tronquée) et ne borne pas : l’associer à constrain(), qui ramène la valeur entre deux bornes. Bornes d’arrivée inversées (255, 0) : sens inversé.

tone() : une seule note à la fois, 31 Hz au minimum ; perturbe la MLI des broches 3 et 11 (sauf Mega).

const int DATA = 11, CLK = 12, LAT = 8;
void afficher(byte motif) {   // Q7…Q0
  digitalWrite(LAT, LOW);
  shiftOut(DATA, CLK, MSBFIRST, motif);
  digitalWrite(LAT, HIGH);  // sorties
}
void setup() {
  pinMode(DATA, OUTPUT);
  pinMode(CLK, OUTPUT);
  pinMode(LAT, OUTPUT);
  afficher(0b10100101);  // 4 sur 8
}

Un bit par sortie ; les 8 changent ensemble quand le verrou (LAT) remonte. Câblage : DS (14), SHCP (11), STCP (12) ; OE (13) à GND, MR (10) à 5 V.

const byte CAPTEUR = 2;   // 2 ou 3
volatile unsigned long compte = 0; 1

void compter() {          2
  compte++;
}

void setup() {
  Serial.begin(9600);
  pinMode(CAPTEUR, INPUT_PULLUP);
  attachInterrupt(
    digitalPinToInterrupt(CAPTEUR),
    compter, FALLING);
}

void loop() {
  noInterrupts();         3
  unsigned long copie = compte;
  interrupts();
  Serial.println(copie);
  delay(1000);
}

• 1 volatile : variable partagée avec l’interruption ;
• 2 routine courte, sans paramètre ni valeur renvoyée ; delay() n’y marche pas, millis() n’y avance pas ; éviter Serial ;
• 3 une variable de plus d’un octet se lit en plusieurs instructions : copie protégée.

Déclencheurs : LOW, CHANGE, RISING (montée), FALLING (descente). Broches : Uno R3 et R4 : 2, 3 ; Mega : 2, 3, 18 à 21 ; Nano Every, Nano ESP32 : toutes.

// Photorésistance : 5 V → A0
// 10 kΩ : A0 → GND ; LED + 220 Ω : 9
const int CAPTEUR = A0, LED = 9;
const int NUIT = 300, JOUR = 400; 1
bool allumee = false;

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int lum = analogRead(CAPTEUR);
  Serial.println(lum);            2
  if (lum < NUIT) allumee = true; 3
  if (lum > JOUR) allumee = false;
  digitalWrite(LED, allumee);
  delay(200);
}

• 1 deux seuils : entre 300 et 400, rien ne change (hystérésis) ; la LED ne papillote pas au crépuscule ;
• 2 lire les valeurs réelles au moniteur ou au traceur série pour régler les seuils ;
• 3 plus de lumière → photorésistance plus faible → tension plus haute sur A0 → lecture plus grande.

Cartes 32 bits (Uno R4, ESP32…) : int = 4 octets, double = 8 octets. Pour un code portable : uint8_t, int16_t, uint32_t… (taille garantie).

struct Mesure {      // type composé
  float temp;
  int humidite;
};
Mesure m = {21.5, 40};

enum Mode { ARRET, AUTO, MANUEL };
Mode mode = AUTO;    // 0, 1, 2

void setup() {
  m.temp = 22.0;     // champ : le point
  if (mode == AUTO) m.humidite = 45;
}

struct regroupe des valeurs liées ; enum donne des noms à des états (voir la machine à états, p. 5).

if (t > 30) {
  ventiler();
} else if (t < 18) {
  chauffer();
} else {
  arreter();
}

switch (mode) {
  case 1:  clignoter(); break;
  case 2:  fixe();      break;
  default: eteindre();
}

for (int i = 0; i < 10; i++) { // 0…9
  Serial.println(i);
}
while (digitalRead(2) == HIGH) {}

• switch : sans break, l’exécution continue dans le cas suivant !
• while vide : attendre l’appui (bloquant) ; do { … } while (…); fait au moins un tour.
• break sort d’une boucle ; continue passe au tour suivant ; return quitte la fonction.

float celsius(float f) {
  return (f - 32) * 5 / 9;
}

void clignoter(int b, int fois) {
  for (int i = 0; i < fois; i++) {
    digitalWrite(b, HIGH); delay(100);
    digitalWrite(b, LOW);  delay(100);
  }
}

void echanger(int &a, int &b) {
  int t = a; a = b; b = t;
}

• return renvoie la valeur : celsius(212) → 100 ; void : ne renvoie rien.
• Les paramètres sont des copies ; avec & (référence), echanger(x, y) modifie bien x et y.

int total = 0;       // globale

void loop() {
  int n = 0;         // locale
  static int k = 0;  // statique
  n++;               // vaut toujours 1
  k++;               // 1, 2, 3…
}

Globale : visible partout, existe tout le temps. Locale : visible dans son bloc { }, recréée à chaque passage. Statique : locale qui garde sa valeur d’un appel à l’autre. Locale non initialisée : valeur imprévisible !

int broches[] = {3, 5, 6, 9};
const int N = sizeof(broches)
            / sizeof(broches[0]);  // 4
for (int i = 0; i < N; i++) {
  pinMode(broches[i], OUTPUT);
}

char nom[8] = "Uno";   // + '\0' final
char txt[20];
snprintf(txt, sizeof(txt), "A0=%d",
         analogRead(A0));
dtostrf(21.537, 5, 1, txt); → " 21.5"

String msg = "T = ";   // pratique…
msg += 21.5;           // …mais gourmand

• Indices de 0 à N − 1 ; aucun contrôle : broches[4] écrase la mémoire !
• snprintf() ne connaît pas %f sur AVR : convertir d’abord avec dtostrf() (valeur, largeur, décimales, tampon).
• String : length(), toInt(), toFloat(), indexOf(), substring(), trim()… À éviter dans un programme qui tourne longtemps sur 2 Ko de SRAM.

Sur AVR, abs, min, max, sq sont des macros : ne pas y écrire i++ ou un appel de fonction, évalués deux fois !

Messages du compilateur correspondants : p. 8 ; avertissements à activer (p. 1).

Le suffixe UL sur le premier nombre fait tout le calcul en unsigned long (sinon débordement, p. 4).

Chronométrer un morceau de code

unsigned long t0 = micros();
analogRead(A0);  // code à mesurer
unsigned long duree = micros() - t0;

const int LED = 13;
const unsigned long PERIODE = 500;
unsigned long precedent = 0; 1
bool etat = LOW;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  unsigned long t = millis();
  if (t - precedent >= PERIODE) { 2
    precedent = t;
    etat = !etat;
    digitalWrite(LED, etat);
  }
  3 lire un bouton, un capteur…
}

• 1 un instant se range toujours dans un unsigned long ;
• 2 la soustraction reste juste quand millis() repasse par 0 : avec precedent = 4 294 967 000 et t = 204, la différence vaut 500. Ne pas écrire t >= precedent + PERIODE ! ;
• 3 loop() n’attend jamais : elle tourne des milliers de fois par seconde et peut tout surveiller.

unsigned long tLed = 0, tMesure = 0;

void loop() {
  unsigned long t = millis();
  if (t - tLed >= 250) {      // 250 ms
    tLed = t;
    digitalWrite(13, !digitalRead(13));
  }
  if (t - tMesure >= 2000) {  // 2 s
    tMesure = t;
    Serial.println(analogRead(A0));
  }
}

const int BOUTON = 2;  // vers GND
const unsigned long STABLE = 30; // ms
int etatStable = HIGH, dernierLu = HIGH;
unsigned long tChange = 0;

bool appui() {  // 1 fois par appui
  int lu = digitalRead(BOUTON);
  if (lu != dernierLu) {         1
    dernierLu = lu;
    tChange = millis();
  }
  if (millis() - tChange >= STABLE
      && lu != etatStable) {
    etatStable = lu;             2
    return etatStable == LOW;
  }
  return false;
}

void setup() {
  pinMode(BOUTON, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  if (appui()) Serial.println("Appui");
}

• 1 la lecture change : on relance le chronomètre ;
• 2 elle n’a plus bougé depuis 30 ms : c’est le nouvel état.

Clé en main : bibliothèque Bounce2.

enum Etat { VERT, ORANGE, ROUGE };
Etat etat = VERT;
unsigned long debut = 0;

void allumer(int b) {    // 9, 10 ou 11
  for (int p = 9; p <= 11; p++)
    digitalWrite(p, p == b);
}

void changer(Etat nouveau) {
  etat = nouveau;
  debut = millis();
}

void setup() {
  for (int p = 9; p <= 11; p++)
    pinMode(p, OUTPUT);
}

void loop() {
  unsigned long dt = millis() - debut;
  switch (etat) {
    case VERT:
      allumer(9);                1
      if (dt >= 5000) changer(ORANGE);
      break;
    case ORANGE:
      allumer(10);
      if (dt >= 1000) changer(ROUGE);
      break;
    case ROUGE:
      allumer(11);
      if (dt >= 4000) changer(VERT);
      break;
  }
}

1 À chaque tour : agir selon l’état courant, puis tester les transitions (les if). Ajouter un bouton piéton = ajouter une transition, sans rien bloquer.

Après chaque compilation, l’IDE affiche :

Le croquis utilise n octets (p%) de
l'espace de stockage de programmes.
Le maximum est de 32256 octets.
Les variables globales utilisent n octets
(p%) de mémoire dynamique, ce qui laisse
n octets pour les variables locales.
Le maximum est de 2048 octets.

Au-delà de 75 % de SRAM : « La mémoire disponible faible, des problèmes de stabilité pourraient survenir. » (sic). La pile a besoin de la place restante : plantages aléatoires !

Serial.println(F("Texte en flash"));

const byte t[] PROGMEM = {1, 2, 4, 8};
byte v = pgm_read_byte(&t[2]);  → 4

• F() pour tout texte fixe passé à print() ;
• le plus petit type suffisant (byte plutôt qu’int) ;
• éviter String et les grands tableaux ; un écran OLED 128 × 64 réserve 1 Ko (la moitié de la SRAM !).

#include <EEPROM.h>

void setup() {
  EEPROM.update(0, 42); // si différent
  byte v = EEPROM.read(0);  → 42
  float c = 21.5;
  EEPROM.put(10, c);    // cases 10…13
  EEPROM.get(10, c);    // relecture
  int n = EEPROM.length();  → 1024
}

• update() n’écrit que si la valeur change ; put(), get() : une variable entière (ici un float, 4 octets) ; case jamais écrite : 255.
• 100 000 écritures par case : jamais à chaque tour de loop() !
• R4 EEPROM de 8 Ko, même interface.

#include <avr/wdt.h>

void setup() {
  wdt_enable(WDTO_2S);   1
}

void loop() {
  wdt_reset();           2
  // … travail normal
}

• 1 si le programme se fige plus de 2 s, la carte redémarre d’elle-même ;
• 2 « nourrir » le chien de garde à chaque tour de loop().

Propre aux microcontrôleurs AVR (Uno R3, Nano, Mega). Des redémarrages en boucle sont signalés avec l’ancien chargeur d’amorçage de certains Nano : tester avant de s’y fier.

• Uno : broches 0 et 1 partagées avec l’USB ; tampon de réception de 64 octets.
• Cartes à USB natif (Leonardo, Micro…) : while (!Serial) {} dans setup() pour ne rien perdre.

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  if (Serial.available() > 0) {     1
    String c =
      Serial.readStringUntil('\n'); 2
    c.trim();                       3
    if (c == "on")
      digitalWrite(13, HIGH);
    else if (c == "off")
      digitalWrite(13, LOW);
    else
      Serial.println("Inconnu : " + c);
  }
}

• 1 nombre d’octets reçus en attente ; Serial.read() en lit un (−1 s’il n’y a rien) ;
• 2 lit jusqu’au caractère donné, ou jusqu’au délai d’attente (1 s par défaut, Serial.setTimeout()) ; Serial.parseInt() lit un nombre ;
• 3 retire espaces et \r (fin de ligne « Les deux, NL et CR »).

• Débit du moniteur = débit de Serial.begin(), sinon caractères illisibles.
• Fin de ligne ajoutée à l’envoi : Pas de fin de ligne · Nouvelle ligne (\n) · Retour chariot (\r) · Les deux, NL et CR.
• Traceur série (Outils › Traceur série) : une ligne par mesure, valeurs séparées par une virgule, une espace ou une tabulation, étiquetées nom: :

Serial.print("temp:");
Serial.print(t);
Serial.print(",hum:");
Serial.println(h);
→ temp:21.50,hum:40.00

• Deux fils + la masse : SDA (données, A4) et SCL (horloge, A5) sur Uno ; tous les modules en parallèle.
• Chaque module a une adresse sur 7 bits, souvent réglable ; 0x08 à 0x77 utilisables.
• Résistances de tirage vers VCC (souvent 4,7 kΩ), en général déjà présentes sur les modules.
• 100 kHz par défaut ; Wire.setClock(400000) : 400 kHz. Fils courts (bus prévu pour l’intérieur d’un appareil).

#include <Wire.h>

void setup() {    // scanner I²C
  Serial.begin(9600);
  Wire.begin();   // pilote du bus
  for (byte a = 8; a < 120; a++) {
    Wire.beginTransmission(a);  1
    if (Wire.endTransmission() == 0) {
      Serial.print("Module en 0x");
      Serial.println(a, HEX);
    }
  }
}

void loop() {}

1 appel à l’adresse a ; endTransmission() renvoie 0 succès · 1 données trop longues (tampon de 32 octets) · 2 adresse sans réponse · 3 donnée refusée · 4 autre erreur · 5 délai dépassé.

Lire des registres

Wire.beginTransmission(0x68); // module
Wire.write(0x00);           // registre
Wire.endTransmission(false);  // garder
Wire.requestFrom(0x68, 3);  // 3 octets
while (Wire.available()) {
  byte b = Wire.read();
}

false : redémarrage sans libérer le bus, entre l’écriture du n° de registre et la lecture.

Adresses courantes, à vérifier sur le module : LCD à adaptateur PCF8574 0x27 ou 0x3F ; OLED SSD1306 0x3C ; BME280 0x76 ou 0x77 ; horloge DS3231 et MPU-6050 0x68.

#include <SoftwareSerial.h>
SoftwareSerial gps(4, 3);  // RX, TX

void setup() {
  Serial.begin(9600);      // vers le PC
  gps.begin(9600);    // vers le module
}

void loop() {              // relais
  if (gps.available())
    Serial.write(gps.read());
}

Un seul port logiciel écoute à la fois (listen()) ; peu fiable à haut débit. Mega : ports matériels Serial1 à Serial3.

• 4 fils : SCK horloge (13), COPI ou MOSI (11), CIPO ou MISO (12), CS sélection : une broche par module (10 par défaut).
• Rapide (plusieurs MHz), dans les deux sens à la fois : cartes SD, écrans TFT, lecteurs RFID, modules radio.
• Sur AVR, la broche 10 doit rester une sortie : en entrée à l’état bas, le SPI bascule en esclave !

#include <SPI.h>
const int CS = 10;

void setup() {
  pinMode(CS, OUTPUT);
  digitalWrite(CS, HIGH);  // libre
  SPI.begin();
}

byte lire(byte reg) {
  SPISettings r(1000000, MSBFIRST,
                SPI_MODE0);        1
  SPI.beginTransaction(r);
  digitalWrite(CS, LOW);   // sélection
  SPI.transfer(reg);
  byte v = SPI.transfer(0); 2
  digitalWrite(CS, HIGH);
  SPI.endTransaction();
  return v;
}

void loop() {}

• 1 vitesse (1 MHz), ordre des bits, mode (0 à 3) : lire la fiche du composant ;
• 2 on envoie un octet quelconque pour en recevoir un.

UART : le TX de l’un va au RX de l’autre ; masse commune.

• 5 V : Uno R3 et R4, Nano, Mega · 3,3 V : Nano ESP32, Nano 33, ESP32, la plupart des capteurs récents.
• Sortie 3,3 V → entrée 5 V : en général lue HIGH (seuil ≈ 3 V), marge faible.
• Sortie 5 V → entrée 3,3 V : jamais en direct ! diviseur (1 kΩ / 2 kΩ, p. 2) ou adaptateur de niveaux.
• Beaucoup de modules ont régulateur et adaptateur intégrés : lire la tension indiquée sur VCC.

En italique : nom exact dans le gestionnaire de bibliothèques (p. 8).

int v = analogRead(A0);
float mv = v * 5000.0 / 1024;    // mV
float tLM35 = mv / 10;           // °C
float tTMP36 = (mv - 500) / 10;  // °C

LM35 : 10 mV/°C, 0 mV à 0 °C. TMP36 : 10 mV/°C, 500 mV à 0 °C (750 mV → 25 °C). Plus de finesse : analogReference(INTERNAL) (1,1 V) et 1100 au lieu de 5000.

#include <DHT.h>
DHT dht(2, DHT22);  // broche, modèle

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

void loop() {
  delay(2000);                     1
  float h = dht.readHumidity();    // %
  float t = dht.readTemperature(); // °C
  if (isnan(h) || isnan(t)) {      2
    Serial.println("Erreur");
    return;
  }
  Serial.print(t);
  Serial.print(" °C  ");
  Serial.print(h);
  Serial.println(" %");
}

• 1 le DHT22 ne fournit pas plus d’une mesure toutes les 2 s ;
• 2 isnan() : « n’est pas un nombre », lecture ratée (câblage, broche).

const int TRIG = 9, ECHO = 10;

void setup() {
  Serial.begin(9600);
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
}

void loop() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);      1
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  unsigned long d =
    pulseIn(ECHO, HIGH, 30000);  2
  if (d > 0) {
    float cm = d * 0.0343 / 2;   3
    Serial.println(cm);
  }
  delay(100);
}

• 1 impulsion de 10 µs : le module émet ses ultrasons ;
• 2 durée de l’écho en µs (aller-retour) ; 0 si rien en 30 ms ;
• 3 son : 343 m/s à 20 °C, soit 0,0343 cm/µs ; ÷ 2 pour l’aller seul ; soit cm ≈ durée / 58.

#include <Servo.h>
Servo bras;

void setup() {
  bras.attach(9);          1
}

void loop() {
  int v = analogRead(A0);
  int angle = map(v, 0, 1023, 0, 180);
  bras.write(angle);       2
  delay(15);
}

• 1 fil de commande sur une broche quelconque ; jusqu’à 12 servos ; sur Uno, la bibliothèque supprime la MLI de 9 et 10 ;
• 2 angle de 0 à 180° ; bras.writeMicroseconds(1500) : durée d’impulsion (544 à 2 400 µs par défaut pour 0 à 180°).

Fils : rouge + 5 V, noir ou marron GND, jaune, orange ou blanc : commande. Un servo tire de fortes pointes de courant : au-delà d’un ou deux, alimentation séparée, masses reliées.

const int EN = 5;      // broche MLI
const int IN1 = 7, IN2 = 8;

void moteur(int v) {   // -255 à 255
  digitalWrite(IN1, v > 0);
  digitalWrite(IN2, v < 0);
  analogWrite(EN, min(abs(v), 255));
}

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  moteur(-150);        // recule
}

void loop() {}

Moteur alimenté à part, masses reliées. Module L298N : retirer le cavalier ENA pour régler la vitesse.

#include <LiquidCrystal.h>
// RS, E, D4, D5, D6, D7
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
  lcd.begin(16, 2);     // taille
  lcd.print("Bonjour !");
}

void loop() {
  lcd.setCursor(0, 1);  // 2e ligne
  lcd.print(millis() / 1000);
  lcd.print(" s");
}

Contraste : potentiomètre de 10 kΩ sur V0 (écran vide ou rectangles pleins sinon). Pas d’accents dans le jeu de caractères d’origine. Version I²C (PCF8574) : bibliothèque « LiquidCrystal I2C », dont il existe plusieurs variantes : partir de l’exemple fourni.

#include <Adafruit_NeoPixel.h>
// 30 LED, données sur la broche 6
Adafruit_NeoPixel ruban(30, 6,
  NEO_GRB + NEO_KHZ800);

void setup() {
  ruban.begin();
  ruban.setBrightness(50);  // 0…255
}

void loop() {  // un point qui court
  for (int i = 0; i < 30; i++) {
    ruban.clear();
    ruban.setPixelColor(i,
      ruban.Color(255, 0, 0));  // rouge
    ruban.show();               1
    delay(50);
  }
}

1 rien ne change avant show(). Jusqu’à 60 mA par LED en blanc à pleine luminosité (1,8 A pour 30) : alimentation 5 V dédiée, masses reliées, condensateur de 500 à 1 000 µF sur l’alimentation, 300 à 500 Ω sur le fil de données.

Caractéristiques : documentation officielle (docs.arduino.cc).

• Installer : Outils › Gérer les bibliothèques… Ctrl+Shift+I, chercher, Installer ; accepter Tout installer pour les dépendances.
• Depuis une archive : Croquis › Importer une bibliothèque › Ajouter la bibliothèque .ZIP…
• Utiliser : #include <Nom.h> en tête du croquis ; exemples dans Fichier › Exemples.
• Fournies avec les cartes AVR : EEPROM, SoftwareSerial, SPI, Wire. Officielles : Servo, LiquidCrystal, Stepper.

• Outils › Carte › Gestionnaire de cartes : « Arduino AVR Boards » (Uno R3, Nano, Mega…), « Arduino UNO R4 Boards », « Arduino ESP32 Boards » (Nano ESP32).
• Autres ESP32 : Fichier › Préférences › URL de gestionnaire de cartes supplémentaires :
  https://espressif.github.io/arduino-esp32/package_esp32_index.json
  puis installer esp32.

• Avancer par petites étapes : un composant, un test, puis le suivant.
• Partir d’un exemple qui fonctionne, puis le modifier.
• Déboguer avec Serial.println() : afficher valeurs et étapes franchies.
• Noms explicites, constantes pour les broches, câblage décrit en commentaire en tête du croquis ; Ctrl+T pour mettre en forme.
• Garder les versions qui marchent (copie datée, Git).
• Tester sans matériel : simulateurs en ligne (Wokwi, Tinkercad Circuits).
• Référence : docs.arduino.cc (langage, cartes, tutoriels) ; entraide : forum.arduino.cc (section francophone).

Toujours lire la première erreur : les suivantes en découlent souvent.

arduino-cli core update-index
arduino-cli core install arduino:avr
arduino-cli board list                  # cartes et ports
arduino-cli compile --fqbn arduino:avr:uno Blink
arduino-cli upload -p COM3 --fqbn arduino:avr:uno Blink
arduino-cli lib install "DHT sensor library"
arduino-cli monitor -p COM3 --config 115200

• 1 Blink : la LED intégrée clignote (p. 1).
• 2 Feu tricolore : trois LED et leurs résistances, avec delay(), puis avec millis() (p. 5).
• 3 Bouton qui allume une LED, puis bascule avec anti-rebond (p. 3, 5).
• 4 Variateur : un potentiomètre règle la luminosité par MLI (p. 3).
• 5 Veilleuse automatique à photorésistance (p. 3).
• 6 Thermomètre : valeurs au moniteur, puis au traceur série (p. 6, 7).
• 7 Radar de recul : HC-SR04 et buzzer dont le rythme suit la distance (p. 7).
• 8 Aiguille : un servomoteur suit un potentiomètre (p. 7).
• 9 Station météo : DHT22 et écran LCD (p. 7).
• 10 Petit robot : deux moteurs, pont en H, capteur de distance, machine à états (p. 5, 7).