Pinout Arduino Uno: pin digitali, PWM, analogici e alimentazione

Il pinout di Arduino Uno comprende 32 punti di collegamento allineati sui connettori femmina neri dei due lati lunghi della scheda: 14 pin digitali di ingresso/uscita (0–13), di cui 6 possono generare PWM (~3, 5, 6, 9, 10, 11), 6 ingressi analogici (A0–A5) e i pin di alimentazione che alimentano la scheda o forniscono energia ad altri componenti (Vin, 5V, 3.3V, GND, IOREF, AREF, RESET). Ogni pin ha una funzione principale, ma molti ne hanno anche una seconda: A4 e A5 sono anche il bus I2C, i pin 10–13 formano il bus SPI, il 2 e il 3 sono pin di interrupt e lo 0 e l'1 sono la linea seriale che parla con il tuo computer.

Scegliere il pin giusto fa la differenza tra un progetto che funziona al primo colpo e ore passate a cercare errori. Con le tabelle di questo articolo capirai facilmente perché il PWM sui pin 9 e 10 smette di funzionare quando colleghi un servo, perché lo sketch non si carica mentre è collegato un modulo Bluetooth o perché qualche LED può sovraccaricare la scheda. Alla fine troverai anche uno sketch di prova che usa tutti i tipi di pin insieme, un esempio di piano dei pin e le differenze di pin tra Uno R3 e R4.

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

Metti la scheda davanti a te con la presa USB e il jack di alimentazione a sinistra. I due connettori del lato superiore ospitano i pin digitali; i numeri crescono da destra verso sinistra, quindi il pin più a destra è lo 0 (RX) e il pin digitale più a sinistra è il 13. Sul lato inferiore, il connettore di sinistra porta i pin di alimentazione e quello di destra gli ingressi analogici. La ~ (tilde) accanto a un numero indica che quel pin può generare PWM. Il gruppo di 2×3 pin maschio sul lato destro della scheda è il connettore ICSP.

La grande tabella dei pin: D0–D13 e A0–A5

Come funzionano i pin digitali (0–13)?

Ogni pin digitale si imposta come ingresso o uscita con pinMode(). Come uscita, digitalWrite(pin, HIGH) porta il pin a circa 5 V e LOW a 0 V. Come ingresso, digitalRead() confronta la tensione con una soglia: con l'ATmega328P alimentato a 5 V, tutto ciò che supera 3,0 V è sicuramente HIGH, tutto ciò che sta sotto 1,5 V è sicuramente LOW, e in mezzo c'è una zona indefinita. Per questo l'uscita di un sensore a 3,3 V di solito viene letta come HIGH da Arduino Uno; l'uscita a 5 V di Arduino Uno però non deve andare direttamente all'ingresso di un modulo a 3,3 V, in mezzo serve un convertitore di livello logico.

Un pin di ingresso non collegato a nulla resta flottante e legge HIGH e LOW a caso, anche solo avvicinando la mano. La soluzione è portare il pin a un livello fisso con una resistenza: pinMode(pin, INPUT_PULLUP) attiva la resistenza da 20–50 kΩ interna al chip e il pulsante va collegato tra il pin e GND. Trovi i dettagli in Come collegare un pulsante ad Arduino. Al pin 13 è collegato il LED L della scheda; sulla R3 originale questo LED è pilotato tramite un amplificatore operazionale usato come buffer, quindi usare il pin come ingresso non crea problemi, ma su alcuni cloni il LED e la sua resistenza sono collegati direttamente al pin e possono disturbare la lettura di un pulsante con il pull-up interno.

Pin PWM (~3, 5, 6, 9, 10, 11) e timer

Arduino Uno non può generare una vera uscita analogica; al suo posto questi sei pin forniscono il PWM, un'onda quadra che si accende e si spegne molto velocemente. Con analogWrite(pin, valore) regoli da 0 a 255 per quanto tempo l'onda resta accesa: 0 è sempre spento, 127 circa metà e 255 sempre acceso. Così si controllano la luminosità di un LED, la velocità di un motore e quella di una ventola. I sei pin PWM sono collegati a coppie a tre timer hardware, ed è questa la causa dei conflitti con alcune librerie. Il principio del PWM e il calcolo del duty cycle sono spiegati in Cos'è il PWM?.

Pin analogici (A0–A5) e AREF

