Brochage Arduino Uno : broches numériques, PWM et analogiques

Le brochage de l'Arduino Uno regroupe 32 points de connexion alignés sur les connecteurs femelles noirs des deux grands côtés de la carte : 14 broches numériques d'entrée/sortie (0–13), dont 6 peuvent fournir du PWM (~3, 5, 6, 9, 10, 11), 6 entrées analogiques (A0–A5) et les broches d'alimentation qui alimentent la carte ou fournissent du courant à d'autres composants (Vin, 5V, 3.3V, GND, IOREF, AREF, RESET). Chaque broche a une fonction principale, mais beaucoup en ont une seconde : A4 et A5 forment aussi le bus I2C, 10 à 13 le bus SPI, 2 et 3 sont des broches d'interruption, et 0 et 1 sont la liaison série qui dialogue avec ton ordinateur.

Choisir la bonne broche fait la différence entre un projet qui marche du premier coup et des heures de dépannage. Grâce aux tableaux de cet article, tu comprendras facilement pourquoi le PWM des broches 9 et 10 s'arrête dès que tu branches un servo, pourquoi le téléversement échoue quand un module Bluetooth est connecté ou pourquoi quelques LED peuvent surcharger la carte. À la fin, tu trouveras aussi un programme de test qui utilise tous les types de broches à la fois, un exemple de plan de câblage et les différences de broches entre l'Uno R3 et le R4.

Schéma de brochage de l'Arduino Uno : où se trouve chaque broche ?

Pose la carte devant toi avec la prise USB et le jack d'alimentation à gauche. Les deux connecteurs du bord supérieur portent les broches numériques ; les numéros augmentent de droite à gauche, donc la broche la plus à droite est la 0 (RX) et la broche numérique la plus à gauche est la 13. Sur le bord inférieur, le connecteur de gauche porte les broches d'alimentation et celui de droite les entrées analogiques. Le ~ (tilde) à côté d'un numéro indique que la broche peut fournir du PWM. Le groupe de 2×3 broches mâles sur le bord droit de la carte est le connecteur ICSP.

Le grand tableau des broches : D0–D13 et A0–A5

Comment fonctionnent les broches numériques (0–13) ?

Chaque broche numérique est configurée en entrée ou en sortie avec pinMode(). En sortie, digitalWrite(pin, HIGH) amène la broche à environ 5 V et LOW à 0 V. En entrée, digitalRead() compare la tension à un seuil : avec l'ATmega328P alimenté en 5 V, tout ce qui dépasse 3,0 V est un HIGH garanti, tout ce qui est sous 1,5 V un LOW garanti, et l'intervalle entre les deux est une zone indéterminée. C'est pourquoi la sortie d'un capteur 3,3 V est généralement lue comme HIGH par l'Uno ; en revanche, la sortie 5 V de l'Uno ne doit pas aller directement sur l'entrée d'un module 3,3 V, il faut un convertisseur de niveau logique entre les deux.

Une broche d'entrée reliée à rien est flottante et lit HIGH et LOW au hasard, même quand tu approches la main. La solution consiste à tirer la broche vers un niveau fixe avec une résistance : pinMode(pin, INPUT_PULLUP) active la résistance de 20 à 50 kΩ intégrée à la puce, et le bouton se branche entre la broche et GND. Les détails sont dans Comment brancher un bouton-poussoir sur Arduino. La broche 13 est reliée à la LED L de la carte ; sur un R3 d'origine, cette LED est pilotée par un amplificateur opérationnel monté en tampon, donc utiliser la broche en entrée ne pose pas de problème, mais sur certains clones la LED et sa résistance sont branchées directement sur la broche et peuvent fausser la lecture d'un bouton avec le pull-up interne.

Broches PWM (~3, 5, 6, 9, 10, 11) et timers

L'Uno ne sait pas produire une vraie sortie analogique ; ces six broches fournissent à la place du PWM, un signal carré qui s'allume et s'éteint très vite. Avec analogWrite(pin, valeur), tu règles entre 0 et 255 la durée pendant laquelle le signal reste allumé : 0 correspond à éteint, 127 à environ la moitié et 255 à allumé en permanence. C'est ainsi qu'on règle la luminosité d'une LED, la vitesse d'un moteur ou celle d'un ventilateur. Les six broches PWM sont reliées deux par deux à trois timers matériels, et c'est la cause des conflits avec certaines bibliothèques. Le principe du PWM et le calcul du rapport cyclique sont expliqués dans Qu'est-ce que le PWM ?.

