Componentes · 12 min de lectura

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.

Placa Arduino Mega 2560 y sus cabeceras de pines
Arduino Mega 2560: procesador ATmega2560, 54 pines digitales y 16 analógicos; en la doble fila del borde derecho están los pines digitales 22–53.

¿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ísticaValor
MicrocontroladorATmega2560 (AVR de 8 bits)
Velocidad de reloj16 MHz
Memoria flash256 KB (8 KB del bootloader)
SRAM8 KB
EEPROM4 KB
Tensión de trabajo5 V
Tensión de entrada (jack / Vin)7–12 V recomendada, límite 6–20 V
E/S digitales54 (15 con PWM)
Entradas analógicas16 (A0–A15, 10 bits)
Puertos serie por hardware4 (Serial, Serial1, Serial2, Serial3)
Pines de interrupción externa6
Corriente por pin20 mA recomendada, 40 mA límite absoluto
Corriente del pin 3.3VMáximo 50 mA
Tamaño101,5 × 53,3 mm

Comparación entre Arduino Mega y Uno

CaracterísticaArduino Uno R3Arduino Mega 2560
MicrocontroladorATmega328PATmega2560
Velocidad de reloj16 MHz16 MHz
Pines digitales1454
Pines PWM6 (3, 5, 6, 9, 10, 11)15 (2–13, 44, 45, 46)
Entradas analógicas6 (A0–A5)16 (A0–A15)
Puertos serie por hardware14
Pines de interrupción externa2 (2, 3)6 (2, 3, 18, 19, 20, 21)
Flash / SRAM / EEPROM32 KB / 2 KB / 1 KB256 KB / 8 KB / 4 KB
Pines I2CA4 (SDA), A5 (SCL)20 (SDA), 21 (SCL)
Pines SPI10, 11, 12, 1353, 51, 50, 52
Tamaño68,6 × 53,4 mm101,5 × 53,3 mm

Mapa de pines del Arduino Mega: todos los grupos

Grupo de pinesNúmeros de pinFunción y notas
Pines digitales comunes con el Uno0–130 (RX0) y 1 (TX0) son la línea serie USB; el 13 tiene el LED integrado
Pines de puertos serie adicionales14–1914 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1
I2C20 (SDA), 21 (SCL)Biblioteca Wire; la placa lleva resistencias pull-up de 10 kΩ a 5 V
Cabecera digital de doble fila22–53E/S de propósito general; no hay PWM salvo en 44, 45 y 46
PWM2–13, 44, 45, 46Se usa con analogWrite(pin, 0–255)
SPI50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)Las mismas señales están también en la cabecera ICSP
Entradas analógicasA0–A15 (digitales 54–69)Se leen con analogRead y también pueden usarse como pines digitales
Alimentación y control5V, 3.3V, Vin, GND, IOREF, AREF, RESETAREF es la entrada de referencia analógica externa; si pones RESET en LOW la placa se reinicia
Cada pin de entrada/salida de la Mega soporta como máximo 40 mA; para trabajar con seguridad mantente por debajo de 20 mA. La corriente total que el procesador puede entregar entre todos los pines es de unos 200 mA. Que haya 54 pines no significa que puedas alimentar 54 LED directamente a la vez ni conectar un motor o la bobina de un relé a un pin: eso daña el procesador; para esas cargas usa un transistor o un driver. Además, los pines 0 y 1 están conectados a la línea serie USB, así que con un módulo conectado ahí puede que no se cargue el código.

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

TemporizadorPines PWMFrecuencia por defecto¿Con qué entra en conflicto?
Timer0 (8 bits)4, 13~980 Hzmillis() y delay()
Timer1 (16 bits)11, 12~490 HzBiblioteca Servo (servos 13.º–24.º)
Timer2 (8 bits)9, 10~490 HzFunción tone()
Timer3 (16 bits)2, 3, 5~490 HzBiblioteca Servo (servos 25.º–36.º)
Timer4 (16 bits)6, 7, 8~490 HzBiblioteca Servo (servos 37.º–48.º)
Timer5 (16 bits)44, 45, 46~490 HzBiblioteca 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.

