Pinout Arduino Nano: pin, A6/A7, alimentazione e Old Bootloader

Il pinout di Arduino Nano comprende 30 pin allineati sui due lati lunghi di una scheda di 45 × 18 mm: 14 pin digitali di ingresso/uscita (D0–D13), di cui 6 possono generare PWM (~3, 5, 6, 9, 10, 11), 8 ingressi analogici (A0–A7) e i pin di alimentazione e controllo VIN, 5V, 3V3, AREF, due GND e due RST. Poiché Nano usa lo stesso processore ATmega328P di Arduino Uno, anche numeri e funzioni dei pin sono gli stessi: uno sketch scritto per Uno funziona senza alcuna modifica, basta scegliere Nano nel menu delle schede.

Ci sono però alcuni dettagli importanti che distinguono Nano da Uno, ed è proprio lì che i principianti si bloccano: A6 e A7 sono solo analogici, la scheda non ha il jack di alimentazione, il pin 3V3 eroga pochissima corrente, sui cloni la parte USB è gestita da un chip CH340 e per caricare il codice spesso devi scegliere ATmega328P (Old Bootloader). In questa guida conoscerai ogni pin, imparerai a posizionare correttamente Nano sulla breadboard, vedrai la corrispondenza dei pin con Uno e scoprirai in cosa Nano Every e Nano ESP32 si differenziano dal Nano classico.

Che cos'è Arduino Nano e in cosa è diverso da Uno?

Arduino Nano racchiude tutte le funzioni di base di Uno in una scheda di 45 × 18 mm che pesa circa 7 grammi. I suoi pin sono rivolti verso il basso, quindi si inserisce direttamente nella breadboard; così si riducono i cavetti e, a circuito finito, lo si sposta facilmente in una scatola o su un circuito definitivo. All'interno c'è lo stesso ATmega328P a 16 MHz di Uno, la logica è a 5 V e le stesse librerie funzionano senza modifiche. Sul Nano originale la comunicazione USB-seriale è affidata a un chip FT232RL; quasi tutti i cloni economici in commercio hanno invece un CH340G o un CH340C sul lato inferiore. Per macchinine robot, progetti indossabili, telecomandi e qualsiasi circuito che debba stare in una scatola, Nano è una scelta più pratica di Uno.

Schema dei pin di Arduino Nano: dove si trova ogni pin?

I 30 pin di Nano sono disposti in due file contrapposte da 15, distanti 15,24 mm (0,6 pollici). Se metti la scheda davanti a te con la presa mini USB rivolta verso di te, subito accanto alla presa vedi due pin uno di fronte all'altro: D12 e D13. Nella fila di D13 si trovano 3V3, AREF, A0–A7 e i pin di alimentazione; nella fila di D12 ci sono i pin digitali da D11 a D2, seguiti da GND, RST, RX0 (D0) e TX1 (D1). All'estremità più lontana dall'USB, VIN e TX1 sono uno di fronte all'altro, e lì si trova anche il connettore ICSP 2×3. Intorno al pulsante di reset al centro trovi il LED di alimentazione (POW o ON), il LED L collegato a D13 e i LED TX e RX che lampeggiano durante il caricamento.

Pin digitali (D0–D13), PWM e funzioni speciali

Ogni pin digitale si imposta come ingresso o uscita con pinMode(); come uscita, HIGH dà circa 5 V e LOW 0 V. Per non lasciare un ingresso flottante puoi attivare con INPUT_PULLUP la resistenza interna da 20–50 kΩ del chip. La corrente sicura per pin è di 20 mA; un LED rosso con una resistenza da 220 Ω assorbe circa 13 mA, e puoi trovare la resistenza giusta con il calcolatore della resistenza per LED. Alcuni pin hanno funzioni aggiuntive, e conoscerle in anticipo evita conflitti quando il progetto cresce:

Un dettaglio piccolo ma importante che distingue Nano da Uno riguarda D13. Su Uno R3 il LED L è pilotato tramite un amplificatore operazionale, mentre su Nano il LED e la sua resistenza sono collegati direttamente al pin. Se usi D13 come ingresso per un pulsante con INPUT_PULLUP, il LED tira il pin verso il basso e potresti leggere LOW anche a pulsante rilasciato; riserva questo pin alle uscite o all'SPI. Come funziona il PWM e cosa significano i valori di analogWrite() lo trovi in Cos'è il PWM, gli interrupt in Interrupt su Arduino.

