Brochage Arduino Nano : schéma des broches, A6/A7, alimentation

Le brochage de l'Arduino Nano compte 30 broches alignées sur les deux grands côtés d'une carte de 45 × 18 mm : 14 broches numériques d'entrée/sortie (D0–D13), dont 6 peuvent fournir du PWM (~3, 5, 6, 9, 10, 11), 8 entrées analogiques (A0–A7) et les broches d'alimentation et de contrôle VIN, 5V, 3V3, AREF, deux GND et deux RST. Comme le Nano utilise le même processeur ATmega328P que l'Arduino Uno, les numéros et les fonctions des broches sont aussi les mêmes : un programme écrit pour l'Uno fonctionne sans aucune modification, il suffit de choisir le Nano dans le menu des cartes.

Quelques détails importants distinguent pourtant le Nano de l'Uno, et c'est précisément là que les débutants bloquent : A6 et A7 sont seulement analogiques, la carte n'a pas de prise jack, la broche 3V3 fournit très peu de courant, sur les clones l'USB est géré par une puce CH340 et, pour téléverser, il faut souvent choisir ATmega328P (Old Bootloader). Dans ce guide, tu vas découvrir chaque broche, apprendre à bien placer le Nano sur une breadboard, voir la correspondance des broches avec l'Uno et comprendre en quoi les Nano Every et Nano ESP32 diffèrent du Nano classique.

Qu'est-ce que l'Arduino Nano et en quoi diffère-t-il de l'Uno ?

L'Arduino Nano réunit toutes les fonctions de base de l'Uno sur une carte de 45 × 18 mm pesant environ 7 grammes. Ses broches sont orientées vers le bas, il se pique donc directement sur une breadboard ; cela limite les fils de liaison et, une fois le montage terminé, il passe facilement dans un boîtier ou sur un circuit définitif. À l'intérieur, on retrouve le même ATmega328P à 16 MHz que sur l'Uno, la logique est en 5 V et les mêmes bibliothèques fonctionnent sans changement. Sur le Nano d'origine, la communication USB-série est assurée par une puce FT232RL ; presque tous les clones bon marché du marché ont à la place un CH340G ou un CH340C sous la carte. Pour les voitures robots, les projets portables, les télécommandes et tout montage qui doit tenir dans un boîtier, le Nano est un choix plus pratique que l'Uno.

Schéma des broches de l'Arduino Nano : quelle broche est où ?

Les 30 broches du Nano sont disposées en deux rangées face à face de 15 broches, espacées de 15,24 mm (0,6 pouce). Pose la carte devant toi avec la prise mini USB de ton côté : juste à côté de la prise, tu vois deux broches face à face, D12 et D13. La rangée de D13 regroupe 3V3, AREF, A0–A7 et les broches d'alimentation ; la rangée de D12 contient les broches numériques de D11 à D2, suivies de GND, RST, RX0 (D0) et TX1 (D1). À l'extrémité la plus éloignée de l'USB, VIN et TX1 se font face, et le connecteur ICSP 2×3 se trouve aussi de ce côté. Autour du bouton reset, au centre, tu trouves la LED d'alimentation (POW ou ON), la LED L reliée à D13 ainsi que les LED TX et RX qui clignotent pendant le téléversement.

Broches numériques (D0–D13), PWM et fonctions spéciales

Chaque broche numérique est configurée en entrée ou en sortie avec pinMode() ; en sortie, HIGH donne environ 5 V et LOW 0 V. Pour qu'une entrée ne reste pas flottante, tu peux activer avec INPUT_PULLUP la résistance interne de 20–50 kΩ de la puce. Le courant sûr par broche est de 20 mA ; une LED rouge avec une résistance de 220 Ω consomme environ 13 mA, et tu peux trouver la bonne résistance avec le calculateur de résistance pour LED. Certaines broches ont des fonctions supplémentaires, et les connaître à l'avance évite les conflits quand ton projet grandit :