I pin analogici misurano una tensione tra 0 e 5 V con una risoluzione di 10 bit, e analogRead() restituisce un numero da 0 a 1023. Un passo vale circa 4,9 mV; per convertire il numero in volt usa tensione = valore × 5,0 / 1023, quindi una lettura di 512 significa circa 2,5 V. I sei pin condividono a turno un unico ADC e una lettura dura circa 100 µs, cioè circa 10.000 letture al secondo. Per misure precise l'impedenza di uscita del sensore non dovrebbe superare 10 kΩ; se è più alta, leggendo due pin uno dopo l'altro i valori possono mescolarsi, e scartare la prima lettura per usare la seconda risolve il problema. Per misurare tensioni sopra i 5 V scegli le resistenze giuste con il calcolatore del partitore di tensione.

Il pin AREF serve a cambiare il limite superiore della misura analogica. analogReference(DEFAULT) usa 5 V, analogReference(INTERNAL) il riferimento interno da 1,1 V del chip e analogReference(EXTERNAL) la tensione che applichi al pin AREF (0–5 V) come fondo scala. Con un sensore che dà 0–1 V, il riferimento da 1,1 V riduce un passo a circa 1,1 mV e rende la misura circa 4,5 volte più fine. Potenziometri, LDR e sensori di umidità del terreno si collegano a questi pin; i dettagli della conversione analogico-digitale sono nell'articolo sull'ADC e un esempio pratico nell'articolo sul potenziometro.

Pin di alimentazione: Vin, 5V, 3.3V, GND, IOREF e RESET

Arduino Uno si può alimentare in tre modi. Tramite USB la scheda prende i 5 V direttamente dal computer e un fusibile ripristinabile da 500 mA protegge la porta. Se fornisci 7–12 V dal jack DC o da Vin, il regolatore della scheda li abbassa a 5 V; se sono collegati entrambi, la scheda passa da sola all'alimentazione esterna quando Vin supera circa 6,6 V. Dato che il regolatore trasforma in calore la tensione in eccesso, con 12 V in ingresso si scalda in fretta se prelevi qualche centinaio di mA dal pin 5V. La soluzione più sana è alimentare carichi come servo, motori e strisce LED con una fonte separata e unire solo i GND. Per scegliere la batteria e calcolare l'autonomia usa il calcolatore di durata della batteria, e leggi tutti i modi di alimentazione in Come alimentare Arduino.

Perché i pin 0 e 1 vanno lasciati liberi?

I pin 0 (RX) e 1 (TX) sono l'unica porta seriale hardware dell'ATmega328P e sulla scheda sono collegati tramite resistenze da 1 kΩ al chip convertitore USB-seriale (ATmega16U2). Il computer usa questi due pin quando carica il codice e quando invii testo al Monitor seriale. Se al pin 0 è collegato il TX di un modulo Bluetooth o un altro segnale, le due sorgenti si contendono la stessa linea e il caricamento si ferma con avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00. Inoltre il pin 1 cambia stato rapidamente a ogni Serial.print(), quindi un LED o un relè collegato lì si attiva a caso.

Per questo lascia liberi lo 0 e l'1 finché hai altri pin disponibili. Se devi collegare un modulo seriale come un HC-05, un GPS o un lettore MP3, la libreria SoftwareSerial crea una seconda porta seriale su altri due pin. Lo sketch seguente collega il modulo ai pin 8 (RX) e 7 (TX): inoltra al modulo ciò che scrivi nel Monitor seriale e al computer ciò che arriva dal modulo. Con moduli a logica 3,3 V come l'HC-05, collega l'uscita TX di Arduino Uno (pin 7) all'ingresso RX del modulo tramite un partitore di tensione. Tutte le soluzioni ai problemi di caricamento sono in Arduino non carica lo sketch, e il funzionamento della comunicazione seriale in Comunicazione seriale 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}

Pin di comunicazione: I2C (A4/A5), SPI (10–13) e pin di interrupt (2, 3)

L'I2C ti permette di collegare decine di dispositivi allo stesso bus con soli due fili (SDA e SCL); display LCD, OLED, moduli orologio RTC e sensori come il BME280 lo usano. Su Arduino Uno SDA = A4 e SCL = A5. Sulle schede R3 i pin SDA e SCL accanto ad AREF non sono un bus separato: sono collegati internamente ad A4 e A5, quindi mentre usi l'I2C non puoi usare A4 e A5 per letture analogiche. La libreria Wire lavora di default a 100 kHz e arriva a 400 kHz con Wire.setClock(400000). Indirizzi, resistenze di pull-up e uno scanner I2C sono in Cos'è l'I2C?, un esempio pratico in Display LCD I2C.