Broches analogiques (A0–A5) et AREF

Les broches analogiques mesurent une tension entre 0 et 5 V avec une résolution de 10 bits, et analogRead() renvoie un nombre de 0 à 1023. Un pas vaut environ 4,9 mV ; pour convertir ce nombre en volts, utilise tension = valeur × 5,0 / 1023 : une lecture de 512 correspond donc à environ 2,5 V. Les six broches partagent à tour de rôle un seul convertisseur analogique-numérique (CAN), et une lecture dure environ 100 µs, soit environ 10 000 lectures par seconde. Pour des mesures justes, l'impédance de sortie du capteur ne doit pas dépasser 10 kΩ ; au-delà, deux broches lues coup sur coup peuvent se mélanger, et ignorer la première lecture pour garder la seconde règle le problème. Pour mesurer des tensions supérieures à 5 V, choisis les bonnes résistances avec le calculateur de pont diviseur de tension.

La broche AREF permet de changer la limite haute de la mesure analogique. analogReference(DEFAULT) utilise 5 V, analogReference(INTERNAL) la référence interne de 1,1 V de la puce, et analogReference(EXTERNAL) la tension que tu appliques sur AREF (0–5 V) comme pleine échelle. Avec un capteur qui sort 0 à 1 V, la référence de 1,1 V réduit un pas à environ 1,1 mV et rend la mesure environ 4,5 fois plus fine. Les potentiomètres, les LDR et les capteurs d'humidité du sol se branchent sur ces broches ; les détails de la conversion analogique-numérique sont dans l'article sur le CAN, et un exemple concret dans l'article sur le potentiomètre.

Broches d'alimentation : Vin, 5V, 3.3V, GND, IOREF et RESET

L'Uno peut être alimenté de trois façons. Par USB, la carte prend le 5 V directement sur l'ordinateur, et un fusible réarmable de 500 mA protège le port. Si tu fournis 7 à 12 V par le jack DC ou par Vin, le régulateur de la carte les abaisse à 5 V ; si les deux sont branchés, la carte bascule automatiquement sur l'alimentation externe dès que Vin dépasse environ 6,6 V. Comme le régulateur transforme la tension en trop en chaleur, il chauffe vite avec 12 V en entrée si tu tires quelques centaines de mA sur la broche 5V. Le plus sain est d'alimenter les charges comme les servos, les moteurs et les rubans LED avec une source séparée et de relier seulement les masses. Pour choisir une batterie et estimer l'autonomie, utilise le calculateur d'autonomie de batterie, et découvre toutes les méthodes d'alimentation dans Comment alimenter un Arduino.

Pourquoi laisser libres les broches 0 et 1 ?

Les broches 0 (RX) et 1 (TX) constituent le seul port série matériel de l'ATmega328P et, sur la carte, elles sont reliées par des résistances de 1 kΩ à la puce de conversion USB-série (ATmega16U2). Ton ordinateur utilise ces deux broches pour téléverser le code et pour envoyer du texte au moniteur série. Si la sortie TX d'un module Bluetooth ou un autre signal est branché sur la broche 0, les deux sources se disputent la même ligne et le téléversement s'arrête avec avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00. De plus, la broche 1 change rapidement d'état à chaque Serial.print() ; une LED ou un relais branché dessus s'active alors au hasard.

Laisse donc 0 et 1 libres tant qu'il te reste d'autres broches. Si tu dois brancher un module série comme un HC-05, un GPS ou un lecteur MP3, la bibliothèque SoftwareSerial crée un second port série sur deux autres broches. Le programme ci-dessous relie le module aux broches 8 (RX) et 7 (TX) : il transmet au module ce que tu tapes dans le moniteur série et à l'ordinateur ce qu'envoie le module. Avec les modules en logique 3,3 V comme le HC-05, relie la sortie TX de l'Uno (broche 7) à l'entrée RX du module à travers un pont diviseur de tension. Toutes les solutions aux problèmes de téléversement sont dans Arduino : le téléversement échoue, et le principe de la liaison série dans Communication série UART.

