Pinout Arduino Mega 2560: PWM, Seriali, Interrupt e I2C
Pinout Arduino Mega in una guida: 54 pin digitali, 16 analogici, 15 PWM, 4 seriali hardware e 6 interrupt. Confronto con Uno, codici e esempio RAMPS.
Il pinout dell'Arduino Mega offre la maggiore connettività della famiglia Arduino: la scheda Mega 2560 ha 54 I/O digitali, 16 ingressi analogici, 15 uscite PWM, 4 porte seriali hardware e 6 pin per interrupt esterni. Quando i pin della Uno non bastano, quando devi far parlare più dispositivi seriali (GPS, Bluetooth, GSM) o quando la memoria del programma si esaurisce, la Mega è la prima scheda a cui pensare. Usa lo stesso linguaggio Arduino, lo stesso IDE e la maggior parte delle librerie della Uno: cresci senza imparare nulla di nuovo.
In questa guida esaminiamo la mappa dei pin gruppo per gruppo: quali pin danno il PWM, dove si trovano le porte seriali, dove funzionano gli interrupt e perché I2C e SPI sono in posizioni diverse rispetto alla Uno. Poi passiamo alla tabella di confronto con la Uno, a quando la Mega serve davvero, al motivo per cui è lo standard nelle stampanti 3D e a come pianificare i pin in un progetto con molti sensori.

