Pines del Arduino Mega: mapa, PWM, serie e interrupciones
Pines del Arduino Mega 2560: 54 digitales, 16 analógicos, 15 PWM, 4 puertos serie y 6 interrupciones. Comparativa con Uno, códigos e impresora 3D.
Los pines del Arduino Mega ofrecen la mayor capacidad de conexión de la familia Arduino: la placa Arduino Mega 2560 tiene 54 entradas/salidas digitales, 16 entradas analógicas, 15 salidas PWM, 4 puertos serie por hardware y 6 pines de interrupción externa. Cuando los pines del Uno no te alcanzan, cuando necesitas hablar con varios dispositivos serie a la vez (GPS, Bluetooth, GSM) o cuando se te llena la memoria de programa, la Mega es la primera placa en la que piensas. Además usa el mismo lenguaje Arduino, el mismo IDE y la gran mayoría de las bibliotecas del Uno, así que creces sin aprender nada nuevo.
En esta guía repasamos el mapa de pines de la Mega grupo por grupo: qué pines dan PWM, en qué pines está cada puerto serie, dónde funcionan las interrupciones y por qué I2C y SPI están en otro sitio que en el Uno. Después veremos la tabla comparativa con el Uno, cuándo necesitas de verdad una Mega, por qué es el estándar en las impresoras 3D y cómo planificar los pines en un proyecto con muchos sensores.