Pin analogici A0–A7: perché A6 e A7 sono diversi?

Gli otto ingressi analogici di Nano misurano tensioni tra 0 e 5 V con una risoluzione di 10 bit: analogRead() restituisce un numero da 0 a 1023 e un passo vale circa 4,9 mV. All'occorrenza A0–A5 funzionano anche come normali pin digitali (A0 = 14 … A5 = 19), e A4 e A5 sono anche le linee SDA e SCL del bus I2C. A6 e A7, che Uno non ha, sono due canali ADC aggiuntivi presenti solo nel package a montaggio superficiale (TQFP) dell'ATmega328P. Questi due canali sono collegati solo al convertitore analogico-digitale; dietro non c'è né un registro di porta, né un driver di uscita, né una resistenza di pull-up. Per questo pinMode(), digitalRead(), digitalWrite() e INPUT_PULLUP non funzionano su questi due pin.

Il fatto che A6 e A7 siano solo analogici sembra uno svantaggio, ma si può sfruttare in modo furbo. Se colleghi più pulsanti a un pin analogico tramite resistenze di valore diverso, ogni pulsante produce una tensione diversa; così leggi quattro pulsanti con un solo pin e lasci i pin digitali a motori e display. Nel circuito collega A6 a 5V con una resistenza da 10 kΩ; collega il primo pulsante direttamente tra A6 e GND e gli altri tre verso GND tramite resistenze da 2,2 kΩ, 4,7 kΩ e 10 kΩ.

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}

I valori derivano dalla formula analogRead = 1023 × R / (10 kΩ + R), e ogni soglia sta esattamente a metà tra due valori vicini. Poiché la resistenza di pull-up e l'ADC sono alimentati dalla stessa linea a 5 V, le letture non cambiano anche se l'alimentazione scende a 4,7 V; si parla di misura raziometrica. Se premi due pulsanti insieme, le loro resistenze finiscono in parallelo e la lettura scende: il codice vede un pulsante con numero più basso, e 3 e 4 premuti insieme risultano addirittura come 2. Per questo la scala di resistenze va bene per menu in cui si preme un solo tasto alla volta. Puoi verificare il calcolo con il calcolatore del partitore di tensione e approfondire le letture analogiche nell'articolo sull'ADC.

Pin di alimentazione: VIN, 5V, 3V3 e GND

Puoi alimentare Nano in tre modi. Tramite USB, i 5 V arrivano dal computer attraverso un diodo Schottky; il diodo fa cadere circa 0,3 V, quindi sul pin 5V di solito misuri 4,6–4,8 V, e il diodo MBR0520 della scheda originale è previsto per 500 mA al massimo. Se applichi 7–12 V sul pin VIN, il regolatore sul lato inferiore (un LM1117 sull'originale, quasi sempre un AMS1117 sui cloni) li abbassa a 5 V. Il regolatore trasforma la tensione in eccesso in calore: la potenza dissipata è (VIN − 5 V) × corrente, quindi se assorbi 150 mA con 12 V in ingresso il piccolo regolatore dissipa circa 1 W e diventa troppo caldo da toccare. Per questo su VIN l'ideale sono 7–9 V. Il terzo modo è fornire 5 V stabilizzati dall'esterno sul pin 5V; in questo caso il regolatore viene escluso e il diodo sul lato USB impedisce che la corrente torni verso il computer. Se lavori con un alimentatore da 12 V, è molto più fresco ricavare 5 V con un convertitore step-down LM2596 e portarli al pin 5V; tutti i modi di alimentazione sono spiegati in Come alimentare Arduino.

Il pin 3V3 è il più frainteso di Nano. Su Uno questo pin arriva da un regolatore dedicato, mentre il Nano classico non ha un regolatore a 3,3 V separato. Sul Nano originale i 3,3 V arrivano da un piccolo regolatore interno al chip FT232RL (50 mA al massimo) e, secondo la vecchia documentazione di Arduino, questa uscita non è disponibile quando la scheda non è alimentata via USB. Sulla maggior parte dei cloni il pin è collegato al regolatore interno del CH340 ed è sicuro solo per carichi di pochi mA. Quindi non alimentare da questo pin moduli a 3,3 V come nRF24L01, ESP-01 o RC522; usa un regolatore AMS1117-3.3 separato alimentato dal pin 5V. E quando colleghi un'uscita a 5 V di Nano all'ingresso di un modulo a 3,3 V, metti in mezzo un convertitore di livello o un partitore di tensione.

Il fatto che con l'USB il pin 5V si trovi intorno a 4,7 V influisce anche sulle misure analogiche: analogRead() usa la tensione di alimentazione come limite superiore, e se nel calcolo metti 5,0 V il risultato si sposta del 4–6 %. Si può calcolare la tensione di alimentazione reale misurando il riferimento interno fisso di circa 1,1 V dell'ATmega328P. Il primo sketch di prova qui sotto fa proprio questo, converte in volt tutti e otto gli ingressi analogici usando la tensione reale e fa lampeggiare il LED L su 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}