L'SPI è più veloce ma richiede più fili: MOSI = 11, MISO = 12, SCK = 13 e SS (CS) = 10. Moduli per schede SD, lettori RFID e display TFT usano l'SPI. Più dispositivi possono condividere il bus: MOSI, MISO e SCK sono in comune e ogni dispositivo riceve il proprio pin CS. Un dettaglio importante: in modalità master il pin 10 deve restare un'uscita; se lo imposti come ingresso e viene portato a LOW, l'ATmega328P passa in modalità slave e l'SPI si ferma. MISO, MOSI e SCK sono presenti anche sul connettore ICSP, da cui alcuni shield prendono l'SPI. Per i dettagli leggi Cos'è l'SPI? e RFID RC522.

Un interrupt ti permette di cogliere all'istante un cambiamento su un pin, qualunque cosa stia facendo loop() in quel momento. Su Arduino Uno gli interrupt esterni ci sono solo sui pin 2 (INT0) e 3 (INT1): scrivi attachInterrupt(digitalPinToInterrupt(2), funzione, FALLING), e la modalità di attivazione può essere LOW, CHANGE, RISING o FALLING. Encoder, sensori di giri, flussimetri e pulsanti che non devono mai sfuggire vanno su questi pin. Anche gli altri pin hanno gli "interrupt di cambio stato" (PCINT), ma i pin della stessa porta condividono un'unica funzione di interrupt e il tuo codice deve capire quale pin è cambiato. Regole ed esempi sono in Interrupt su Arduino.

Passando all'ESP32 o al Pico, la differenza più grande è la tensione: entrambe le schede lavorano a 3,3 V e i loro pin non tollerano i 5 V, quindi i moduli a 5 V che colleghi direttamente ad Arduino Uno possono richiedere un convertitore di livello. In compenso queste schede hanno interrupt e PWM su quasi tutti i pin, e i bus I2C e SPI si possono spostare su altri pin. Per confrontare le schede leggi Arduino Uno o ESP32?, per vedere le mappe dei pin usa lo strumento pinout; le schede vere e proprie sono presentate in Cos'è l'ESP32? e Cos'è il Raspberry Pi Pico?.

A cosa serve il connettore ICSP?

ICSP (In-Circuit Serial Programming) è un connettore 2×3 che serve a programmare il microcontrollore direttamente attraverso le linee SPI, senza USB né bootloader. L'ICSP sul lato destro appartiene all'ATmega328P, mentre il piccolo ICSP1 accanto alla presa USB appartiene al chip USB-seriale (ATmega16U2). Nell'uso quotidiano non lo tocchi, ma l'ICSP entra in gioco quando il bootloader si corrompe, quando scrivi il bootloader su un ATmega328P nuovo o quando carichi il codice con un programmatore come l'USBasp. Se trasformi un secondo Arduino Uno in programmatore con l'esempio ArduinoISP, i suoi pin 10, 11, 12 e 13 vanno a RESET, MOSI, MISO e SCK della scheda di destinazione, e un condensatore da 10 µF tra RESET e GND sull'Uno programmatore ne impedisce il reset automatico. Per capire se la tua scheda si è danneggiata, dai un'occhiata a Arduino bruciato?.

20 mA per pin, 200 mA in totale: i limiti di corrente

Un pin di Arduino Uno lavora in sicurezza fino a 20 mA. I 40 mA del datasheet dell'ATmega328P sono il massimo assoluto, cioè il valore oltre il quale il chip può danneggiarsi in modo permanente, non un valore di lavoro. La corrente totale che passa dai pin VCC e GND del chip non deve superare i 200 mA. Il datasheet divide inoltre i pin in gruppi: quando erogano corrente (HIGH), D0–D4 insieme ad A0–A5, e D5–D13 tra loro, devono restare ciascuno sotto i 150 mA; quando assorbono corrente (LOW), i gruppi D0–D4, D5–D13 e A0–A5 devono restare ciascuno sotto i 100 mA. Se alimenti un LED rosso a 5 V con una resistenza da 220 Ω, la corrente è (5 − 2) / 220 ≈ 13,6 mA. Dieci LED accesi insieme fanno 136 mA; è sotto i 200 mA, ma se stanno tutti nello stesso gruppo si arriva molto vicino al limite di 150 mA del gruppo. Se i LED si accendono con il pin a LOW (resistenza dal 5V al pin) e la maggior parte sta nello stesso gruppo, il limite di 100 mA viene superato. Distribuisci i LED tra i gruppi o aumenta la resistenza a 330–470 Ω. Trova la resistenza giusta con il calcolatore della resistenza per LED o il calcolatore della legge di Ohm.

