Componenti · 11 min di lettura

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.

Scheda Arduino Mega 2560 e connettori dei pin
Arduino Mega 2560: processore ATmega2560, 54 pin digitali e 16 analogici; sul doppio connettore a destra ci sono i pin digitali 22–53.

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.

CaratteristicaValore
MicrocontrolloreATmega2560 (AVR a 8 bit)
Frequenza di clock16 MHz
Memoria flash256 KB (8 KB per il bootloader)
SRAM8 KB
EEPROM4 KB
Tensione di lavoro5 V
Tensione di ingresso (jack / Vin)7–12 V consigliati, limite 6–20 V
I/O digitali54 (15 con PWM)
Ingressi analogici16 (A0–A15, 10 bit)
Porte seriali hardware4 (Serial, Serial1, Serial2, Serial3)
Pin per interrupt esterni6
Corrente per pin20 mA consigliati, 40 mA limite assoluto
Corrente del pin 3.3VMassimo 50 mA
Dimensioni101,5 × 53,3 mm

Confronto tra Arduino Mega e Uno

CaratteristicaArduino Uno R3Arduino Mega 2560
MicrocontrolloreATmega328PATmega2560
Frequenza di clock16 MHz16 MHz
Pin digitali1454
Pin PWM6 (3, 5, 6, 9, 10, 11)15 (2–13, 44, 45, 46)
Ingressi analogici6 (A0–A5)16 (A0–A15)
Porte seriali hardware14
Pin per interrupt esterni2 (2, 3)6 (2, 3, 18, 19, 20, 21)
Flash / SRAM / EEPROM32 KB / 2 KB / 1 KB256 KB / 8 KB / 4 KB
Pin I2CA4 (SDA), A5 (SCL)20 (SDA), 21 (SCL)
Pin SPI10, 11, 12, 1353, 51, 50, 52
Dimensioni68,6 × 53,4 mm101,5 × 53,3 mm

Mappa dei pin dell'Arduino Mega: tutti i gruppi

Gruppo di pinNumeri dei pinFunzione e note
Pin digitali in comune con la Uno0–130 (RX0) e 1 (TX0) sono la linea seriale USB; sul 13 c'è il LED integrato
Pin delle seriali aggiuntive14–1914 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1
I2C20 (SDA), 21 (SCL)Libreria Wire; sulla scheda ci sono resistenze di pull-up da 10 kΩ a 5 V
Connettore digitale a doppia fila22–53I/O generici; non c'è PWM tranne su 44, 45 e 46
PWM2–13, 44, 45, 46Si usa con analogWrite(pin, 0–255)
SPI50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)Gli stessi segnali sono presenti anche sul connettore ICSP
Ingressi analogiciA0–A15 (digitali 54–69)Si leggono con analogRead, si possono usare anche come pin digitali
Alimentazione e controllo5V, 3.3V, Vin, GND, IOREF, AREF, RESETAREF è l'ingresso di riferimento analogico esterno; con RESET a LOW la scheda si riavvia
Ogni pin di I/O della Mega sopporta al massimo 40 mA; per lavorare in sicurezza resta sotto i 20 mA. La corrente totale che il processore può erogare da tutti i pin è circa 200 mA. Avere 54 pin non significa poter pilotare 54 LED direttamente, né collegare motori o bobine di relè al pin: rovineresti il processore. Per questi carichi usa un transistor o un driver. Inoltre i pin 0 e 1 sono collegati alla linea seriale USB: con un modulo collegato, il caricamento del codice può fallire.

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?.

TimerPin PWMFrequenza predefinitaCon cosa va in conflitto?
Timer0 (8 bit)4, 13~980 Hzmillis() e delay()
Timer1 (16 bit)11, 12~490 HzLibreria Servo (servo 13–24)
Timer2 (8 bit)9, 10~490 HzFunzione tone()
Timer3 (16 bit)2, 3, 5~490 HzLibreria Servo (servo 25–36)
Timer4 (16 bit)6, 7, 8~490 HzLibreria Servo (servo 37–48)
Timer5 (16 bit)44, 45, 46~490 HzLibreria 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.

PortaPin TXPin RXUso tipico
Serial10USB e Monitor Seriale
Serial11819Modulo Bluetooth HC-05
Serial21617Modulo GPS NEO-6M
Serial31415SIM800L GSM o sensore di impronte
C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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?.