Dopo il caricamento apri il monitor seriale a 9600 baud. Il valore Vcc dovrebbe essere intorno a 4600–4800 mV con l'USB e intorno a 5000 mV con l'alimentazione da VIN. I pin analogici scollegati mostrano valori casuali; se colleghi un potenziometro ad A0 e lo ruoti, vedrai il valore cambiare in modo regolare tra 0 e Vcc. Il riferimento interno può variare del ±10 % da chip a chip; per un risultato più preciso misura il pin 5V con un multimetro e moltiplica la costante 1125300 del codice per il rapporto valore misurato / valore mostrato dal codice. Poiché questo sketch usa direttamente i registri dell'ATmega328P, non funziona su Nano Every né su Nano ESP32.

Mini USB, CH340 e installazione del driver

Il Nano classico ha una presa USB Mini-B; i cavi Micro-USB o USB-C dei telefoni non entrano. Alcuni cloni recenti hanno prese Micro-USB o USB-C, ma la maggior parte è ancora mini USB. Il motivo più comune per cui la scheda non compare affatto nell'elenco delle porte è un cavo di sola ricarica, senza fili dati: il LED di alimentazione si accende, ma il computer non vede la scheda. Se il cavo è a posto, gira la scheda e guarda il chip vicino alla presa USB. Se c'è scritto FT232RL è un Nano originale e il driver di solito è già presente nel sistema operativo; se c'è scritto CH340G o CH340C, hai un clone.

Windows 10 e 11 spesso installano da soli il driver del CH340 tramite Windows Update, e la scheda compare in Gestione dispositivi con un nome come USB-SERIAL CH340 (COM3). Se sotto Altri dispositivi vedi un USB2.0-Serial con un punto esclamativo giallo, installa il driver CH341SER del produttore del chip, WCH, poi scollega e ricollega la scheda. Le versioni recenti di macOS includono già il driver; la porta compare come /dev/cu.usbserial-…, e installare in più vecchi driver può creare conflitti. Su Linux il driver è già nel kernel; se su Ubuntu 22.04 o successivi la porta sparisce appena colleghi la scheda, è il pacchetto di lettura dello schermo brltty che si prende il CH340, e se non lo usi puoi rimuoverlo con sudo apt remove brltty. Tutti i problemi di porta e driver sono trattati in Errore di caricamento su Arduino, le differenze tra i chip USB-seriale in Convertitori USB-TTL.

Caricare il codice: ATmega328P o Old Bootloader?

1. Nell'IDE Arduino scegli Strumenti > Scheda > Arduino AVR Boards > Arduino Nano.
2. Collega la scheda e scegli in Strumenti > Porta la porta appena comparsa (per esempio COM3 su Windows o /dev/cu.usbserial-… su macOS).
3. In Strumenti > Processor prova prima a caricare l'esempio Blink con l'opzione ATmega328P.
4. Se l'output ripete programmer is not responding o not in sync per dieci tentativi, imposta Processor su ATmega328P (Old Bootloader) e carica di nuovo.
5. Se ancora non funziona, prova un'altra porta USB, togli i cavi da D0 e D1 e controlla che il LED L lampeggi velocemente quando premi il pulsante di reset.
6. Annota quale opzione ha funzionato; gli altri Nano dello stesso venditore richiederanno molto probabilmente la stessa impostazione.