Cos'è l'Arduino Mega 2560 e come funziona?
L'Arduino Mega 2560 è una scheda di sviluppo basata sul microcontrollore AVR a 8 bit ATmega2560. Lavora alla stessa frequenza di 16 MHz della Uno, usa la stessa logica a 5 V e si programma con lo stesso IDE: la Mega non è più veloce della Uno, è più ampia. Grazie al package a 100 pin, sulla scheda sono disponibili 70 pin di segnale. La connessione USB è gestita dal chip ATmega16U2; nei cloni spesso se ne occupa un CH340. Puoi alimentare la scheda a 5 V via USB oppure a 7–12 V da jack e Vin; il regolatore interno porta la tensione a 5 V. La memoria programma è 8 volte quella della Uno e la RAM 4 volte: librerie grandi, display grafici e menu lunghi girano senza problemi. La metà sinistra della scheda ha lo stesso pinout della Uno, quindi la maggior parte degli shield per Uno si monta direttamente sulla Mega.
| Caratteristica | Valore |
|---|---|
| Microcontrollore | ATmega2560 (AVR a 8 bit) |
| Frequenza di clock | 16 MHz |
| Memoria flash | 256 KB (8 KB per il bootloader) |
| SRAM | 8 KB |
| EEPROM | 4 KB |
| Tensione di lavoro | 5 V |
| Tensione di ingresso (jack / Vin) | 7–12 V consigliati, limite 6–20 V |
| I/O digitali | 54 (15 con PWM) |
| Ingressi analogici | 16 (A0–A15, 10 bit) |
| Porte seriali hardware | 4 (Serial, Serial1, Serial2, Serial3) |
| Pin per interrupt esterni | 6 |
| Corrente per pin | 20 mA consigliati, 40 mA limite assoluto |
| Corrente del pin 3.3V | Massimo 50 mA |
| Dimensioni | 101,5 × 53,3 mm |
Confronto tra Arduino Mega e Uno
| Caratteristica | Arduino Uno R3 | Arduino Mega 2560 |
|---|---|---|
| Microcontrollore | ATmega328P | ATmega2560 |
| Frequenza di clock | 16 MHz | 16 MHz |
| Pin digitali | 14 | 54 |
| Pin PWM | 6 (3, 5, 6, 9, 10, 11) | 15 (2–13, 44, 45, 46) |
| Ingressi analogici | 6 (A0–A5) | 16 (A0–A15) |
| Porte seriali hardware | 1 | 4 |
| Pin per interrupt esterni | 2 (2, 3) | 6 (2, 3, 18, 19, 20, 21) |
| Flash / SRAM / EEPROM | 32 KB / 2 KB / 1 KB | 256 KB / 8 KB / 4 KB |
| Pin I2C | A4 (SDA), A5 (SCL) | 20 (SDA), 21 (SCL) |
| Pin SPI | 10, 11, 12, 13 | 53, 51, 50, 52 |
| Dimensioni | 68,6 × 53,4 mm | 101,5 × 53,3 mm |
Mappa dei pin dell'Arduino Mega: tutti i gruppi
| Gruppo di pin | Numeri dei pin | Funzione e note |
|---|---|---|
| Pin digitali in comune con la Uno | 0–13 | 0 (RX0) e 1 (TX0) sono la linea seriale USB; sul 13 c'è il LED integrato |
| Pin delle seriali aggiuntive | 14–19 | 14 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1 |
| I2C | 20 (SDA), 21 (SCL) | Libreria Wire; sulla scheda ci sono resistenze di pull-up da 10 kΩ a 5 V |
| Connettore digitale a doppia fila | 22–53 | I/O generici; non c'è PWM tranne su 44, 45 e 46 |
| PWM | 2–13, 44, 45, 46 | Si usa con analogWrite(pin, 0–255) |
| SPI | 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS) | Gli stessi segnali sono presenti anche sul connettore ICSP |
| Ingressi analogici | A0–A15 (digitali 54–69) | Si leggono con analogRead, si possono usare anche come pin digitali |
| Alimentazione e controllo | 5V, 3.3V, Vin, GND, IOREF, AREF, RESET | AREF è l'ingresso di riferimento analogico esterno; con RESET a LOW la scheda si riavvia |
Pin PWM e timer
La Mega ha 15 uscite PWM: i 12 pin da 2 a 13 più 44, 45 e 46. Con analogWrite(pin, 0–255) regoli la luminosità dei LED e la velocità dei motori. I segnali PWM sono generati da sei timer hardware (Timer0–Timer5); Timer0 e Timer2 sono a 8 bit, gli altri a 16 bit. Poiché Timer0 gestisce anche millis() e delay(), i pin 4 e 13 lavorano a circa 980 Hz e gli altri pin PWM a circa 490 Hz. Il punto a cui prestare attenzione è che quando una libreria si prende un timer, il PWM sui pin collegati a quel timer si rovina: la libreria Servo sulla Mega usa Timer5 per i primi 12 servo, quindi appena colleghi un servo analogWrite non funziona più su 44, 45 e 46; tone() usa invece Timer2 e influenza i pin 9 e 10. Trovi i concetti di duty cycle e frequenza in Cos'è il PWM?.
| Timer | Pin PWM | Frequenza predefinita | Con cosa va in conflitto? |
|---|---|---|---|
| Timer0 (8 bit) | 4, 13 | ~980 Hz | millis() e delay() |
| Timer1 (16 bit) | 11, 12 | ~490 Hz | Libreria Servo (servo 13–24) |
| Timer2 (8 bit) | 9, 10 | ~490 Hz | Funzione tone() |
| Timer3 (16 bit) | 2, 3, 5 | ~490 Hz | Libreria Servo (servo 25–36) |
| Timer4 (16 bit) | 6, 7, 8 | ~490 Hz | Libreria Servo (servo 37–48) |
| Timer5 (16 bit) | 44, 45, 46 | ~490 Hz | Libreria Servo (primi 12 servo) |
4 porte seriali hardware: Serial, Serial1, Serial2, Serial3
La Uno ha una sola porta seriale hardware, condivisa con l'USB; per un secondo dispositivo sei costretto a usare SoftwareSerial. SoftwareSerial può perdere dati a velocità alte, ascolta una sola porta alla volta e, disattivando gli interrupt mentre riceve un byte, rallenta il resto del codice. Sulla Mega ci sono invece quattro UART indipendenti, ciascuno con un buffer di ricezione da 64 byte che lavora in background: mentre fai altro in loop(), i dati in arrivo non si perdono. La regola di collegamento è la stessa per ogni porta: il TX del modulo va all'RX della Mega, l'RX del modulo al TX della Mega e le masse devono essere in comune. Se un modulo lavora a 3,3 V, abbassa il segnale a circa 3,3 V con un partitore di tensione da 1 kΩ e 2 kΩ sul suo ingresso RX. Il codice bridge qui sotto inoltra al Serial1 ciò che scrivi nel Monitor Seriale e viceversa: è il modo più rapido per provare moduli come l'HC-05. Per il funzionamento dell'UART vedi comunicazione seriale UART.
| Porta | Pin TX | Pin RX | Uso tipico |
|---|---|---|---|
| Serial | 1 | 0 | USB e Monitor Seriale |
| Serial1 | 18 | 19 | Modulo Bluetooth HC-05 |
| Serial2 | 16 | 17 | Modulo GPS NEO-6M |
| Serial3 | 14 | 15 | SIM800L GSM o sensore di impronte |
1// USB Seri Monitör <-> Serial1 köprüsü / USB Serial Monitor <-> Serial1 bridge
2// Serial1: TX1 = 18, RX1 = 19
3
4void setup() {
5 Serial.begin(9600); // bilgisayar (USB) / computer (USB)
6 Serial1.begin(9600); // HC-05, GPS vb. / HC-05, GPS, etc.
7 Serial.println(F("Mega seri kopru hazir / serial bridge ready"));
8}
9
10void loop() {
11 if (Serial1.available()) { // modülden gelen veri / data from the module
12 Serial.write(Serial1.read());
13 }
14 if (Serial.available()) { // Seri Monitör'den gelen veri / data from the Serial Monitor
15 Serial1.write(Serial.read());
16 }
17}Pin per interrupt
Un interrupt esterno ti permette di catturare in pochi microsecondi un cambiamento su un pin, qualunque cosa stia facendo loop(); è ideale per encoder, sensori di flusso dell'acqua, contagiri e pulsanti che richiedono una reazione rapida. Sulla Mega i pin utilizzabili con attachInterrupt sono 6: 2, 3, 18, 19, 20 e 21. I numeri degli interrupt non seguono l'ordine dei pin (2 → 0, 3 → 1, 21 → 2, 20 → 3, 19 → 4, 18 → 5); perciò usa sempre digitalPinToInterrupt(pin) invece di scrivere il numero a mano. Attenzione: 18 e 19 sono i pin di Serial1 e 20 e 21 quelli dell'I2C; se usi Serial1 e I2C ti restano solo 2 e 3. Se ti servono più pin, gli interrupt di cambio pin (PCINT) dell'ATmega2560 funzionano sui pin 10–15, 50–53 e A8–A15 e si usano con le librerie adatte. Il codice qui sotto conta gli impulsi sui pin 2 e 18: le funzioni di interrupt sono brevi, i contatori condivisi sono dichiarati volatile e durante la lettura gli interrupt sono sospesi per un istante. In questo esempio il 18 è usato per l'interrupt, quindi Serial1 non è disponibile. Per approfondire leggi l'articolo Arduino interrupt.
1// Arduino Mega: 2 ve 18 numaralı pinlerde darbe sayma / pulse counting on pins 2 and 18
2volatile unsigned long countA = 0; // pin 2
3volatile unsigned long countB = 0; // pin 18
4
5void onPulseA() { countA++; } // kısa tut / keep it short
6void onPulseB() { countB++; }
7
8void setup() {
9 Serial.begin(115200);
10 pinMode(2, INPUT_PULLUP); // buton ya da sensör GND'ye çeker / button or sensor pulls to GND
11 pinMode(18, INPUT_PULLUP);
12 attachInterrupt(digitalPinToInterrupt(2), onPulseA, FALLING);
13 attachInterrupt(digitalPinToInterrupt(18), onPulseB, FALLING);
14}
15
16void loop() {
17 noInterrupts(); // okurken kesmeleri durdur / pause interrupts while reading
18 unsigned long a = countA;
19 unsigned long b = countB;
20 interrupts();
21
22 Serial.print(F("Pin 2: "));
23 Serial.print(a);
24 Serial.print(F(" Pin 18: "));
25 Serial.println(b);
26 delay(500);
27}16 ingressi analogici (A0–A15)
I 16 ingressi analogici della Mega condividono un unico ADC a 10 bit tramite un multiplexer. Ogni lettura restituisce un valore tra 0 e 1023; con riferimento a 5 V un passo corrisponde a circa 4,9 mV. Una conversione dura circa 100 microsecondi, quindi puoi fare circa 10.000 letture al secondo: scansionare i 16 canali in sequenza non è un problema. Per misure più precise puoi scegliere con analogReference il riferimento interno da 1,1 V (INTERNAL1V1) o da 2,56 V (INTERNAL2V56); l'opzione INTERNAL della Uno sulla Mega non esiste. I pin analogici si possono usare anche come digitali: A0 è il pin digitale 54 e A15 il 69, quindi con pinMode(A8, OUTPUT) puoi accendere un LED. Passando velocemente da un canale all'altro, la tensione del canale precedente può influenzare la misura successiva; con sorgenti con impedenza interna superiore a 10 kΩ, leggere ogni canale due volte e scartare la prima lettura riduce l'errore. Il funzionamento dell'ADC è spiegato in conversione analogico-digitale.
1// 16 analog kanalı sırayla oku / read all 16 analog channels in turn
2void setup() {
3 Serial.begin(115200);
4}
5
6void loop() {
7 for (byte ch = 0; ch < 16; ch++) {
8 int raw = analogRead(A0 + ch); // A0..A15 = 54..69
9 float volts = raw * (5.0 / 1023.0); // ham değeri volta çevir / convert raw value to volts
10 Serial.print(F("A"));
11 Serial.print(ch);
12 Serial.print(F("="));
13 Serial.print(volts, 2);
14 if (ch < 15) {
15 Serial.print(F(" "));
16 }
17 }
18 Serial.println(); // satır sonu / end of line
19 delay(1000);
20}Pin I2C e SPI: compatibilità con gli shield della Uno
La differenza che mette più in difficoltà chi passa alla Mega è la posizione dei pin di comunicazione. Sulla Uno l'I2C è su A4 e A5 e l'SPI sui pin 10–13; sulla Mega l'I2C è su 20 (SDA) e 21 (SCL) e l'SPI sui pin 50–53. Sulle schede R3, SDA e SCL sono ripetuti anche sul connettore accanto ad AREF; i segnali SPI sono invece nella stessa posizione su entrambe le schede, sul connettore ICSP a 6 pin centrale. Per questo gli shield che prendono l'SPI dall'ICSP funzionano senza problemi sulla Mega, mentre i vecchi shield che lo prendono direttamente dai pin 11–13 non funzionano. Le librerie Wire e SPI usano da sole i pin giusti: a te basta collegare bene i cavi. In SPI puoi collegare il pin CS del dispositivo a qualsiasi pin digitale, ma non usare mai il 53 come ingresso: se il pin è un ingresso e viene portato a LOW, il processore passa in modalità slave sull'SPI e la comunicazione si ferma. Per esempio, un lettore RFID RC522 si collega con SDA → 53, SCK → 52, MOSI → 51, MISO → 50. Per i dettagli dei protocolli vedi Cos'è l'I2C? e Cos'è l'SPI?.
| Segnale | Arduino Uno | Arduino Mega | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|
| I2C SDA | A4 | 20 | GPIO 21 | GP4 |
| I2C SCL | A5 | 21 | GPIO 22 | GP5 |
| SPI MISO | 12 | 50 | GPIO 19 | GP16 |
| SPI MOSI | 11 | 51 | GPIO 23 | GP19 |
| SPI SCK | 13 | 52 | GPIO 18 | GP18 |
| SPI SS / CS | 10 | 53 | GPIO 5 | GP17 |
| Seriale aggiuntiva TX / RX | Nessuna (SoftwareSerial) | 18 / 19 (Serial1) | GPIO 17 / 16 (Serial2) | GP0 / GP1 (UART0) |
| Livello logico | 5 V | 5 V | 3,3 V | 3,3 V |
Passo dopo passo: il primo programma con la Mega (luce scorrevole con 16 LED)
- Collega la Mega al computer con un cavo USB-B; se il chip USB della scheda clone è un CH340, installa prima il driver.
- Nell'IDE Arduino scegli dal menu Strumenti > Scheda la voce Arduino Mega or Mega 2560 e lascia come processore ATmega2560 (Mega 2560).
- Dal menu Strumenti > Porta scegli la porta della scheda (su Windows qualcosa come COM3, su macOS un nome che inizia con /dev/cu.usbmodem o /dev/cu.wchusbserial).
- Collega 16 LED ai pin 22–37, ciascuno con una resistenza da 220 Ω, e porta i catodi (gambe corte) alla linea GND. Con un LED rosso scorrono (5 − 2) / 220 ≈ 13,6 mA; per altri colori usa il calcolatore della resistenza per LED.
- Carica il codice qui sotto; i LED si accendono uno dopo l'altro. Poiché è acceso un solo LED alla volta, la corrente totale resta sotto i 20 mA. L'effetto avanti-indietro lo trovi in Knight Rider e luce scorrevole.
1// Arduino Mega: 22-37 pinlerinde 16 LED'li yürüyen ışık / 16-LED chaser on pins 22-37
2const byte FIRST_PIN = 22; // ilk LED pini / first LED pin
3const byte LED_COUNT = 16; // 22..37
4
5void setup() {
6 for (byte i = 0; i < LED_COUNT; i++) {
7 pinMode(FIRST_PIN + i, OUTPUT); // tüm LED pinleri çıkış / all LED pins as outputs
8 }
9}
10
11void loop() {
12 for (byte i = 0; i < LED_COUNT; i++) {
13 digitalWrite(FIRST_PIN + i, HIGH); // LED'i yak / turn LED on
14 delay(60);
15 digitalWrite(FIRST_PIN + i, LOW); // LED'i söndür / turn LED off
16 }
17}Quando serve l'Arduino Mega?
- Se i pin non bastano: un keypad 4x4 da solo richiede 8 pin e un LCD parallelo 6; aggiungendo relè, pulsanti e sensori, i 20 pin della Uno finiscono in fretta.
- Se hai più dispositivi seriali: ascoltare insieme GPS, Bluetooth e GSM sulla Uno è quasi impossibile; sulla Mega ognuno ha la propria porta hardware.
- Se la memoria si esaurisce: se il compilatore avvisa che la memoria è scarsa o se usi insieme display TFT, scheda SD e codice dei menu, 256 KB di flash e 8 KB di RAM sono un grande sollievo; i dettagli sono in Arduino memoria insufficiente.
- Se hai molti sensori analogici: con 16 canali leggi umidità del terreno, gas, luce e potenziometri senza bisogno di un multiplexer.
- Nei robot con molti servo: la libreria Servo sulla Mega supporta fino a 48 servo (12 sulla Uno); è adatta a bracci robotici e robot camminatori.
- Quando la Mega non serve: se ti servono Wi-Fi, alta velocità o basso consumo, l'ESP32 è più sensato (Arduino o ESP32?); se mancano solo alcune uscite, moltiplicare i pin della Uno con uno shift register 74HC595 è una soluzione più economica e piccola.
Arduino Mega e RAMPS 1.4 nelle stampanti 3D
Per anni la maggior parte delle stampanti 3D fai da te e delle piccole CNC ha funzionato con un Arduino Mega e la scheda RAMPS 1.4 montata sopra; ancora oggi questa coppia è l'elettronica didattica più diffusa per le stampanti. Il motivo è semplice: un firmware come Marlin, con display e supporto SD, supera facilmente i 100 KB; servono cinque driver per motori passo-passo (X, Y, Z e due estrusori), tre uscite MOSFET, sei finecorsa, termistori, e decine di pin per LCD e scheda SD. Su RAMPS i segnali step e direzione dell'asse X sono collegati ai pin 54 e 55 (A0 e A1), quelli dell'asse Y a 60 e 61 (A6 e A7), quelli dell'asse Z a 46 e 48 e quelli del primo estrusore a 26 e 28. Il riscaldatore dell'ugello è pilotato dal pin PWM 10, il piatto riscaldato dall'8 e la ventola dal 9; i termistori di ugello e piatto si leggono su A13 e A14. Questa disposizione è anche un bell'esempio di come i pin analogici si possano usare in modo efficiente come uscite digitali. Per la corrente dei driver e la scelta dei micropassi, dai un'occhiata a driver per motori passo-passo A4988.
Esempio di progetto con molti sensori: pianificare bene i pin
| Modulo | Pin Mega | Perché questo pin? |
|---|---|---|
| Bluetooth HC-05 | 18 (TX1), 19 (RX1) | La comunicazione con il telefono avviene su una seriale hardware, i dati non si perdono |
| GPS NEO-6M | 16 (TX2), 17 (RX2) | Il GPS invia molte righe ogni secondo e vuole una porta dedicata |
| GSM SIM800L | 14 (TX3), 15 (RX3) | Terza porta indipendente per SMS e chiamate |
| LCD I2C + BME280 | 20 (SDA), 21 (SCL) | I due dispositivi condividono la stessa linea I2C con indirizzi diversi |
| RFID RC522 | 50, 51, 52, 53 + RST 49 | Linea SPI hardware, come CS si usa il 53 |
| Sensore di umidità del terreno (4) | A0–A3 | I primi quattro dei 16 canali analogici |
| Sensore di gas MQ-2 | A4 | Sensore con uscita analogica |
| Sensore di flusso dell'acqua | 2 | Pin di interrupt esterno per non perdere gli impulsi |
| Modulo relè a 8 canali | 22–29 | Semplici uscite digitali, senza bisogno di PWM |
| Ventola (con MOSFET) | 6 | PWM per il controllo della velocità (Timer4) |
| Servo (sportello) | 8 | Il segnale del servo può uscire da qualsiasi pin digitale; poiché usa Timer5, 44–46 non vanno riservati al PWM |
Errori comuni e come risolverli
| Sintomo | Causa | Soluzione |
|---|---|---|
| Il codice non si carica, errore di timeout di avrdude | È rimasta selezionata la Uno, la porta è sbagliata o c'è un modulo sui pin 0 e 1 | Scegli Mega 2560 e la porta giusta dal menu Strumenti, scollega i cavi su 0 e 1 durante il caricamento |
| Display o sensore I2C non trovato | I cavi sono stati collegati ad A4 e A5 per abitudine con la Uno | Collega SDA al 20 e SCL al 21 |
| Il modulo SPI sullo shield non funziona | Lo shield prende i segnali SPI dai pin 11–13 | Usa il connettore ICSP o i pin 50–52 |
| Dopo aver aggiunto un servo, analogWrite su 44–46 si è fermato | La libreria Servo usa Timer5 | Sposta l'uscita PWM su un pin tra 2 e 13 |
| SoftwareSerial non riceve dati | Il pin RX scelto non supporta gli interrupt di cambio pin | Usa le porte hardware Serial1, Serial2 o Serial3 |
| La scheda si scalda o si resetta da sola | Motore, bobina di relè o molti LED pilotati direttamente dal pin | Usa un transistor, un MOSFET o un driver motore e aggiungi un'alimentazione esterna |
| I valori analogici oscillano di continuo | Lettura di un ingresso flottante o dispersione tra i canali | Leggi solo i canali con un sensore collegato, leggi ogni canale due volte e fai la media |
L'Arduino Mega è il passo di crescita più semplice per chi conosce la Uno: stesso codice, stesse librerie, ma molti più pin, porte e memoria. Per i progetti piccoli ti serviranno anche le guide al pinout dell'Arduino Uno e al pinout dell'Arduino Nano. Nell'app BlueGrays trovi passo dopo passo, con schema elettrico e codice, progetti che richiedono molti pin come l'orologio digitale a 7 segmenti a 4 cifre, la serratura con codice con keypad e LCD, il robot che evita gli ostacoli e la cassaforte elettronica intelligente, e puoi adattare la disposizione dei pin alla tua Mega.
Domande frequenti
Quanti pin ha l'Arduino Mega?
L'Arduino Mega 2560 ha 54 I/O digitali e 16 ingressi analogici, per un totale di 70 pin di segnale. 15 dei pin digitali danno il PWM e i pin analogici (A0–A15) si possono usare, se serve, come pin digitali dal 54 al 69. In più ci sono i pin di alimentazione e controllo come 5V, 3.3V, Vin, GND, AREF, IOREF e RESET.
Quali sono i pin PWM dell'Arduino Mega?
Sulla Mega danno il PWM i pin da 2 a 13 e i pin 44, 45 e 46, per un totale di 15 uscite PWM. I pin 4 e 13 lavorano a circa 980 Hz, gli altri a circa 490 Hz. Quando usi la libreria Servo, il PWM su 44, 45 e 46 viene disattivato.
Dove sono i pin SDA e SCL dell'Arduino Mega?
Sulla Mega la linea I2C è sui pin 20 (SDA) e 21 (SCL); sulle schede R3 gli stessi segnali sono presenti anche sul connettore accanto ad AREF. A4 e A5, che sulla Uno sono l'I2C, sulla Mega sono normali ingressi analogici. L'SPI è invece sui pin 50 (MISO), 51 (MOSI), 52 (SCK) e 53 (SS) e sul connettore ICSP.
Il codice della Arduino Uno funziona sulla Mega?
La maggior parte del codice per Uno si compila e funziona sulla Mega senza modifiche; basta selezionare la scheda Mega 2560 dal menu Strumenti. I problemi di solito sono hardware: I2C e SPI sono in posizioni diverse e il codice che accede direttamente ai registri di timer e porte va rivisto. Anche passare dal codice con SoftwareSerial alle seriali hardware della Mega dà risultati più affidabili.
Quali sono i pin di interrupt dell'Arduino Mega?
I pin di interrupt esterni utilizzabili con attachInterrupt sono 2, 3, 18, 19, 20 e 21. Poiché 18 e 19 sono condivisi con Serial1 e 20 e 21 con l'I2C, se usi queste linee restano liberi solo 2 e 3. Usare digitalPinToInterrupt(pin) invece di scrivere a mano il numero dell'interrupt evita errori.
Si può collegare un sensore a 3,3 V all'Arduino Mega?
Sì, ma con attenzione. La Mega lavora a logica 5 V; un'uscita a 3,3 V di solito viene letta come HIGH, ma l'uscita a 5 V della Mega può danneggiare un ingresso a 3,3 V. Per questo sui pin di ingresso del modulo usa un partitore di tensione o un convertitore di livello logico; per l'I2C, a causa dei pull-up a 5 V sulla scheda, preferisci un convertitore di livello bidirezionale.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED in sequenza
Luci che si accendono una dopo l'altra, come se corressero. L'Arduino accende sei LED uno alla volta; ognuno brilla per un istante e si spegne, così la luce percorre la fila dall'inizio alla fine e…

Effetto Supercar con LED
La classica luce che va e viene: un punto luminoso scorre da un capo all'altro di sei LED e poi torna indietro.

HC-SR04 Misura della distanza (display seriale)
Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

Orologio digitale con display a 7 segmenti a 4 cifre
Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

Serratura con password, tastierino 4x4 e LCD
Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

Cassaforte elettronica intelligente
Una piccola cassaforte per le tue cose di valore che si apre con un codice. Digiti il tuo codice a quattro cifre sul tastierino; se è giusto, il servomotore apre la serratura, si accende la luce…

Coreografia di servo in cerchio - Animazioni con 32 servomotori
Un progetto di animazione visiva con 32 servomotori disposti in cerchio su un Arduino Mega. I servo sono gestiti in un unico array, collegati ai pin 22–53 del Mega, e mostrano quattro sequenze di movimento: una vibrazione caotica ad angoli casuali, una spazzata sincronizzata, un'onda che gira lungo il cerchio e un ago di bussola che oscilla a destra e a sinistra.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