PuertoPin TXPin RXUso típico
Serial10USB y Monitor Serie
Serial11819Módulo Bluetooth HC-05
Serial21617Módulo GPS NEO-6M
Serial31415SIM800L GSM o sensor de huellas
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}

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.

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

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}

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ñalArduino UnoArduino MegaESP32Raspberry Pi Pico
I2C SDAA420GPIO 21GP4
I2C SCLA521GPIO 22GP5
SPI MISO1250GPIO 19GP16
SPI MOSI1151GPIO 23GP19
SPI SCK1352GPIO 18GP18
SPI SS / CS1053GPIO 5GP17
TX / RX del puerto serie adicionalNo hay (SoftwareSerial)18 / 19 (Serial1)GPIO 17 / 16 (Serial2)GP0 / GP1 (UART0)
Nivel lógico5 V5 V3,3 V3,3 V

Paso a paso: tu primer programa con la Mega (luces secuenciales con 16 LED)

  1. 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.
  2. En el IDE de Arduino, elige Arduino Mega or Mega 2560 en el menú Herramientas > Placa y deja el procesador en ATmega2560 (Mega 2560).
  3. 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).
  4. 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.
  5. 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.
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}

¿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óduloPin de la Mega¿Por qué este pin?
Bluetooth HC-0518 (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-6M16 (TX2), 17 (RX2)El GPS envía muchas líneas por segundo y necesita un puerto propio
GSM SIM800L14 (TX3), 15 (RX3)Tercer puerto independiente para SMS y llamadas
LCD I2C + BME28020 (SDA), 21 (SCL)Los dos dispositivos comparten el mismo bus I2C con direcciones distintas
RFID RC52250, 51, 52, 53 + RST 49Bus SPI por hardware, con el 53 como CS
Sensor de humedad del suelo (4 unidades)A0–A3Los cuatro primeros de los 16 canales analógicos
Sensor de gas MQ-2A4Sensor con salida analógica
Sensor de caudal de agua2Pin de interrupción externa para no perder pulsos
Módulo de relés de 8 canales22–29Salidas digitales normales que no necesitan PWM
Ventilador (con MOSFET)6PWM para controlar la velocidad (Timer4)
Servo (tapa)8La 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íntomaCausaSolución
El código no se carga y avrdude da un error de tiempo de esperaLa placa seleccionada sigue siendo Uno, el puerto es incorrecto o hay un módulo conectado a los pines 0 y 1Elige 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 I2CLos cables están en A4 y A5 por costumbre del UnoConecta SDA al 20 y SCL al 21
El módulo SPI del shield no funcionaEl shield toma las señales SPI de los pines 11–13Usa la cabecera ICSP o los pines 50–52
Al añadir un servo, analogWrite deja de funcionar en 44–46La biblioteca Servo usa Timer5Pasa la salida PWM a un pin entre el 2 y el 13
SoftwareSerial no recibe datosEl pin RX elegido no admite interrupciones por cambio de pinUsa los puertos por hardware Serial1, Serial2 o Serial3
La placa se calienta o se reinicia solaUn motor, una bobina de relé o muchos LED se alimentan directamente desde los pinesUsa un transistor, un MOSFET o un driver de motor y añade alimentación externa
Los valores analógicos fluctúan sin pararSe lee una entrada sin conectar o hay filtración entre canalesLee solo los canales con sensor conectado y haz la media de dos lecturas por canal
Antes de empezar el proyecto, escribe el plan de pines en papel: coloca primero los pines con funciones especiales (puertos serie, I2C, SPI, interrupciones y PWM) y reparte al final los pines digitales normales entre el 22 y el 53. Si sigues este orden, no tendrás que desmontar cables a mitad del proyecto. Para comparar los pines visualmente puedes usar la herramienta de mapa de pines y, para las lecturas de sensores con ruido, el artículo sobre filtrado de datos de sensores.

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.

Ver todos los proyectos
Luz secuencial LED
AR-5Intermedio

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…

4.6(87)
218
Efecto coche fantástico con LED
AR-6Intermedio

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.

4.8(107)
214
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

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.

4.6(50)
82
Reloj digital con display de 7 segmentos de 4 dígitos
AR-48Intermedio
Premium

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…

4.8(56)
73
Cerradura con contraseña, teclado 4x4 y LCD
AR-64Avanzado
Premium

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…

4.8(59)
75
Robot para evitar obstáculos
AR-81Avanzado
Premium

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.

5.0(38)
49
Caja fuerte electrónica inteligente
AR-92Avanzado
Premium

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…

4.7(42)
63
Coreografía de servos en círculo - Patrones animados con 32 servos
AR-97Avanzado
Premium

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.

4.5(40)
62