Un petit détail important distingue le Nano de l'Uno : D13. Sur l'Uno R3, la LED L est pilotée par un amplificateur opérationnel, alors que sur le Nano la LED et sa résistance sont reliées directement à la broche. Si tu utilises D13 comme entrée de bouton avec INPUT_PULLUP, la LED tire la broche vers le bas et tu peux lire LOW même sans appui ; réserve cette broche aux sorties ou au SPI. Le fonctionnement du PWM et la signification des valeurs d'analogWrite() sont expliqués dans Qu'est-ce que le PWM ?, et les interruptions dans Interruptions Arduino.

Broches analogiques A0–A7 : pourquoi A6 et A7 sont-elles différentes ?

Les huit entrées analogiques du Nano mesurent les tensions entre 0 et 5 V avec une résolution de 10 bits : analogRead() renvoie un nombre de 0 à 1023 et un pas vaut environ 4,9 mV. Si besoin, A0–A5 fonctionnent aussi comme des broches numériques normales (A0 = 14 … A5 = 19), et A4 et A5 sont en même temps les lignes SDA et SCL du bus I2C. A6 et A7, absentes de l'Uno, sont deux canaux ADC supplémentaires qu'on ne trouve que sur le boîtier CMS (TQFP) de l'ATmega328P. Ces deux canaux ne sont reliés qu'au convertisseur analogique-numérique ; derrière eux, il n'y a ni registre de port, ni étage de sortie, ni résistance de tirage. C'est pourquoi pinMode(), digitalRead(), digitalWrite() et INPUT_PULLUP ne fonctionnent pas sur ces deux broches.

Le fait que A6 et A7 soient seulement analogiques ressemble à un inconvénient, mais on peut en tirer parti. Si tu relies plusieurs boutons à une broche analogique à travers des résistances de valeurs différentes, chaque bouton produit une tension différente ; tu lis ainsi quatre boutons avec une seule broche et tu gardes les broches numériques pour les moteurs et les écrans. Dans le montage, relie A6 à 5V par une résistance de 10 kΩ ; branche le premier bouton directement entre A6 et GND, et les trois autres vers GND à travers des résistances de 2,2 kΩ, 4,7 kΩ et 10 kΩ respectivement.

1// A6'da 4 buton: 10 kΩ pull-up + farklı seri dirençler / 4 buttons on A6: 10 kΩ pull-up + different series resistors
2const byte LADDER_PIN = A6;    // yalnız analog pin / analog-only pin
3
4byte readButton() {
5  int v = analogRead(LADDER_PIN);
6  if (v < 92)  return 1;       // 0 Ω      -> yaklaşık 0 / about 0
7  if (v < 256) return 2;       // 2,2 kΩ   -> yaklaşık 184 / about 184
8  if (v < 419) return 3;       // 4,7 kΩ   -> yaklaşık 327 / about 327
9  if (v < 767) return 4;       // 10 kΩ    -> yaklaşık 512 / about 512
10  return 0;                    // basılı değil -> 1023 / not pressed -> 1023
11}
12
13void setup() {
14  Serial.begin(9600);
15}
16
17void loop() {
18  static byte lastButton = 0;
19  byte b = readButton();
20  if (b != lastButton) {
21    delay(20);                 // kontak sıçramasını bekle / wait out contact bounce
22    b = readButton();          // değeri doğrula / confirm the value
23    if (b != lastButton) {
24      lastButton = b;
25      if (b != 0) {
26        Serial.print(F("Buton / Button: "));
27        Serial.println(b);
28      }
29    }
30  }
31}

Les valeurs viennent de la formule analogRead = 1023 × R / (10 kΩ + R), et chaque seuil se trouve exactement à mi-chemin entre deux valeurs voisines. Comme la résistance de tirage et l'ADC sont alimentés par la même ligne 5 V, les lectures ne changent pas même si l'alimentation tombe à 4,7 V ; on parle de mesure ratiométrique. Si deux boutons sont appuyés en même temps, leurs résistances se retrouvent en parallèle et la valeur lue baisse : le code voit un bouton de plus petit numéro, et 3 et 4 appuyés ensemble donnent même 2. L'échelle de résistances convient donc aux menus où l'on n'appuie que sur une touche à la fois. Tu peux vérifier le calcul avec le calculateur de pont diviseur et en savoir plus sur les lectures analogiques dans l'article sur l'ADC.