1#include <SoftwareSerial.h>
2
3SoftwareSerial moduleSerial(8, 7);   // RX = 8, TX = 7; 0 ve 1 boş kalır / 0 and 1 stay free
4
5void setup() {
6  Serial.begin(9600);                // USB üzerinden bilgisayar / computer over USB
7  moduleSerial.begin(9600);          // HC-05 veri modu hızı / HC-05 data mode baud rate
8  Serial.println(F("Seri kopru hazir / Serial bridge ready"));
9}
10
11void loop() {
12  if (moduleSerial.available()) {
13    Serial.write(moduleSerial.read());   // modülden bilgisayara / module to computer
14  }
15  if (Serial.available()) {
16    moduleSerial.write(Serial.read());   // bilgisayardan modüle / computer to module
17  }
18}

Broches de communication : I2C (A4/A5), SPI (10–13) et interruptions (2, 3)

L'I2C permet de brancher des dizaines d'appareils sur le même bus avec seulement deux fils (SDA et SCL) ; les écrans LCD, les OLED, les modules d'horloge RTC et les capteurs comme le BME280 l'utilisent. Sur l'Uno, SDA = A4 et SCL = A5. Sur les cartes R3, les broches SDA et SCL situées à côté d'AREF ne forment pas un bus distinct : elles sont reliées en interne à A4 et A5, donc tant que tu utilises l'I2C, A4 et A5 ne peuvent pas servir aux mesures analogiques. La bibliothèque Wire fonctionne à 100 kHz par défaut et monte à 400 kHz avec Wire.setClock(400000). Les adresses, les résistances de pull-up et un scanner I2C sont présentés dans Qu'est-ce que l'I2C ?, et un exemple pratique dans Écran LCD I2C.

Le SPI est plus rapide mais demande plus de fils : MOSI = 11, MISO = 12, SCK = 13 et SS (CS) = 10. Les modules carte SD, les lecteurs RFID et les écrans TFT utilisent le SPI. Plusieurs appareils peuvent partager le bus : MOSI, MISO et SCK sont communs et chaque appareil reçoit sa propre broche CS. Détail important : en mode maître (master), la broche 10 doit rester une sortie ; si tu la passes en entrée et qu'elle est tirée à LOW, l'ATmega328P bascule en mode esclave (slave) et le SPI s'arrête. MISO, MOSI et SCK sont aussi présents sur le connecteur ICSP, d'où certains shields récupèrent le SPI. Pour en savoir plus, consulte Qu'est-ce que le SPI ? et RFID RC522.

Une interruption te permet de capter instantanément un changement sur une broche, quoi que loop() soit en train de faire. Sur l'Uno, les interruptions externes n'existent que sur les broches 2 (INT0) et 3 (INT1) : tu écris attachInterrupt(digitalPinToInterrupt(2), fonction, FALLING), et le mode de déclenchement peut être LOW, CHANGE, RISING ou FALLING. Les encodeurs, capteurs de vitesse de rotation, débitmètres et boutons qu'il ne faut jamais rater vont sur ces broches. Les autres broches disposent aussi d'« interruptions sur changement d'état » (PCINT), mais les broches d'un même port partagent une seule fonction d'interruption et ton code doit déterminer laquelle a changé. Les règles et les exemples sont dans Les interruptions Arduino.

En passant à l'ESP32 ou au Pico, la plus grande différence est la tension : les deux cartes fonctionnent en 3,3 V et leurs broches ne tolèrent pas le 5 V, donc les modules 5 V que tu branches directement sur l'Uno peuvent nécessiter un convertisseur de niveau. En contrepartie, ces cartes offrent des interruptions et du PWM sur presque toutes les broches, et leurs bus I2C et SPI peuvent être déplacés sur d'autres broches. Pour comparer les cartes, lis Arduino Uno ou ESP32 ?, et pour voir les brochages, utilise l'outil de brochage ; les cartes elles-mêmes sont présentées dans Qu'est-ce que l'ESP32 ? et Qu'est-ce que le Raspberry Pi Pico ?.

À quoi sert le connecteur ICSP ?