Il motivo di questa confusione è una modifica del 2018. Arduino ha sostituito il vecchio bootloader da 2 KB del Nano (ATmegaBOOT) con l'Optiboot da 512 byte usato su Uno. Optiboot riceve il codice a 115200 baud, mentre il vecchio bootloader si aspetta 57600 baud; se le velocità non coincidono, la scheda sembra non rispondere affatto. Poiché i produttori di cloni hanno continuato per anni a usare il vecchio bootloader, l'IDE offre entrambe le opzioni, e scegliere quella sbagliata non danneggia la scheda. Se vuoi, puoi usare un secondo Arduino come ArduinoISP per scrivere il nuovo bootloader su Nano: i caricamenti diventano più veloci e sparisce anche il ciclo infinito di riavvii del vecchio bootloader dopo un reset del watchdog.

Posizionamento sulla breadboard e saldatura

Quando inserisci Nano nella breadboard, posizionalo in modo che le due file di pin si trovino ai due lati del canale centrale. Così ogni pin finisce sulla sua striscia e puoi collegare i cavi a quel pin tramite i fori liberi della striscia. Poiché la scheda copre il canale e i fori tra i pin, accanto a ogni pin restano solo pochi fori; sulle comuni breadboard da 830 punti, se centri la scheda sul canale restano 2 fori liberi da un lato e 3 dall'altro. Se orienti la presa USB verso il lato corto della breadboard, il cavo si inserisce comodamente. Poi collega i pin 5V e GND di Nano alle linee di alimentazione rossa e blu della breadboard, così da alimentare i sensori da lì. Per ripassare come sono collegati i fori all'interno, leggi Cos'è una breadboard.

• Saldare gli strip di pin: Sui cloni con i pin sciolti, inserisci prima gli strip maschio nella breadboard, appoggia Nano sopra e saldalo così; la breadboard tiene gli strip dritti ed esattamente a 0,6 pollici di distanza. Trovi la tecnica in Come saldare.
• Per toglierlo: Sollevare la scheda da un solo lato piega i pin; solleva le due estremità un po' per volta, oppure infila sotto un cacciavite piatto ed estraila in modo uniforme.
• Falsi contatti: Nelle breadboard vecchie o economiche le mollette si allentano; Nano si riavvia ogni tanto o un sensore sparisce a tratti. Prova a spostare la scheda in un'altra zona della breadboard.
• Scheda di espansione per Nano: In un progetto definitivo, una Nano I/O shield con morsetti a vite o connettori a 3 pin che fornisce segnale, 5V e GND per ogni pin riduce molto il groviglio di cavi.
• Mini breadboard: Le piccole breadboard da 170 punti non hanno linee di alimentazione; porta 5V e GND su strisce separate e contrassegnale con i colori dei cavi.

Tabella di corrispondenza dei pin tra Arduino Uno e Nano

Come vedi nella tabella, per spostare su Nano un circuito costruito per Uno basta collegare i cavi ai pin con lo stesso numero: un servo su D9 di Uno va su D9 di Nano, e un display I2C su A4/A5 resta su A4/A5. L'unica modifica nel codice è scegliere Arduino Nano in Strumenti > Scheda. Le shield che si innestano direttamente su Uno, però, non entrano su Nano; per questo esistono schede adattatrici che portano Nano al layout dei pin di Uno. Trovi il ruolo dettagliato di ogni pin di Uno in Pinout Arduino Uno, e un aiuto nella scelta della scheda in Quale Arduino comprare?.

Nano Every e Nano ESP32: le differenze dal Nano classico

Nano Every è una versione più potente del Nano classico, con le stesse dimensioni e lo stesso pinout. Monta un ATmega4809, funziona a 5 V e offre 48 KB di flash e 6 KB di SRAM; i progetti con display OLED o strisce LED che sul Nano classico restano a corto di RAM respirano meglio. Sul lato USB un chip SAMD11 fa da ponte e il codice viene caricato tramite l'interfaccia UPDI, quindi niente problemi di Old Bootloader. Per usare la scheda devi installare il pacchetto Arduino megaAVR Boards dal Gestore schede. Queste sono le differenze da tenere presenti: il PWM è disponibile solo su D3, D5, D6, D9 e D10 (D11 non ha il PWM), A6 e A7 funzionano anche come digitali, ogni pin digitale può essere usato come interrupt esterno e D0 e D1 sono una porta Serial1 indipendente dall'USB. L'impostazione Strumenti > Registers emulation > ATMEGA328 emula i registri di porta come PORTB, ma il vecchio codice che scrive direttamente nei registri dei timer o dell'ADC continua a non funzionare. Lo sketch qui sotto mostra due differenze di Every insieme: dialoga con un modulo su D0/D1 mentre il monitor seriale è aperto e usa A7 come ingresso per un pulsante con il pull-up interno.

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}