¿Qué es el Arduino Mega 2560 y cómo funciona?
El Arduino Mega 2560 es una placa de desarrollo basada en el microcontrolador de 8 bits ATmega2560. Funciona a los mismos 16 MHz que el Uno, usa la misma lógica de 5 V y se programa con el mismo IDE de Arduino; es decir, la Mega no es más rápida que el Uno, sino más grande. Gracias a su encapsulado de 100 patillas, la placa expone 70 pines de señal. La conexión USB corre a cargo del chip ATmega16U2 de la placa; en las placas clónicas suele encargarse el CH340. Puedes alimentarla por USB con 5 V o por el jack y Vin con 7–12 V; el regulador interno baja esa tensión a 5 V. Tiene 8 veces la memoria de programa del Uno y 4 veces su RAM, por eso las bibliotecas grandes, las pantallas gráficas y los menús largos funcionan sin problema. La mitad izquierda de la placa coincide con el Uno en la disposición de pines, así que la mayoría de los shields de Uno se pueden montar directamente en la Mega.
| Característica | Valor |
|---|---|
| Microcontrolador | ATmega2560 (AVR de 8 bits) |
| Velocidad de reloj | 16 MHz |
| Memoria flash | 256 KB (8 KB del bootloader) |
| SRAM | 8 KB |
| EEPROM | 4 KB |
| Tensión de trabajo | 5 V |
| Tensión de entrada (jack / Vin) | 7–12 V recomendada, límite 6–20 V |
| E/S digitales | 54 (15 con PWM) |
| Entradas analógicas | 16 (A0–A15, 10 bits) |
| Puertos serie por hardware | 4 (Serial, Serial1, Serial2, Serial3) |
| Pines de interrupción externa | 6 |
| Corriente por pin | 20 mA recomendada, 40 mA límite absoluto |
| Corriente del pin 3.3V | Máximo 50 mA |
| Tamaño | 101,5 × 53,3 mm |
Comparación entre Arduino Mega y Uno
| Característica | Arduino Uno R3 | Arduino Mega 2560 |
|---|---|---|
| Microcontrolador | ATmega328P | ATmega2560 |
| Velocidad de reloj | 16 MHz | 16 MHz |
| Pines digitales | 14 | 54 |
| Pines PWM | 6 (3, 5, 6, 9, 10, 11) | 15 (2–13, 44, 45, 46) |
| Entradas analógicas | 6 (A0–A5) | 16 (A0–A15) |
| Puertos serie por hardware | 1 | 4 |
| Pines de interrupción externa | 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 |
| Pines I2C | A4 (SDA), A5 (SCL) | 20 (SDA), 21 (SCL) |
| Pines SPI | 10, 11, 12, 13 | 53, 51, 50, 52 |
| Tamaño | 68,6 × 53,4 mm | 101,5 × 53,3 mm |
Mapa de pines del Arduino Mega: todos los grupos
| Grupo de pines | Números de pin | Función y notas |
|---|---|---|
| Pines digitales comunes con el Uno | 0–13 | 0 (RX0) y 1 (TX0) son la línea serie USB; el 13 tiene el LED integrado |
| Pines de puertos serie adicionales | 14–19 | 14 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1 |
| I2C | 20 (SDA), 21 (SCL) | Biblioteca Wire; la placa lleva resistencias pull-up de 10 kΩ a 5 V |
| Cabecera digital de doble fila | 22–53 | E/S de propósito general; no hay PWM salvo en 44, 45 y 46 |
| PWM | 2–13, 44, 45, 46 | Se usa con analogWrite(pin, 0–255) |
| SPI | 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS) | Las mismas señales están también en la cabecera ICSP |
| Entradas analógicas | A0–A15 (digitales 54–69) | Se leen con analogRead y también pueden usarse como pines digitales |
| Alimentación y control | 5V, 3.3V, Vin, GND, IOREF, AREF, RESET | AREF es la entrada de referencia analógica externa; si pones RESET en LOW la placa se reinicia |
Pines PWM y temporizadores
La Mega tiene 15 salidas PWM: los 12 pines del 2 al 13 más el 44, 45 y 46. Con ellos puedes regular el brillo de un LED o la velocidad de un motor usando analogWrite(pin, 0–255). Las señales PWM las generan seis temporizadores por hardware (Timer0–Timer5); Timer0 y Timer2 son de 8 bits y los demás de 16 bits. Como Timer0 también gestiona millis() y delay(), los pines 4 y 13 trabajan a unos 980 Hz y el resto de pines PWM a unos 490 Hz. Lo que más debes vigilar es que, cuando una biblioteca se apropia de un temporizador, el PWM de los pines asociados deja de funcionar: la biblioteca Servo usa Timer5 para los 12 primeros servos en la Mega, así que en cuanto conectas un servo analogWrite deja de funcionar en 44, 45 y 46; tone() usa Timer2 y afecta a los pines 9 y 10. Los conceptos de ciclo de trabajo y frecuencia los tienes explicados en ¿Qué es PWM?.
| Temporizador | Pines PWM | Frecuencia por defecto | ¿Con qué entra en conflicto? |
|---|---|---|---|
| Timer0 (8 bits) | 4, 13 | ~980 Hz | millis() y delay() |
| Timer1 (16 bits) | 11, 12 | ~490 Hz | Biblioteca Servo (servos 13.º–24.º) |
| Timer2 (8 bits) | 9, 10 | ~490 Hz | Función tone() |
| Timer3 (16 bits) | 2, 3, 5 | ~490 Hz | Biblioteca Servo (servos 25.º–36.º) |
| Timer4 (16 bits) | 6, 7, 8 | ~490 Hz | Biblioteca Servo (servos 37.º–48.º) |
| Timer5 (16 bits) | 44, 45, 46 | ~490 Hz | Biblioteca Servo (primeros 12 servos) |
4 puertos serie por hardware: Serial, Serial1, Serial2, Serial3
El Uno solo tiene un puerto serie por hardware, y además lo comparte con el USB; para un segundo dispositivo tienes que usar SoftwareSerial. SoftwareSerial puede perder datos a velocidades altas, solo escucha un puerto a la vez y ralentiza el resto del código porque desactiva las interrupciones mientras recibe un byte. La Mega, en cambio, tiene cuatro UART independientes; cada uno trabaja en segundo plano con su propio búfer de recepción de 64 bytes, así que mientras haces otras cosas en loop() los datos entrantes no se pierden. La regla de conexión es la misma en todos los puertos: el TX del módulo va al RX de la Mega, el RX del módulo al TX de la Mega y las GND siempre en común. Si conectas la salida TX de 5 V de la Mega a la entrada RX de un módulo de lógica de 3,3 V, baja la señal a unos 3,3 V con un divisor de tensión de 1 kΩ y 2 kΩ. El siguiente código puente envía a Serial1 lo que escribas en el Monitor Serie y al Monitor Serie lo que llegue de Serial1; es la forma más rápida de probar módulos como el HC-05. Para entender cómo funciona la UART, consulta el artículo sobre comunicación serie UART.
| Puerto | Pin TX | Pin RX | Uso típico |
|---|---|---|---|
| Serial | 1 | 0 | USB y Monitor Serie |
| Serial1 | 18 | 19 | Módulo Bluetooth HC-05 |
| Serial2 | 16 | 17 | Módulo GPS NEO-6M |
| Serial3 | 14 | 15 | SIM800L GSM o sensor de huellas |
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}Pines de interrupción
Una interrupción externa te permite detectar un cambio en un pin en microsegundos, haga lo que haga loop() en ese momento; es ideal para encoders, sensores de caudal de agua, tacómetros y botones que exigen reacción rápida. En la Mega hay 6 pines utilizables con attachInterrupt: 2, 3, 18, 19, 20 y 21. Los números de interrupción no siguen el orden de los pines (2 → 0, 3 → 1, 21 → 2, 20 → 3, 19 → 4, 18 → 5); por eso, en lugar de escribir el número a mano, usa siempre digitalPinToInterrupt(pin). Ojo: 18 y 19 son los pines de Serial1 y 20 y 21 los de I2C; si usas Serial1 e I2C solo te quedan el 2 y el 3. Si necesitas más pines, las interrupciones por cambio de pin (PCINT) del ATmega2560 funcionan en los pines 10–15, 50–53 y A8–A15 y se pueden usar con las bibliotecas adecuadas. El código siguiente cuenta los pulsos de los pines 2 y 18; las funciones de interrupción son cortas, los contadores compartidos se declaran volatile y las interrupciones se detienen brevemente durante la lectura. En este ejemplo el 18 está dedicado a la interrupción, así que no se puede usar Serial1. Para profundizar, lee el artículo sobre interrupciones en Arduino.
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 entradas analógicas (A0–A15)
Las 16 entradas analógicas de la Mega comparten un único ADC de 10 bits a través de un multiplexor. Cada lectura devuelve un valor entre 0 y 1023; con referencia de 5 V, un paso equivale a unos 4,9 mV. Como una conversión dura unos 100 microsegundos, puedes hacer alrededor de 10.000 lecturas por segundo, así que recorrer los 16 canales en secuencia no supone ningún problema. Si necesitas más precisión, con analogReference puedes elegir la referencia interna de 1,1 V (INTERNAL1V1) o de 2,56 V (INTERNAL2V56); la opción INTERNAL del Uno no existe en la Mega. Los pines analógicos también se pueden usar como digitales: A0 es el pin digital 54 y A15 el 69; con pinMode(A8, OUTPUT) puedes encender un LED desde ese pin. Al cambiar rápidamente de canal, la tensión del canal anterior puede filtrarse en la siguiente medida; con fuentes de impedancia interna superior a 10 kΩ, leer cada canal dos veces y descartar la primera lectura reduce este error. El funcionamiento del ADC lo encuentras en el artículo sobre la conversión analógica-digital.
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}Pines I2C y SPI: compatibilidad con los shields del Uno
La diferencia que más tropiezos causa al pasar a la Mega es la ubicación de los pines de comunicación. En el Uno, I2C está en A4 y A5 y SPI en los pines 10–13; en la Mega, I2C está en 20 (SDA) y 21 (SCL) y SPI en los pines 50–53. En las placas R3, SDA y SCL se repiten además en la cabecera junto a AREF; las señales SPI, por su parte, están en el mismo sitio en ambas placas, en la cabecera ICSP de 6 pines del centro. Por eso los shields que toman SPI del ICSP funcionan sin problema en la Mega, mientras que los shields antiguos que toman SPI directamente de los pines 11–13 no funcionan. Las bibliotecas Wire y SPI usan los pines correctos por sí solas; lo tuyo es conectar los cables en el sitio adecuado. En SPI puedes conectar el pin CS del dispositivo a cualquier pin digital, pero nunca pongas el 53 como entrada: si ese pin es entrada y se pone en LOW, el procesador pasa a modo esclavo en SPI y la comunicación se detiene. Por ejemplo, un lector RFID RC522 se conecta así: SDA → 53, SCK → 52, MOSI → 51, MISO → 50. Para conocer los detalles de los protocolos, consulta ¿Qué es I2C? y ¿Qué es SPI?.
| Señal | 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 |
| TX / RX del puerto serie adicional | No hay (SoftwareSerial) | 18 / 19 (Serial1) | GPIO 17 / 16 (Serial2) | GP0 / GP1 (UART0) |
| Nivel lógico | 5 V | 5 V | 3,3 V | 3,3 V |
Paso a paso: tu primer programa con la Mega (luces secuenciales con 16 LED)
- Conecta la Mega al ordenador con un cable USB-B; si el chip USB de tu placa clónica es un CH340, instala antes su controlador.
- En el IDE de Arduino, elige Arduino Mega or Mega 2560 en el menú Herramientas > Placa y deja el procesador en ATmega2560 (Mega 2560).
- Elige el puerto de la placa en Herramientas > Puerto (algo como COM3 en Windows; en macOS, un nombre que empieza por /dev/cu.usbmodem o /dev/cu.wchusbserial).
- Conecta 16 LED a los pines 22–37, cada uno con una resistencia de 220 Ω, y lleva las patillas cortas (cátodo) de los LED a la línea de GND. En un LED rojo circulan (5 − 2) / 220 ≈ 13,6 mA; para otros colores puedes usar la calculadora de resistencia para LED.
- Carga el código siguiente; los LED se encenderán y apagarán en secuencia. Como solo hay un LED encendido a la vez, la corriente total se mantiene por debajo de 20 mA. El efecto de ida y vuelta lo tienes en el artículo sobre el coche fantástico y luces secuenciales.
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}¿Cuándo necesitas un Arduino Mega?
- Si no te alcanzan los pines: un teclado matricial 4x4 necesita por sí solo 8 pines y un LCD en paralelo 6; añade relés, botones y sensores y los 20 pines del Uno se agotan enseguida.
- Si tienes varios dispositivos serie: escuchar a la vez un GPS, Bluetooth y GSM es casi imposible en el Uno; en la Mega cada uno tiene su propio puerto por hardware.
- Si te quedas sin memoria: si el compilador avisa de poca memoria o si combinas pantalla TFT, tarjeta SD y código de menús, los 256 KB de flash y 8 KB de RAM te dan mucho margen; los detalles están en el artículo sobre memoria insuficiente en Arduino.
- Si tienes muchos sensores analógicos: con 16 canales lees humedad del suelo, gas, luz y potenciómetros sin necesidad de multiplexor.
- En robots con muchos servos: la biblioteca Servo admite hasta 48 servos en la Mega (12 en el Uno); es adecuada para un brazo robótico y robots caminantes.
- Cuando no hace falta una Mega: si necesitas Wi-Fi, alta velocidad o bajo consumo, un ESP32 tiene más sentido (¿Arduino o ESP32?); si solo te faltan unas pocas salidas, ampliar los pines del Uno con un registro de desplazamiento 74HC595 es una solución más barata y compacta.
Arduino Mega y RAMPS 1.4 en impresoras 3D
Durante años, la mayoría de las impresoras 3D caseras y las pequeñas CNC funcionaron con una Arduino Mega y una placa RAMPS 1.4 encima; este dúo sigue siendo hoy la electrónica de impresora más común con fines educativos. El motivo es sencillo: un firmware como Marlin, con soporte de pantalla y tarjeta SD, supera con holgura los 100 KB, y cinco drivers de motores paso a paso (X, Y, Z y dos extrusores), tres salidas MOSFET, seis finales de carrera, termistores, LCD y tarjeta SD necesitan decenas de pines. En RAMPS, las señales de paso y dirección del eje X van a los pines 54 y 55 (A0 y A1), las del eje Y a 60 y 61 (A6 y A7), las del eje Z a 46 y 48 y las del primer extrusor a 26 y 28. El calentador de la boquilla se controla con el pin PWM 10, la cama caliente con el 8 y el ventilador con el 9; los termistores de la boquilla y de la cama se leen en A13 y A14. Esta distribución es también un buen ejemplo de cómo se pueden aprovechar los pines analógicos como salidas digitales. Para el ajuste de corriente y la selección de micropasos de los drivers, echa un vistazo al artículo sobre el driver de motor paso a paso A4988.
Ejemplo de proyecto con varios sensores: planificar bien los pines
| Módulo | Pin de la Mega | ¿Por qué este pin? |
|---|---|---|
| Bluetooth HC-05 | 18 (TX1), 19 (RX1) | La comunicación con el móvil se hace en un puerto serie por hardware y no se pierden datos |
| GPS NEO-6M | 16 (TX2), 17 (RX2) | El GPS envía muchas líneas por segundo y necesita un puerto propio |
| GSM SIM800L | 14 (TX3), 15 (RX3) | Tercer puerto independiente para SMS y llamadas |
| LCD I2C + BME280 | 20 (SDA), 21 (SCL) | Los dos dispositivos comparten el mismo bus I2C con direcciones distintas |
| RFID RC522 | 50, 51, 52, 53 + RST 49 | Bus SPI por hardware, con el 53 como CS |
| Sensor de humedad del suelo (4 unidades) | A0–A3 | Los cuatro primeros de los 16 canales analógicos |
| Sensor de gas MQ-2 | A4 | Sensor con salida analógica |
| Sensor de caudal de agua | 2 | Pin de interrupción externa para no perder pulsos |
| Módulo de relés de 8 canales | 22–29 | Salidas digitales normales que no necesitan PWM |
| Ventilador (con MOSFET) | 6 | PWM para controlar la velocidad (Timer4) |
| Servo (tapa) | 8 | La señal del servo se puede generar en cualquier pin digital; como se usa Timer5, los pines 44–46 ya no sirven para PWM |
Errores comunes y cómo solucionarlos
| Síntoma | Causa | Solución |
|---|---|---|
| El código no se carga y avrdude da un error de tiempo de espera | La placa seleccionada sigue siendo Uno, el puerto es incorrecto o hay un módulo conectado a los pines 0 y 1 | Elige Mega 2560 y el puerto correcto en el menú Herramientas y quita los cables de 0 y 1 durante la carga |
| No se encuentra la pantalla o el sensor I2C | Los cables están en A4 y A5 por costumbre del Uno | Conecta SDA al 20 y SCL al 21 |
| El módulo SPI del shield no funciona | El shield toma las señales SPI de los pines 11–13 | Usa la cabecera ICSP o los pines 50–52 |
| Al añadir un servo, analogWrite deja de funcionar en 44–46 | La biblioteca Servo usa Timer5 | Pasa la salida PWM a un pin entre el 2 y el 13 |
| SoftwareSerial no recibe datos | El pin RX elegido no admite interrupciones por cambio de pin | Usa los puertos por hardware Serial1, Serial2 o Serial3 |
| La placa se calienta o se reinicia sola | Un motor, una bobina de relé o muchos LED se alimentan directamente desde los pines | Usa un transistor, un MOSFET o un driver de motor y añade alimentación externa |
| Los valores analógicos fluctúan sin parar | Se lee una entrada sin conectar o hay filtración entre canales | Lee solo los canales con sensor conectado y haz la media de dos lecturas por canal |
La Arduino Mega es el paso más cómodo para crecer si ya conoces el Uno: el mismo código, las mismas bibliotecas, pero muchos más pines, puertos y memoria. Para proyectos pequeños también te servirán las guías de pines del Arduino Uno y pines del Arduino Nano. En la app de BlueGrays encontrarás, con esquema del circuito y código paso a paso, proyectos que necesitan muchos pines, como un reloj digital de 4 dígitos con 7 segmentos, una cerradura con contraseña con teclado y LCD, un robot esquivaobstáculos y una caja fuerte electrónica inteligente, y podrás adaptar la distribución de pines a tu propia Mega.
Preguntas frecuentes
¿Cuántos pines tiene el Arduino Mega?
El Arduino Mega 2560 tiene 54 entradas/salidas digitales y 16 entradas analógicas, es decir, 70 pines de señal en total. 15 de los pines digitales dan salida PWM y los pines analógicos (A0–A15) también pueden usarse como pines digitales del 54 al 69 cuando haga falta. Además hay pines de alimentación y control como 5V, 3.3V, Vin, GND, AREF, IOREF y RESET.
¿Cuáles son los pines PWM del Arduino Mega?
En la Mega dan PWM los pines del 2 al 13 y el 44, 45 y 46; en total hay 15 salidas PWM. Los pines 4 y 13 trabajan a unos 980 Hz y los demás a unos 490 Hz. Si usas la biblioteca Servo, el PWM de los pines 44, 45 y 46 queda desactivado.
¿Dónde están los pines SDA y SCL del Arduino Mega?
En la Mega, el bus I2C está en los pines 20 (SDA) y 21 (SCL); en las placas R3 las mismas señales están también en la cabecera junto a AREF. A4 y A5, que en el Uno son I2C, en la Mega son entradas analógicas normales. SPI está en los pines 50 (MISO), 51 (MOSI), 52 (SCK) y 53 (SS) y en la cabecera ICSP.
¿Funciona el código del Arduino Uno en la Mega?
La mayoría del código del Uno compila y funciona en la Mega sin cambios; solo tienes que elegir Mega 2560 como placa en el menú Herramientas. Los problemas suelen venir del hardware: I2C y SPI están en otros pines, y el código que accede directamente a los registros de temporizadores y puertos hay que reescribirlo. Pasar el código que usa SoftwareSerial a los puertos serie por hardware de la Mega también da resultados más fiables.
¿Cuáles son los pines de interrupción del Arduino Mega?
Los pines de interrupción externa que se pueden usar con attachInterrupt son 2, 3, 18, 19, 20 y 21. Como el 18 y el 19 se comparten con Serial1 y el 20 y el 21 con I2C, si usas esas líneas solo te quedan libres el 2 y el 3. Usar digitalPinToInterrupt(pin) en lugar de escribir el número de interrupción a mano evita errores.
¿Se puede conectar un sensor de 3,3 V a la Arduino Mega?
Sí, pero con cuidado. La Mega trabaja con lógica de 5 V; normalmente lee una salida de 3,3 V como HIGH, pero la salida de 5 V de la Mega puede dañar una entrada de 3,3 V. Por eso usa un divisor de tensión o un convertidor de nivel lógico en las entradas del módulo; en I2C, por las resistencias pull-up de 5 V de la placa, es mejor un convertidor de nivel bidireccional.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Luz secuencial LED
Luces que se encienden una tras otra, como si corrieran. El Arduino enciende seis LED de uno en uno; cada uno brilla un instante y se apaga, así que la luz recorre la fila de principio a fin y vuelve…

Efecto coche fantástico con LED
La clásica luz que va y viene: un punto de luz recorre seis LED de un extremo al otro y luego regresa.

HC-SR04 Medición de distancia (pantalla en serie)
El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

Reloj digital con display de 7 segmentos de 4 dígitos
Un reloj digital luminoso de cuatro cifras, parecido al del horno de la cocina. El módulo de reloj DS1302 guarda la hora y cada segundo el Arduino lee las horas y los minutos y los muestra en el…

Cerradura con contraseña, teclado 4x4 y LCD
Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…

Robot para evitar obstáculos
¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

Caja fuerte electrónica inteligente
Una pequeña caja fuerte para tus cosas de valor que se abre con un código. Escribes tu código de cuatro cifras en el teclado; si es correcto, el servomotor abre el cierre, se enciende la luz verde y…

Coreografía de servos en círculo - Patrones animados con 32 servos
Un proyecto de animación visual con 32 servomotores dispuestos en círculo sobre un Arduino Mega. Los servos se gestionan en un único array, se conectan a los pines 22–53 del Mega y muestran cuatro secuencias de movimiento: una vibración caótica en ángulos aleatorios, un barrido sincronizado, una ola que recorre el círculo y una aguja de brújula que oscila de lado a lado.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