Broches d'alimentation : VIN, 5V, 3V3 et GND

Tu peux alimenter le Nano de trois façons. Par USB, le 5 V vient de l'ordinateur à travers une diode Schottky ; la diode fait chuter environ 0,3 V, si bien que tu mesures généralement 4,6–4,8 V sur la broche 5V, et la diode MBR0520 de la carte d'origine est prévue pour 500 mA au maximum. Si tu appliques 7–12 V sur VIN, le régulateur situé sous la carte (un LM1117 sur l'original, le plus souvent un AMS1117 sur les clones) l'abaisse à 5 V. Le régulateur transforme la tension en trop en chaleur : la puissance dissipée vaut (VIN − 5 V) × courant ; si tu consommes 150 mA avec 12 V en entrée, le petit régulateur dissipe environ 1 W et devient trop chaud pour être touché. C'est pourquoi 7–9 V sont idéaux sur VIN. La troisième façon consiste à injecter du 5 V régulé de l'extérieur sur la broche 5V ; le régulateur n'intervient alors plus et la diode côté USB empêche le courant de repartir vers ton ordinateur. Si tu travailles avec une alimentation 12 V, il est bien plus frais de produire du 5 V avec un convertisseur abaisseur LM2596 et de l'envoyer sur la broche 5V ; toutes les façons d'alimenter la carte sont détaillées dans Comment alimenter un Arduino.

La broche 3V3 est la plus mal comprise du Nano. Sur l'Uno, cette broche provient d'un régulateur dédié, alors que le Nano classique n'a pas de régulateur 3,3 V séparé. Sur le Nano d'origine, le 3,3 V provient d'un petit régulateur intégré à la puce FT232RL (50 mA au maximum) et, d'après l'ancienne documentation d'Arduino, cette sortie n'est pas disponible quand la carte n'est pas alimentée par USB. Sur la plupart des clones, la broche est reliée au régulateur interne du CH340 et ne convient qu'à des charges de quelques mA. N'alimente donc pas de modules 3,3 V comme le nRF24L01, l'ESP-01 ou le RC522 par cette broche ; utilise un régulateur AMS1117-3.3 séparé alimenté par la broche 5V. Et quand tu relies une sortie 5 V du Nano à l'entrée d'un module 3,3 V, place entre les deux un convertisseur de niveaux logiques ou un pont diviseur.

Le fait que la broche 5V tourne autour de 4,7 V sur USB influe aussi sur les mesures analogiques : analogRead() prend la tension d'alimentation comme limite haute, et si tu mets 5,0 V dans ton calcul, le résultat est faussé de 4 à 6 %. On peut calculer la vraie tension d'alimentation en mesurant la référence interne fixe d'environ 1,1 V de l'ATmega328P. Le premier programme de test ci-dessous fait exactement cela, convertit les huit entrées analogiques en volts avec la vraie tension d'alimentation et fait clignoter la LED L sur D13 :

1// Arduino Nano: A0-A7'yi ve gerçek besleme gerilimini oku / read A0-A7 and the real supply voltage
2const byte ANALOG_PINS[8] = {A0, A1, A2, A3, A4, A5, A6, A7};
3
4long readVccMillivolts() {
5  // Referans AVcc, ölçülen kanal dahili 1,1 V / reference AVcc, measured channel internal 1.1 V
6  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
7  delay(2);                                // referansın oturmasını bekle / let the reference settle
8  ADCSRA |= _BV(ADSC);                     // dönüşümü başlat / start the conversion
9  while (bit_is_set(ADCSRA, ADSC)) {}      // bitmesini bekle / wait until it finishes
10  unsigned int raw = ADC;                  // 10 bit sonuç / 10-bit result
11  return 1125300L / raw;                   // 1,1 V x 1023 x 1000 / 1.1 V x 1023 x 1000
12}
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED_BUILTIN, OUTPUT);            // D13'teki L LED'i / L LED on D13
17}
18
19void loop() {
20  long vcc = readVccMillivolts();
21  analogRead(A0);                          // kanal değişti, ilk okumayı at / channel changed, discard the first reading
22  Serial.print(F("Vcc: "));
23  Serial.print(vcc);
24  Serial.print(F(" mV |"));
25  for (byte i = 0; i < 8; i++) {
26    int raw = analogRead(ANALOG_PINS[i]);  // A6 ve A7 de okunur / A6 and A7 are read too
27    Serial.print(F(" A"));
28    Serial.print(i);
29    Serial.print(F("="));
30    Serial.print(raw * (vcc / 1000.0) / 1023.0, 2);   // gerçek Vcc ile volta çevir / convert to volts using the real Vcc
31  }
32  Serial.println();
33  digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));   // L LED'ini çevir / toggle the L LED
34  delay(1000);
35}