Nano ESP32, invece, è un mondo completamente diverso nello stesso formato: il processore ESP32-S3 del modulo u-blox NORA-W106 lavora a 240 MHz e offre Wi-Fi e Bluetooth LE. La differenza più importante è la tensione: tutti i pin lavorano a 3,3 V e non tollerano i 5 V; un sensore con uscita a 5 V che collegheresti direttamente a un Nano classico può danneggiare Nano ESP32. Al posto del pin 5V del Nano classico c'è un pin VBUS, che fornisce 5 V solo quando la scheda è alimentata via USB; con l'alimentazione da VIN questo pin resta senza tensione. Al posto di AREF e del pin RST sul lato analogico trovi BOOT0 e BOOT1. La scheda si programma con il pacchetto Arduino ESP32 Boards, e il menu Strumenti > Pin Numbering ha due opzioni: con l'impostazione predefinita By Arduino pin valgono i nomi D e A stampati sulla scheda, con By GPIO number i numeri sono i GPIO dell'ESP32. Per esempio D2 in realtà è il GPIO5; in modalità GPIO, se scrivi pinMode(2, OUTPUT) stai configurando il pin A1. Se scrivi sempre i pin con il loro nome, come D2 e A0, il codice funziona correttamente in entrambe le modalità.

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}

Gli ingressi analogici di Nano ESP32 misurano a 12 bit e restituiscono valori da 0 a 4095, mentre analogReadMilliVolts() usa i dati di calibrazione del chip per dare il risultato direttamente in millivolt. Il LED RGB sulla scheda funziona con logica invertita, cioè si accende quando scrivi LOW. Se il codice non si carica e la scheda sparisce dall'elenco delle porte, puoi metterla in modalità bootloader premendo due volte in rapida successione il pulsante di reset. Per scoprire il lato Wi-Fi dell'ESP32 leggi Cos'è l'ESP32, e per scegliere la scheda Arduino o ESP32?. Tra gli altri membri della famiglia, Nano R4 porta lo stesso Renesas RA4M1 a 48 MHz di Uno R4 nel formato Nano a 5 V, ma eroga solo 8 mA per pin, mentre Nano 33 IoT e Nano 33 BLE sono schede a 3,3 V come Nano ESP32.

Idee di progetto con Arduino Nano

• Termometro tascabile: Mostra la temperatura misurata con un DHT11 su un piccolo display OLED; Nano e display stanno in una scatola di fiammiferi.
• Mini macchinina robot: Le piccole dimensioni di Nano fanno risparmiare spazio sul telaio; pilota i motori con un L298N e segui i passaggi di Costruire una macchinina robot.
• Robot segui-linea: Otto ingressi analogici bastano e avanzano per leggere una barra di cinque sensori; i dettagli sono in Robot segui-linea.
• Telecomando Bluetooth: Collega un modulo HC-05 a D8 e D7 con SoftwareSerial e comanda un LED o un relè dal telefono; D0 e D1 restano liberi per il caricamento.
• Luce da indossare: Realizza un badge luminoso o una luce per lo zaino con un Nano a batteria e qualche LED WS2812B.
• Tastiera su un solo pin: Monta la scala di resistenze vista sopra sia su A6 sia su A7 per avere un menu a otto pulsanti e lascia i pin digitali a display e motori.
• Vuoi una tastiera USB? L'ATmega328P del Nano classico non ha l'USB integrato, quindi non può presentarsi al computer come tastiera o mouse; per questo servono schede con ATmega32U4 come Leonardo e Pro Micro.

Errori comuni e soluzioni

Arduino Nano è il modo più semplice per portare tutto ciò che hai imparato con Uno in progetti piccoli e definitivi; finché conosci le differenze su A6/A7, 3V3 e bootloader, non avrai sorprese. Se vuoi tornare alle basi, comincia da Cos'è Arduino. Nell'app BlueGrays trovi, passo dopo passo e con schemi di collegamento e codice pronto, progetti per accendere un LED, un LED con pulsante, misurare la luce con una fotoresistenza, la distanza con l'HC-SR04, temperatura e umidità con il DHT11, un LED RGB, un servo con potenziometro e la comunicazione seriale tra due Arduino; funzionano tutti su Nano con gli stessi numeri di pin.