Configurer les GPIO Arduino

Les GPIO (General Purpose Input/Output) d’une carte Arduino sont les broches numériques configurables en entrée ou en sortie pour lire ou émettre un signal binaire (0 V / 5 V sur Uno R3). Configurer correctement un GPIO est le geste de base de tout programme embarqué. Oublier pinMode(), confondre les modes ou ignorer l’état flottant d’une entrée est la cause la plus fréquente des comportements imprévisibles en début de projet.

À quoi ça sert ?

Tous les capteurs et actionneurs binaires (bouton, fin de course, LED, relais, buzzer, capteur de présence) passent par les GPIO. Trois modes couvrent ~80 % des montages Arduino : INPUT (entrée flottante), INPUT_PULLUP (entrée tirée au haut par résistance interne), OUTPUT (sortie à pousser à HIGH ou LOW). Comprendre ces trois modes et le câblage qui va avec rend lisible la plupart des autres tutoriels Arduino.

Procédure pas à pas

Quatre étapes : identifier la broche, configurer le mode, lire ou écrire, vérifier le câblage.

1. Identifier les broches numériques

Sur Arduino Uno, les broches D0 à D13 sont des GPIO numériques. D0 et D1 sont aussi utilisées par l’USB (TX/RX), à éviter pour autre chose. Les broches A0 à A5 peuvent aussi servir de GPIO numériques (référencées comme A0, A1, …, ou comme 14, 15, …, 19).

Sur Mega 2560 : D0 à D53. Sur Nano : D0 à D13 + A0-A7 (D0/D1 partagées avec l’USB comme sur l’Uno, A6/A7 ne fonctionnent qu’en entrée analogique).

2. Configurer le mode dans setup()

Une ligne pinMode() par broche utilisée :

const int LED = 13;
const int BOUTON = 2;
 
void setup() {
  pinMode(LED, OUTPUT);
  pinMode(BOUTON, INPUT_PULLUP);
}

• OUTPUT — la broche pilote un signal vers l’extérieur (LED, relais, transistor).
• INPUT — la broche lit un signal extérieur sans aucune polarisation interne. Si rien n’est branché, la lecture est aléatoire (bruit 50 Hz capté par l’antenne formée par le fil). À n’utiliser que si une résistance externe maintient l’entrée à un niveau connu.
• INPUT_PULLUP — la broche lit un signal mais une résistance interne d’environ 20 à 50 kΩ tire le potentiel vers +5 V. Logique inversée : la broche lit HIGH au repos, LOW quand on la connecte à GND (typiquement par un bouton).

3. Lire ou écrire dans loop()

void loop() {
  int etat = digitalRead(BOUTON);  // HIGH ou LOW
  if (etat == LOW) {                // bouton appuyé (logique pullup inversée)
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }
}

digitalRead() renvoie HIGH ou LOW. digitalWrite() accepte les mêmes constantes (ou 1 / 0).

4. Câbler proprement

• Sortie sur LED : une résistance série de 220 Ω à 1 kΩ entre la broche et l’anode (+) de la LED, cathode (-) vers GND. Sans résistance, la LED brûle ou la broche s’abîme.
• Entrée sur bouton, mode INPUT_PULLUP : un côté du bouton sur la broche, l’autre côté sur GND. Rien d’autre.
• Entrée sur bouton, mode INPUT : il faut une résistance externe (pull-up vers +5 V ou pull-down vers GND, ~10 kΩ) pour donner un état de repos défini.

Exemple — Bouton qui allume une LED

Câblage et code complets pour valider la chaîne pinMode + digitalRead + digitalWrite.

Câblage :

• LED anode (+) → résistance 220 Ω → broche D13.
• LED cathode (-) → GND.
• Bouton entre la broche D2 et GND (configuration INPUT_PULLUP, pas de résistance externe).

const int LED = 13;
const int BOUTON = 2;
 
void setup() {
  pinMode(LED, OUTPUT);
  pinMode(BOUTON, INPUT_PULLUP);
}
 