Après le téléversement, ouvre le moniteur série à 9600 bauds. La valeur Vcc doit se situer autour de 4600–4800 mV sur USB et autour de 5000 mV avec une alimentation par VIN. Les broches analogiques non reliées affichent des valeurs aléatoires ; si tu branches un potentiomètre sur A0 et que tu le tournes, la valeur varie régulièrement entre 0 et Vcc. La référence interne peut varier de ±10 % d'une puce à l'autre ; pour un résultat plus précis, mesure la broche 5V au multimètre et multiplie la constante 1125300 du code par le rapport valeur mesurée / valeur affichée par le code. Comme ce programme utilise directement les registres de l'ATmega328P, il ne fonctionne ni sur le Nano Every ni sur le Nano ESP32.

Mini USB, CH340 et installation du pilote

Le Nano classique a une prise USB Mini-B ; les câbles Micro-USB ou USB-C des téléphones n'y entrent pas. Certains clones récents ont une prise Micro-USB ou USB-C, mais la plupart sont toujours en mini USB. La raison la plus fréquente pour laquelle la carte n'apparaît pas du tout dans la liste des ports est un câble de charge seule, sans fils de données : la LED d'alimentation s'allume, mais l'ordinateur ne voit pas la carte. Si le câble est bon, retourne la carte et regarde la puce près de la prise USB. S'il est écrit FT232RL, c'est un Nano d'origine dont le pilote est généralement déjà présent dans le système ; s'il est écrit CH340G ou CH340C, tu as un clone.

Windows 10 et 11 installent souvent eux-mêmes le pilote CH340 via Windows Update, et la carte apparaît dans le Gestionnaire de périphériques sous un nom comme USB-SERIAL CH340 (COM3). Si tu vois un USB2.0-Serial avec un point d'exclamation jaune sous Autres périphériques, installe le pilote CH341SER du fabricant de la puce, WCH, puis débranche et rebranche la carte. Les versions récentes de macOS intègrent le pilote ; le port apparaît sous le nom /dev/cu.usbserial-…, et installer en plus d'anciens pilotes peut créer des conflits. Sous Linux, le pilote est inclus dans le noyau ; si le port disparaît dès que tu branches la carte sous Ubuntu 22.04 ou plus récent, c'est le paquet de lecteur d'écran brltty qui s'approprie le CH340, et si tu ne l'utilises pas tu peux le supprimer avec sudo apt remove brltty. Tous les problèmes de port et de pilote sont traités dans Erreur de téléversement Arduino, et les différences entre puces USB-série dans Convertisseurs USB-TTL.

Téléverser le code : ATmega328P ou Old Bootloader ?

1. Dans l'IDE Arduino, choisis Outils > Carte > Arduino AVR Boards > Arduino Nano.
2. Branche la carte et choisis dans Outils > Port le port qui vient d'apparaître (par exemple COM3 sous Windows ou /dev/cu.usbserial-… sous macOS).
3. Dans Outils > Processor, essaie d'abord de téléverser l'exemple Blink avec l'option ATmega328P.
4. Si la sortie répète programmer is not responding ou not in sync pendant dix tentatives, passe Processor sur ATmega328P (Old Bootloader) et téléverse à nouveau.
5. Si ça ne marche toujours pas, essaie un autre port USB, retire les fils de D0 et D1 et vérifie que la LED L clignote rapidement quand tu appuies sur le bouton reset.
6. Note l'option qui a fonctionné ; les autres Nano achetés chez le même vendeur auront très probablement besoin du même réglage.