L'ICSP (In-Circuit Serial Programming) est un connecteur 2×3 qui sert à programmer le microcontrôleur directement par les lignes SPI, sans USB ni bootloader. L'ICSP du bord droit appartient à l'ATmega328P, tandis que le petit ICSP1 à côté de la prise USB appartient à la puce USB-série (ATmega16U2). Au quotidien, tu n'y touches pas ; l'ICSP entre en jeu quand le bootloader est corrompu, quand tu graves un bootloader sur un ATmega328P neuf ou quand tu téléverses du code avec un programmateur comme l'USBasp. Si tu transformes un second Uno en programmateur avec l'exemple ArduinoISP, ses broches 10, 11, 12 et 13 vont sur RESET, MOSI, MISO et SCK de la carte cible, et un condensateur de 10 µF entre RESET et GND sur l'Uno programmateur empêche sa réinitialisation automatique. Pour savoir si ta carte est endommagée, jette un œil à Mon Arduino est-il grillé ?.

20 mA par broche, 200 mA au total : les limites de courant

Une broche de l'Uno fonctionne en toute sécurité jusqu'à 20 mA. Les 40 mA de la fiche technique de l'ATmega328P sont le maximum absolu, c'est-à-dire le seuil au-delà duquel la puce peut être endommagée de façon permanente, pas une valeur de fonctionnement. Le courant total qui traverse les broches VCC et GND de la puce ne doit pas dépasser 200 mA. La fiche technique répartit aussi les broches en groupes : en fournissant du courant (HIGH), D0–D4 avec A0–A5, et D5–D13 entre elles, doivent chacun rester sous 150 mA ; en absorbant du courant (LOW), les groupes D0–D4, D5–D13 et A0–A5 doivent chacun rester sous 100 mA. Si tu alimentes une LED rouge en 5 V avec une résistance de 220 Ω, le courant vaut (5 − 2) / 220 ≈ 13,6 mA. Dix LED allumées en même temps font 136 mA ; c'est sous les 200 mA, mais si elles sont toutes dans le même groupe, on frôle la limite de 150 mA du groupe. Si les LED s'allument quand la broche est à LOW (résistance du 5V vers la broche) et que la plupart sont dans le même groupe, la limite de 100 mA est dépassée. Répartis les LED entre les groupes ou monte la résistance à 330–470 Ω. Trouve la bonne résistance avec le calculateur de résistance pour LED ou le calculateur de loi d'Ohm.

• Moteurs : Même un petit moteur à courant continu consomme des centaines de mA et produit des pics de tension ; utilise un driver de moteur comme le L298N ou un transistor.
• Bobine de relais : La bobine d'un relais 5 V consomme environ 70 à 90 mA ; utilise un module relais avec transistor et diode.
• Servomoteurs : Le fil de signal peut aller sur une broche, mais l'alimentation du servo doit venir d'une source séparée, pas de la broche 5V ; les détails sont dans l'article sur le servomoteur.
• Rubans LED et LED de puissance : Les rubans 12 V et les LED de 1 W demandent un MOSFET à niveau logique.
• Courts-circuits : Relier directement à GND une sortie à l'état HIGH tire bien plus de 40 mA sur la broche et la détruit définitivement.

Programme de test : broches numériques, PWM, analogiques et interruptions ensemble

1. Branche une LED sur la broche 9 avec une résistance de 220 Ω : patte longue vers la résistance, patte courte vers GND.
2. Relie les deux pattes extérieures d'un potentiomètre au 5V et à GND, et la patte du milieu à A0.
3. Branche un bouton entre la broche 2 et GND ; aucune résistance supplémentaire n'est nécessaire, car le pull-up interne est utilisé.
4. Téléverse le programme, ouvre le moniteur série et règle-le sur 9600 bauds.
5. Tourne le potentiomètre : la luminosité de la LED de la broche 9 change, la LED L de la carte (broche 13) s'allume dès que la tension dépasse 2,5 V, et le compteur augmente de un à chaque appui.