SegnaleArduino UnoArduino MegaESP32Raspberry Pi Pico
I2C SDAA420GPIO 21GP4
I2C SCLA521GPIO 22GP5
SPI MISO1250GPIO 19GP16
SPI MOSI1151GPIO 23GP19
SPI SCK1352GPIO 18GP18
SPI SS / CS1053GPIO 5GP17
Seriale aggiuntiva TX / RXNessuna (SoftwareSerial)18 / 19 (Serial1)GPIO 17 / 16 (Serial2)GP0 / GP1 (UART0)
Livello logico5 V5 V3,3 V3,3 V

Passo dopo passo: il primo programma con la Mega (luce scorrevole con 16 LED)

  1. Collega la Mega al computer con un cavo USB-B; se il chip USB della scheda clone è un CH340, installa prima il driver.
  2. Nell'IDE Arduino scegli dal menu Strumenti > Scheda la voce Arduino Mega or Mega 2560 e lascia come processore ATmega2560 (Mega 2560).
  3. 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).
  4. 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.
  5. 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.
C++ (Arduino IDE)
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

ModuloPin MegaPerché questo pin?
Bluetooth HC-0518 (TX1), 19 (RX1)La comunicazione con il telefono avviene su una seriale hardware, i dati non si perdono
GPS NEO-6M16 (TX2), 17 (RX2)Il GPS invia molte righe ogni secondo e vuole una porta dedicata
GSM SIM800L14 (TX3), 15 (RX3)Terza porta indipendente per SMS e chiamate
LCD I2C + BME28020 (SDA), 21 (SCL)I due dispositivi condividono la stessa linea I2C con indirizzi diversi
RFID RC52250, 51, 52, 53 + RST 49Linea SPI hardware, come CS si usa il 53
Sensore di umidità del terreno (4)A0–A3I primi quattro dei 16 canali analogici
Sensore di gas MQ-2A4Sensore con uscita analogica
Sensore di flusso dell'acqua2Pin di interrupt esterno per non perdere gli impulsi
Modulo relè a 8 canali22–29Semplici uscite digitali, senza bisogno di PWM
Ventola (con MOSFET)6PWM per il controllo della velocità (Timer4)
Servo (sportello)8Il segnale del servo può uscire da qualsiasi pin digitale; poiché usa Timer5, 44–46 non vanno riservati al PWM

Errori comuni e come risolverli

SintomoCausaSoluzione
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 1Scegli Mega 2560 e la porta giusta dal menu Strumenti, scollega i cavi su 0 e 1 durante il caricamento
Display o sensore I2C non trovatoI cavi sono stati collegati ad A4 e A5 per abitudine con la UnoCollega SDA al 20 e SCL al 21
Il modulo SPI sullo shield non funzionaLo shield prende i segnali SPI dai pin 11–13Usa il connettore ICSP o i pin 50–52
Dopo aver aggiunto un servo, analogWrite su 44–46 si è fermatoLa libreria Servo usa Timer5Sposta l'uscita PWM su un pin tra 2 e 13
SoftwareSerial non riceve datiIl pin RX scelto non supporta gli interrupt di cambio pinUsa le porte hardware Serial1, Serial2 o Serial3
La scheda si scalda o si resetta da solaMotore, bobina di relè o molti LED pilotati direttamente dal pinUsa un transistor, un MOSFET o un driver motore e aggiungi un'alimentazione esterna
I valori analogici oscillano di continuoLettura di un ingresso flottante o dispersione tra i canaliLeggi solo i canali con un sensore collegato, leggi ogni canale due volte e fai la media
Prima di iniziare il progetto, scrivi su carta il piano dei pin: sistema per primi i pin con funzioni speciali (seriali, I2C, SPI, interrupt e PWM) e per ultimi i semplici pin digitali tra 22 e 53. Procedendo in quest'ordine non dovrai staccare i cavi a metà progetto. Per confrontare i pin visivamente usa lo strumento pinout, e per le letture rumorose dei sensori l'articolo filtraggio dei dati dei sensori.

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.

Vedi tutti i progetti
LED in sequenza
AR-5Intermedio

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…

4.6(87)
218
Effetto Supercar con LED
AR-6Intermedio

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.

4.8(107)
214
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

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é.

4.6(50)
82
Orologio digitale con display a 7 segmenti a 4 cifre
AR-48Intermedio
Premium

Orologio digitale con display a 7 segmenti a 4 cifre

Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

4.8(56)
73
Serratura con password, tastierino 4x4 e LCD
AR-64Avanzato
Premium

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…

4.8(59)
75
Robot che evita gli ostacoli
AR-81Avanzato
Premium

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.

5.0(38)
49
Cassaforte elettronica intelligente
AR-92Avanzato
Premium

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…

4.7(42)
63
Coreografia di servo in cerchio - Animazioni con 32 servomotori
AR-97Avanzato
Premium

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.

4.5(40)
62