Cette confusion vient d'un changement fait en 2018. Arduino a remplacé l'ancien bootloader de 2 Ko du Nano (ATmegaBOOT) par l'Optiboot de 512 octets utilisé sur l'Uno. Optiboot reçoit le code à 115200 bauds, alors que l'ancien bootloader attend 57600 bauds ; quand les vitesses ne correspondent pas, la carte semble ne pas répondre du tout. Comme les fabricants de clones ont continué pendant des années à livrer des cartes avec l'ancien bootloader, l'IDE propose les deux options, et un mauvais choix n'abîme pas la carte. Si tu veux, tu peux utiliser un second Arduino comme ArduinoISP pour graver le nouveau bootloader sur le Nano : les téléversements sont plus rapides et la boucle de redémarrages sans fin de l'ancien bootloader après un reset du watchdog disparaît aussi.

Placement sur breadboard et soudure

Quand tu piques le Nano sur une breadboard, place-le de façon que les deux rangées de broches se trouvent de part et d'autre de la rainure centrale. Ainsi, chaque broche tombe sur sa propre bande et tu peux y relier des fils par les trous libres de la bande. Comme la carte recouvre la rainure et les trous situés entre les broches, il ne reste que quelques trous à côté de chaque broche ; sur les breadboards courantes de 830 points, si tu centres la carte sur la rainure, il reste 2 trous libres d'un côté et 3 de l'autre. En orientant la prise USB vers le petit côté de la breadboard, le câble se branche facilement. Relie ensuite les broches 5V et GND du Nano aux lignes d'alimentation rouge et bleue de la breadboard pour pouvoir y alimenter tes capteurs. Pour te rappeler comment une breadboard est reliée à l'intérieur, lis Qu'est-ce qu'une breadboard ?.

• Souder les barrettes : Sur les clones livrés avec des broches en vrac, pique d'abord les barrettes mâles dans la breadboard, pose le Nano dessus et soude-le ainsi ; la breadboard maintient les barrettes droites et exactement à 0,6 pouce d'écart. La technique est expliquée dans Comment souder.
• Pour le retirer : Soulever la carte par une seule extrémité tord les broches ; soulève les deux extrémités petit à petit, ou glisse un tournevis plat dessous et retire-la de façon uniforme.
• Faux contacts : Sur les breadboards anciennes ou bon marché, les ressorts se détendent ; le Nano redémarre de temps en temps ou un capteur disparaît par moments. Essaie de déplacer la carte sur une autre zone de la breadboard.
• Carte d'extension Nano : Pour un projet définitif, un Nano I/O shield avec borniers à vis ou connecteurs 3 broches, qui fournit signal, 5V et GND pour chaque broche, réduit fortement le fouillis de fils.
• Mini breadboard : Les petites breadboards de 170 points n'ont pas de lignes d'alimentation ; amène 5V et GND sur des bandes séparées et repère-les avec des couleurs de fils.

Tableau de correspondance des broches Arduino Uno et Nano

Comme le montre le tableau, pour passer au Nano un montage prévu pour l'Uno, il suffit de relier les fils aux broches de même numéro : un servo sur D9 de l'Uno va sur D9 du Nano, et un écran I2C sur A4/A5 reste sur A4/A5. Le seul changement dans le code est de choisir Arduino Nano dans Outils > Carte. En revanche, les shields qui s'enfichent directement sur l'Uno ne vont pas sur le Nano ; il existe pour cela des cartes adaptatrices qui donnent au Nano le brochage de l'Uno. Tu trouveras le rôle détaillé de chaque broche de l'Uno dans Brochage Arduino Uno, et de l'aide pour choisir ta carte dans Quel Arduino acheter ?.

Nano Every et Nano ESP32 : différences avec le Nano classique