1const byte BUTTON_PIN = 2;    // kesme pini INT0 / interrupt pin INT0
2const byte PWM_LED    = 9;    // ~9: PWM çıkışı / PWM output
3const byte STATUS_LED = 13;   // kart üzerindeki L LED'i / onboard L LED
4const byte POT_PIN    = A0;   // analog giriş / analog input
5
6volatile unsigned int pressCount = 0;   // ISR içinde değişir / changed inside the ISR
7
8void onButton() {
9  static unsigned long lastPressMs = 0;
10  unsigned long now = millis();
11  if (now - lastPressMs > 50) {         // 50 ms sıçrama filtresi / 50 ms debounce
12    pressCount++;
13    lastPressMs = now;
14  }
15}
16
17void setup() {
18  Serial.begin(9600);                   // 0 ve 1 numaralı pinleri kullanır / uses pins 0 and 1
19  pinMode(STATUS_LED, OUTPUT);
20  pinMode(PWM_LED, OUTPUT);
21  pinMode(BUTTON_PIN, INPUT_PULLUP);    // dahili pull-up direnci / internal pull-up resistor
22  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButton, FALLING);
23}
24
25void loop() {
26  int raw = analogRead(POT_PIN);        // 0-1023 arası ham değer / raw value 0-1023
27  float volts = raw * 5.0 / 1023.0;     // volta çevir / convert to volts
28  analogWrite(PWM_LED, raw / 4);        // 0-255 arası PWM / PWM from 0 to 255
29  digitalWrite(STATUS_LED, volts > 2.5 ? HIGH : LOW);   // 2,5 V eşiği / 2.5 V threshold
30
31  noInterrupts();                       // sayacı güvenle kopyala / copy the counter safely
32  unsigned int presses = pressCount;
33  interrupts();
34
35  Serial.print(F("A0: "));
36  Serial.print(raw);
37  Serial.print(F("  V: "));
38  Serial.print(volts, 2);
39  Serial.print(F("  Buton / Button: "));
40  Serial.println(presses);
41  delay(200);
42}

Le programme utilise quatre types de broches de l'Uno en même temps. analogRead(A0) lit une valeur de 0 à 1023, et raw / 4 la ramène à la plage 0–255 attendue par analogWrite(). Pour ne pas compter les rebonds du bouton, la fonction d'interruption ignore les signaux qui arrivent moins de 50 ms après le dernier appui. Le compteur modifié dans l'interruption est déclaré volatile, et loop() le copie en suspendant brièvement les interruptions : l'Uno, un 8 bits, lit un nombre de 16 bits en deux étapes, et une interruption survenant entre les deux pourrait donner une valeur fausse. Les broches 0 et 1 ne servent qu'à Serial, rien d'autre n'y est branché.

Exemple de plan de câblage : quel composant sur quelle broche ?

Répartir les broches au hasard dans un projet à plusieurs composants mène aux conflits. Place d'abord les composants à fonction spéciale (I2C, SPI, interruptions, PWM) sur leurs broches, puis distribue les tâches numériques simples sur les broches libres. Voici un exemple de plan pour une serrure à badge RFID : lecteur RC522, LCD I2C, servo, buzzer, bouton et deux LED. Comme le servo et tone() sont utilisés ensemble, le PWM des broches 3, 9, 10 et 11 est déjà hors jeu, et le plan en tient compte.

Différences de broches entre l'Arduino Uno R3 et le R4

En bref, sur le R4 les numéros et les fonctions des broches restent les mêmes (PWM ~3, 5, 6, 9, 10, 11 ; I2C A4/A5 ; SPI 10–13 ; interruptions 2, 3), mais le courant par broche tombe à 8 mA. Une LED que tu pilotais directement depuis une broche sur le R3 demande sur le R4 une résistance plus grande (par exemple 1 kΩ pour environ 3 mA) ou un transistor. La comparaison détaillée se trouve dans Arduino Uno R4. Si tu cherches une carte plus petite, Brochage de l'Arduino Nano et Quel Arduino choisir ? t'aideront.

Erreurs fréquentes et solutions

Une fois que tu connais les broches de l'Arduino Uno, tu n'as plus besoin de retenir par cœur où va chaque composant : tu regardes ce dont il a besoin et tu choisis toi-même la bonne broche. Pour revoir les bases, commence par Qu'est-ce qu'Arduino ?. Dans l'application BlueGrays, tu trouveras des projets comme allumer une LED, lire un bouton, mesurer la lumière avec une LDR, une LED RGB en PWM, un LCD I2C, le RFID et deux Arduino qui communiquent par liaison série, chacun pas à pas avec des schémas qui montrent pourquoi chaque broche a été choisie et du code prêt à l'emploi.