void loop() {
  if (digitalRead(BOUTON) == LOW) {
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }
}

Téléversez, appuyez sur le bouton : la LED s’allume. Relâchez : elle s’éteint. Si la LED reste allumée en permanence (comme si le bouton était toujours appuyé), c’est que la broche est reliée en continu à GND, souvent un bouton tactile 4 pattes câblé sur la mauvaise paire : deux de ses pattes sont déjà reliées entre elles à l’intérieur et relient la broche à GND en permanence. Le pull-up perd alors la bataille face à cette liaison franche.

Pièges

pinMode() oublié. Une broche non configurée se comporte de manière indéfinie (état par défaut variable selon la carte). Symptôme : le code semble correct mais rien ne marche.

Confondre INPUT et INPUT_PULLUP. En INPUT sans résistance externe, la broche flotte, lecture aléatoire qui peut sembler répondre au toucher de la main (le corps fait antenne 50 Hz). En INPUT_PULLUP, la broche est définie au repos. C’est presque toujours le bon choix pour un bouton.

Logique inversée du pull-up. Un bouton en INPUT_PULLUP lit LOW quand appuyé. Un test if (digitalRead(BOUTON) == HIGH) allumera la LED quand le bouton est relâché, inverse du comportement attendu.

LED branchée sans résistance. Une LED rouge consomme ~20 mA sous 2 V. Branchée directement entre 5 V et GND, elle tire un courant excessif qui la grille (ou abîme la broche). Toujours une résistance série, calculée pour la chute de tension de la LED (220 Ω à 1 kΩ pour une LED standard sur 5 V).

Courant max dépassé. Chaque broche supporte 20 mA en régime nominal (40 mA en absolu, destruction au-delà). Le total sur toutes les broches d’un ATmega328P ne doit pas dépasser ~200 mA. Pour piloter plus (relais, moteur, bandeau LED), passer par un transistor ou un module dédié.

digitalRead() sur broche en OUTPUT. Possible mais inutile. On lit l’état qu’on vient d’écrire. Probablement le signe d’un mode mal configuré.

Broche flottante non utilisée. Une broche déclarée INPUT sans rien branché capte du bruit. Si on la lit, on récupère aléatoire. Pour des broches inutilisées qu’on veut lire un jour, soit INPUT_PULLUP, soit broche externe tirée à un niveau défini.

Cas particulier — Broches PWM, ADC et bus

Toutes les broches numériques ne sont pas équivalentes :

• PWM — sur Uno, D3, D5, D6, D9, D10, D11 (marquées ~) génèrent un signal PWM avec analogWrite() (voir piloter une sortie PWM).
• ADC — A0 à A5 sont les entrées analogiques (analogRead), avec un rôle GPIO en alternative.
• Bus — D0/D1 (UART), A4/A5 (I2C), D10-D13 (SPI). Utiliser une broche en GPIO la rend indisponible pour son bus dédié.

Le brochage officiel de votre carte est la référence. Gardez-le à portée de main.

Raccrochage projet

• Étape 2 de la phase de preuve de concept — premiers essais individuels d’entrée et de sortie (bouton, LED, fin de course) avant d’assembler.
• Étape 2 de la phase d’intégration et tests — validation pièce-par-pièce des E/S avant tests pyramidaux.

Maîtriser les trois modes GPIO sur un petit montage isolé est la fondation sur laquelle reposent presque tous les tutoriels Arduino suivants. Pas la peine d’enchaîner sur les capteurs ou les actionneurs avant que ce socle ne soit ferme.

Voir aussi

• Arduino — hub des tutoriels Arduino
• GPIO — notion transverse (modes, état au boot, GPIO sur autres familles)
• Lire une entrée TOR — la suite naturelle (bouton avec anti-rebond)
• Piloter une sortie TOR — la sortie au-delà de la LED (relais)
• État des GPIO à l’allumage — broches sensibles avant setup()
• Niveaux de tension — 3,3 V vs 5 V, compatibilité capteurs