Le Nano Every est une version plus puissante du Nano classique, de même taille et au même brochage. Il embarque un ATmega4809, fonctionne en 5 V et offre 48 Ko de flash et 6 Ko de SRAM ; les projets avec écran OLED ou ruban de LED qui manquent de RAM sur le Nano classique respirent donc mieux. Côté USB, une puce SAMD11 sert de pont et le code est téléversé via l'interface UPDI, il n'y a donc pas de souci d'Old Bootloader. Pour utiliser la carte, installe le paquet Arduino megaAVR Boards depuis le gestionnaire de cartes. Voici les différences à connaître : le PWM n'existe que sur D3, D5, D6, D9 et D10 (D11 n'a pas de PWM), A6 et A7 fonctionnent aussi en numérique, chaque broche numérique peut servir d'interruption externe, et D0 et D1 forment un port Serial1 indépendant de l'USB. Le réglage Outils > Registers emulation > ATMEGA328 émule les registres de port comme PORTB, mais l'ancien code qui écrit directement dans les registres des timers ou de l'ADC ne fonctionne toujours pas. Le programme ci-dessous montre deux différences de l'Every à la fois : il dialogue avec un module sur D0/D1 pendant que le moniteur série est ouvert, et il utilise A7 comme entrée de bouton avec la résistance de tirage interne.

1// Nano Every: Serial = USB, Serial1 = D0 (RX) ve D1 (TX) / Serial = USB, Serial1 = D0 (RX) and D1 (TX)
2const byte BUTTON_PIN = A7;            // Every'de A7 dijital de çalışır / A7 also works as digital on the Every
3
4bool lastState = HIGH;
5
6void setup() {
7  Serial.begin(9600);                  // Seri Monitör / Serial Monitor
8  Serial1.begin(9600);                 // D0/D1'deki modül, ör. HC-05 / module on D0/D1, e.g. HC-05
9  pinMode(BUTTON_PIN, INPUT_PULLUP);   // klasik Nano'nun A7'sinde çalışmaz / does not work on the classic Nano's A7
10}
11
12void loop() {
13  if (Serial1.available()) {
14    Serial.write(Serial1.read());      // modülden bilgisayara / module to computer
15  }
16  if (Serial.available()) {
17    Serial1.write(Serial.read());      // bilgisayardan modüle / computer to module
18  }
19  bool state = digitalRead(BUTTON_PIN);
20  if (state != lastState) {            // durum değişince bildir / report when the state changes
21    lastState = state;
22    Serial1.println(state == LOW ? "Buton basildi / Button pressed" : "Buton birakildi / Button released");
23    delay(20);                         // kontak sıçraması / contact bounce
24  }
25}

Le Nano ESP32, lui, est un tout autre monde dans le même format : le processeur ESP32-S3 du module u-blox NORA-W106 tourne à 240 MHz et offre le Wi-Fi et le Bluetooth LE. La différence la plus importante est la tension : toutes les broches fonctionnent en 3,3 V et ne tolèrent pas le 5 V ; un capteur à sortie 5 V que tu brancherais directement sur un Nano classique peut endommager le Nano ESP32. À l'emplacement de la broche 5V du Nano classique se trouve une broche VBUS, qui ne fournit du 5 V que lorsque la carte est alimentée par USB ; avec une alimentation par VIN, cette broche reste hors tension. À la place d'AREF et de la broche RST côté analogique, tu trouves BOOT0 et BOOT1. La carte se programme avec le paquet Arduino ESP32 Boards, et le menu Outils > Pin Numbering propose deux options : avec le réglage par défaut By Arduino pin, ce sont les noms D et A imprimés sur la carte qui comptent ; avec By GPIO number, les nombres sont les numéros GPIO de l'ESP32. Par exemple, D2 est en réalité le GPIO5 ; en mode GPIO, écrire pinMode(2, OUTPUT) configure en fait la broche A1. Si tu écris toujours les broches par leur nom, comme D2 et A0, ton code fonctionne correctement dans les deux modes.

1// Nano ESP32: Araçlar > Pin Numbering > By Arduino pin (default)
2// Nano ESP32: Tools > Pin Numbering > By Arduino pin (default)
3bool ledOn = false;
4
5void setup() {
6  Serial.begin(115200);                // USB-C üzerinden / over USB-C
7  pinMode(LED_BUILTIN, OUTPUT);        // D13 = GPIO48
8  pinMode(LED_RED, OUTPUT);
9  pinMode(LED_GREEN, OUTPUT);
10  pinMode(LED_BLUE, OUTPUT);
11  digitalWrite(LED_RED, HIGH);         // RGB LED ters mantık: HIGH = sönük / active low: HIGH = off
12  digitalWrite(LED_GREEN, HIGH);
13  digitalWrite(LED_BLUE, HIGH);
14  analogReadResolution(12);            // 0-4095 arası / range 0-4095
15}
16
17void loop() {
18  int raw = analogRead(A0);            // 12 bit ham değer / 12-bit raw value
19  int mv = analogReadMilliVolts(A0);   // kalibre edilmiş milivolt / calibrated millivolts
20  Serial.printf("A0: %d  (%d mV)\n", raw, mv);
21  digitalWrite(LED_GREEN, mv > 1650 ? LOW : HIGH);   // 1,65 V üstünde yeşil / green above 1.65 V
22  digitalWrite(LED_RED, mv > 1650 ? HIGH : LOW);     // altında kırmızı / red below
23  ledOn = !ledOn;
24  digitalWrite(LED_BUILTIN, ledOn ? HIGH : LOW);     // D13 LED'ini yakıp söndür / blink the D13 LED
25  delay(500);
26}

Les entrées analogiques du Nano ESP32 mesurent sur 12 bits et renvoient des valeurs de 0 à 4095, tandis que analogReadMilliVolts() utilise les données d'étalonnage de la puce pour donner directement le résultat en millivolts. La LED RGB de la carte fonctionne en logique inversée : elle s'allume quand tu écris LOW. Si le code ne se téléverse pas et que la carte disparaît de la liste des ports, tu peux la passer en mode bootloader en appuyant deux fois rapidement sur le bouton reset. Pour découvrir le côté Wi-Fi de l'ESP32, lis Qu'est-ce que l'ESP32 ?, et pour choisir ta carte, Arduino ou ESP32 ?. Parmi les autres membres de la famille, le Nano R4 apporte le même Renesas RA4M1 à 48 MHz que l'Uno R4 au format Nano 5 V, mais ne fournit que 8 mA par broche, tandis que les Nano 33 IoT et Nano 33 BLE sont, comme le Nano ESP32, des cartes 3,3 V.

Idées de projets avec l'Arduino Nano

• Thermomètre de poche : Affiche la température mesurée par un DHT11 sur un petit écran OLED ; le Nano et l'écran tiennent dans une boîte d'allumettes.
• Mini voiture robot : La petite taille du Nano fait gagner de la place sur le châssis ; pilote les moteurs avec un L298N et suis les étapes de Fabriquer une voiture robot.
• Robot suiveur de ligne : Huit entrées analogiques suffisent largement pour lire une barrette de cinq capteurs ; les détails sont dans Robot suiveur de ligne.
• Télécommande Bluetooth : Relie un module HC-05 à D8 et D7 avec SoftwareSerial et commande une LED ou un relais depuis ton téléphone ; D0 et D1 restent libres pour le téléversement.
• Lumière à porter : Fabrique un badge lumineux ou une lumière de sac avec un Nano sur piles et quelques LED WS2812B.
• Un clavier sur une seule broche : Monte l'échelle de résistances ci-dessus sur A6 et sur A7 pour obtenir un menu à huit boutons, et garde les broches numériques pour l'écran et les moteurs.
• Tu veux un clavier USB ? L'ATmega328P du Nano classique n'a pas d'USB intégré, il ne peut donc pas se présenter à l'ordinateur comme un clavier ou une souris ; pour cela il faut des cartes à ATmega32U4 comme le Leonardo et le Pro Micro.

Erreurs fréquentes et solutions

L'Arduino Nano est le moyen le plus simple d'emmener tout ce que tu as appris avec l'Uno vers des projets compacts et définitifs ; tant que tu connais les particularités d'A6/A7, du 3V3 et du bootloader, tu n'auras pas de mauvaise surprise. Si tu veux revenir aux bases, commence par Qu'est-ce qu'Arduino ?. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas de câblage et code prêt à l'emploi, des projets pour allumer une LED, une LED avec bouton, mesurer la lumière avec une LDR, une distance avec le HC-SR04, la température et l'humidité avec le DHT11, une LED RGB, un servo avec un potentiomètre et une communication série entre deux Arduino ; tous fonctionnent sur le Nano avec les mêmes numéros de broches.