• Motori: Anche un piccolo motore DC assorbe centinaia di mA e produce picchi di tensione; usa un driver per motori come l'L298N o un transistor.
• Bobina del relè: La bobina di un relè a 5 V assorbe circa 70–90 mA; usa un modulo relè con transistor e diodo.
• Servomotori: Il filo del segnale può andare a un pin, ma l'alimentazione del servo deve arrivare da una fonte separata, non dal pin 5V; i dettagli sono nell'articolo sul servomotore.
• Strisce LED e LED di potenza: Le strisce a 12 V e i LED da 1 W richiedono un MOSFET a livello logico.
• Cortocircuiti: Collegare direttamente a GND un'uscita a livello HIGH preleva dal pin molto più di 40 mA e lo danneggia per sempre.

Sketch di prova: pin digitali, PWM, analogici e di interrupt insieme

1. Collega un LED al pin 9 con una resistenza da 220 Ω: la gamba lunga verso la resistenza, quella corta a GND.
2. Collega i due piedini esterni di un potenziometro a 5V e GND e quello centrale ad A0.
3. Collega un pulsante tra il pin 2 e GND; non serve una resistenza a parte perché si usa il pull-up interno.
4. Carica lo sketch, apri il Monitor seriale e imposta 9600 baud.
5. Gira il potenziometro: la luminosità del LED sul pin 9 cambia, il LED L della scheda (pin 13) si accende quando la tensione supera 2,5 V e il contatore aumenta di uno a ogni pressione del pulsante.

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}

Lo sketch usa contemporaneamente quattro tipi di pin di Arduino Uno. analogRead(A0) legge un valore da 0 a 1023 e raw / 4 lo riduce all'intervallo 0–255 che analogWrite() si aspetta. Per non contare i rimbalzi del pulsante, la funzione di interrupt ignora i segnali che arrivano meno di 50 ms dopo l'ultima pressione. Il contatore modificato nell'interrupt è dichiarato volatile e loop() lo copia sospendendo per un attimo gli interrupt: Arduino Uno, a 8 bit, legge un numero a 16 bit in due passaggi e un interrupt che arriva nel mezzo potrebbe dare un valore sbagliato. I pin 0 e 1 servono solo a Serial, quindi non vi si collega nient'altro.

Esempio di piano dei pin: quale componente su quale pin?

Distribuire i pin a caso in un progetto con molti componenti porta a conflitti. Prima metti sui loro pin i componenti con funzioni speciali (I2C, SPI, interrupt, PWM), poi distribuisci i compiti digitali semplici sui pin liberi. Qui sotto trovi un piano di esempio per una serratura con tessera RFID: lettore RC522, LCD I2C, servo, buzzer, pulsante e due LED. Poiché servo e tone() sono usati insieme, il PWM sui pin 3, 9, 10 e 11 è già fuori gioco, e il piano ne tiene conto.

Differenze di pin tra Arduino Uno R3 e R4

In breve, sulla R4 i numeri e le funzioni dei pin restano gli stessi (PWM ~3, 5, 6, 9, 10, 11; I2C A4/A5; SPI 10–13; interrupt 2, 3), ma la corrente per pin scende a 8 mA. Un LED che sulla R3 pilotavi direttamente da un pin, sulla R4 richiede una resistenza più grande (per esempio 1 kΩ per circa 3 mA) o un transistor. Il confronto dettagliato è in Arduino Uno R4. Se cerchi una scheda più piccola, ti saranno utili Pinout di Arduino Nano e Quale Arduino comprare?.

Errori comuni e soluzioni

Quando conosci i pin di Arduino Uno non devi più ricordare a memoria dove va ogni componente: guardi di cosa ha bisogno e scegli tu il pin giusto. Se vuoi ripassare le basi, parti da Cos'è Arduino?. Nell'app BlueGrays trovi progetti come accendere un LED, leggere un pulsante, misurare la luce con una LDR, un LED RGB in PWM, un LCD I2C, l'RFID e due Arduino che comunicano su una linea seriale, ognuno passo dopo passo con schemi che mostrano perché è stato scelto ogni pin e con il codice pronto.