Arduino Mega Pinbelegung: 2560 Pinout, PWM, Serial, Interrupt
Arduino Mega Pinbelegung im Überblick: 54 digitale und 16 analoge Pins, 15 PWM, 4 serielle Ports, 6 Interrupts. Vergleich mit dem Uno, Beispielcode und 3D-Drucker.
Die Arduino Mega Pinbelegung bietet die meisten Anschlussmöglichkeiten der ganzen Arduino-Familie: Der Arduino Mega 2560 hat 54 digitale Ein-/Ausgänge, 16 analoge Eingänge, 15 PWM-Ausgänge, 4 Hardware-Serialports und 6 externe Interrupt-Pins. Wenn die Pins des Uno nicht reichen, du mehrere serielle Geräte (GPS, Bluetooth, GSM) gleichzeitig betreiben willst oder dir der Programmspeicher ausgeht, ist der Mega die erste Wahl. Er nutzt dieselbe Arduino-Sprache, dieselbe IDE und die meisten Bibliotheken wie der Uno – du wächst also, ohne etwas Neues lernen zu müssen.
In diesem Guide gehen wir die Pinbelegung des Mega Gruppe für Gruppe durch: welche Pins PWM liefern, auf welchen Pins welcher serielle Port liegt, wo Interrupts funktionieren und warum I2C und SPI anders als beim Uno liegen. Danach folgen die Vergleichstabelle mit dem Uno, die Frage, wann du den Mega wirklich brauchst, warum er bei 3D-Druckern Standard ist und wie du die Pins in einem Projekt mit vielen Sensoren planst.

Was ist der Arduino Mega 2560 und wie funktioniert er?
Der Arduino Mega 2560 ist ein Entwicklungsboard auf Basis des 8-Bit-Mikrocontrollers ATmega2560. Er läuft wie der Uno mit 16 MHz, nutzt 5 V Logikpegel und wird mit derselben Arduino IDE programmiert – der Mega ist also nicht schneller als der Uno, sondern breiter. Durch das 100-polige Gehäuse des Prozessors lassen sich 70 Signalpins herausführen. Die USB-Verbindung übernimmt der ATmega16U2 auf dem Board, bei Klonen meist ein CH340. Du kannst das Board per USB mit 5 V oder über Buchse und Vin mit 7–12 V versorgen; der Spannungsregler reduziert auf 5 V. Der Programmspeicher ist 8-mal, der RAM 4-mal so groß wie beim Uno, deshalb laufen große Bibliotheken, Grafikdisplays und lange Menüs auf dem Mega problemlos. Die linke Hälfte des Boards entspricht in der Pinbelegung dem Uno, daher passen die meisten Uno-Shields direkt auf den Mega.
| Merkmal | Wert |
|---|---|
| Mikrocontroller | ATmega2560 (8-Bit-AVR) |
| Taktfrequenz | 16 MHz |
| Flash-Speicher | 256 KB (8 KB davon Bootloader) |
| SRAM | 8 KB |
| EEPROM | 4 KB |
| Betriebsspannung | 5 V |
| Eingangsspannung (Buchse / Vin) | 7–12 V empfohlen, 6–20 V Grenze |
| Digitale E/A | 54 (15 davon PWM) |
| Analoge Eingänge | 16 (A0–A15, 10 Bit) |
| Hardware-Serialports | 4 (Serial, Serial1, Serial2, Serial3) |
| Externe Interrupt-Pins | 6 |
| Strom pro Pin | 20 mA empfohlen, 40 mA absolute Grenze |
| Strom am 3.3V-Pin | maximal 50 mA |
| Abmessungen | 101,5 × 53,3 mm |
Arduino Mega und Uno im Vergleich
| Merkmal | Arduino Uno R3 | Arduino Mega 2560 |
|---|---|---|
| Mikrocontroller | ATmega328P | ATmega2560 |
| Taktfrequenz | 16 MHz | 16 MHz |
| Digitale Pins | 14 | 54 |
| PWM-Pins | 6 (3, 5, 6, 9, 10, 11) | 15 (2–13, 44, 45, 46) |
| Analoge Eingänge | 6 (A0–A5) | 16 (A0–A15) |
| Hardware-Serialports | 1 | 4 |
| Externe Interrupt-Pins | 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 |
| I2C-Pins | A4 (SDA), A5 (SCL) | 20 (SDA), 21 (SCL) |
| SPI-Pins | 10, 11, 12, 13 | 53, 51, 50, 52 |
| Abmessungen | 68,6 × 53,4 mm | 101,5 × 53,3 mm |
Arduino Mega Pinout: alle Pin-Gruppen
| Pin-Gruppe | Pin-Nummern | Funktion und Hinweise |
|---|---|---|
| Gemeinsame digitale Pins mit dem Uno | 0–13 | 0 (RX0) und 1 (TX0) sind die USB-Serialleitung; an 13 hängt die interne LED |
| Zusätzliche Serial-Pins | 14–19 | 14 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1 |
| I2C | 20 (SDA), 21 (SCL) | Wire-Bibliothek; auf dem Board sind 10-kΩ-Pull-ups nach 5 V vorhanden |
| Doppelreihige digitale Leiste | 22–53 | Allgemeine Ein-/Ausgänge; außer 44, 45 und 46 ohne PWM |
| PWM | 2–13, 44, 45, 46 | Nutzung mit analogWrite(pin, 0–255) |
| SPI | 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS) | Dieselben Signale liegen auch auf dem ICSP-Header |
| Analoge Eingänge | A0–A15 (digital 54–69) | Auslesen mit analogRead, auch als digitale Pins nutzbar |
| Spannung und Steuerung | 5V, 3.3V, Vin, GND, IOREF, AREF, RESET | AREF ist der externe analoge Referenzeingang; bei LOW an RESET startet das Board neu |
PWM-Pins und Timer
Der Mega hat 15 PWM-Ausgänge: die 12 Pins von 2 bis 13 sowie 44, 45 und 46. Mit analogWrite(pin, 0–255) regelst du darüber LED-Helligkeit und Motordrehzahl. Die PWM-Signale kommen von sechs Hardware-Timern (Timer0–Timer5); Timer0 und Timer2 sind 8 Bit, die übrigen 16 Bit. Da Timer0 auch millis() und delay() steuert, laufen die Pins 4 und 13 mit etwa 980 Hz, alle anderen PWM-Pins mit etwa 490 Hz. Wichtig: Belegt eine Bibliothek einen Timer, wird PWM an den zugehörigen Pins gestört. Die Servo-Bibliothek nutzt auf dem Mega für die ersten 12 Servos Timer5, sodass analogWrite an 44, 45 und 46 nicht mehr funktioniert, sobald du einen Servo anschließt; tone() nutzt Timer2 und betrifft die Pins 9 und 10. Duty Cycle und Frequenz erklärt Was ist PWM? ausführlich.
| Timer | PWM-Pins | Standardfrequenz | Konflikt mit |
|---|---|---|---|
| Timer0 (8 Bit) | 4, 13 | ~980 Hz | millis() und delay() |
| Timer1 (16 Bit) | 11, 12 | ~490 Hz | Servo-Bibliothek (13.–24. Servo) |
| Timer2 (8 Bit) | 9, 10 | ~490 Hz | Funktion tone() |
| Timer3 (16 Bit) | 2, 3, 5 | ~490 Hz | Servo-Bibliothek (25.–36. Servo) |
| Timer4 (16 Bit) | 6, 7, 8 | ~490 Hz | Servo-Bibliothek (37.–48. Servo) |
| Timer5 (16 Bit) | 44, 45, 46 | ~490 Hz | Servo-Bibliothek (die ersten 12 Servos) |
4 Hardware-Serialports: Serial, Serial1, Serial2, Serial3
Der Uno hat nur einen Hardware-Serialport, und der wird mit USB geteilt; für ein zweites Gerät musst du SoftwareSerial nutzen. SoftwareSerial kann bei hohen Baudraten Daten verlieren, hört nur einen Port gleichzeitig ab und bremst den restlichen Code, weil es beim Empfang Interrupts sperrt. Der Mega hat dagegen vier unabhängige UARTs, jeder mit eigenem 64-Byte-Empfangspuffer, der im Hintergrund arbeitet – eingehende Daten gehen nicht verloren, während du in loop() andere Dinge erledigst. Die Anschlussregel ist bei jedem Port gleich: TX des Moduls an RX des Mega, RX des Moduls an TX des Mega, und die GNDs müssen verbunden sein. Wenn ein Modul mit 3,3 V Logik arbeitet, senkst du das 5-V-Signal des Mega-TX mit 1 kΩ und 2 kΩ über einen Spannungsteiler auf etwa 3,3 V. Der folgende Brückencode leitet alles, was du im Seriellen Monitor eingibst, an Serial1 weiter und umgekehrt – der schnellste Weg, Module wie den HC-05 zu testen. Wie ein UART funktioniert, steht in UART serielle Kommunikation.
| Port | TX-Pin | RX-Pin | Typische Verwendung |
|---|---|---|---|
| Serial | 1 | 0 | USB und Serieller Monitor |
| Serial1 | 18 | 19 | HC-05 Bluetooth-Modul |
| Serial2 | 16 | 17 | NEO-6M GPS-Modul |
| Serial3 | 14 | 15 | SIM800L GSM oder Fingerabdrucksensor |
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}Interrupt-Pins
Ein externer Interrupt lässt dich eine Pegeländerung an einem Pin innerhalb von Mikrosekunden erfassen, egal was loop() gerade tut; ideal für Drehgeber, Durchflusssensoren, Drehzahlmesser und Taster mit schneller Reaktion. Auf dem Mega gibt es 6 Pins für attachInterrupt: 2, 3, 18, 19, 20 und 21. Die Interrupt-Nummern stimmen nicht mit der Pin-Reihenfolge überein (2 → 0, 3 → 1, 21 → 2, 20 → 3, 19 → 4, 18 → 5); schreib die Nummer deshalb nie von Hand, sondern nutze immer digitalPinToInterrupt(pin). Achtung: 18 und 19 gehören zu Serial1, 20 und 21 zu I2C; wenn du Serial1 und I2C nutzt, bleiben dir nur 2 und 3. Brauchst du mehr Pins, funktionieren die Pin-Change-Interrupts (PCINT) des ATmega2560 an den Pins 10–15, 50–53 und A8–A15 und sind mit passenden Bibliotheken nutzbar. Der folgende Code zählt Impulse an den Pins 2 und 18; die Interrupt-Funktionen sind kurz gehalten, die gemeinsamen Zähler als volatile deklariert und beim Auslesen werden die Interrupts kurz angehalten. Da 18 hier als Interrupt dient, kannst du Serial1 in diesem Beispiel nicht nutzen. Mehr dazu in 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 analoge Eingänge (A0–A15)
Die 16 analogen Eingänge des Mega teilen sich über einen Multiplexer einen einzigen 10-Bit-ADC. Jede Messung liefert einen Wert von 0–1023; bei 5 V Referenz entspricht ein Schritt etwa 4,9 mV. Eine Wandlung dauert rund 100 Mikrosekunden, du schaffst also etwa 10.000 Messungen pro Sekunde – 16 Kanäle nacheinander abzufragen ist kein Problem. Für genauere Messungen wählst du mit analogReference die interne 1,1-V-Referenz (INTERNAL1V1) oder 2,56 V (INTERNAL2V56); die Option INTERNAL des Uno gibt es beim Mega nicht. Analoge Pins lassen sich auch digital nutzen: A0 ist digital 54, A15 digital 69, und mit pinMode(A8, OUTPUT) kannst du darüber eine LED schalten. Beim schnellen Wechsel zwischen Kanälen kann die Spannung des vorherigen Kanals in die nächste Messung einfließen; bei Quellen mit mehr als 10 kΩ Innenwiderstand hilft es, jeden Kanal zweimal zu lesen und den ersten Wert zu verwerfen. Die Funktionsweise des ADC steht in Analog-Digital-Wandlung.
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}I2C- und SPI-Pins: Kompatibilität mit Uno-Shields
Der größte Stolperstein beim Umstieg ist die Lage der Kommunikationspins. Beim Uno liegt I2C an A4 und A5 und SPI an den Pins 10–13, beim Mega liegt I2C an 20 (SDA) und 21 (SCL) und SPI an den Pins 50–53. Bei R3-Boards werden SDA und SCL zusätzlich auf der Leiste neben AREF herausgeführt; die SPI-Signale liegen bei beiden Boards am selben Platz auf dem 6-poligen ICSP-Header in der Mitte. Shields, die SPI vom ICSP-Header abgreifen, laufen daher am Mega problemlos, ältere Shields, die SPI direkt von 11–13 nehmen, funktionieren nicht. Die Bibliotheken Wire und SPI verwenden die richtigen Pins selbst; du musst nur die Kabel richtig anschließen. Den CS-Pin eines SPI-Geräts kannst du an jeden digitalen Pin legen, aber schalte 53 niemals als Eingang: Wird dieser Pin zum Eingang und auf LOW gezogen, wechselt der Prozessor in den SPI-Slave-Modus und die Kommunikation bricht ab. Einen RC522-RFID-Leser schließt du zum Beispiel so an: SDA → 53, SCK → 52, MOSI → 51, MISO → 50. Details zu den Protokollen findest du in Was ist I2C? und Was ist SPI?.
| Signal | 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 |
| Zusätzlicher Serialport TX / RX | Keiner (SoftwareSerial) | 18 / 19 (Serial1) | GPIO 17 / 16 (Serial2) | GP0 / GP1 (UART0) |
| Logikpegel | 5 V | 5 V | 3,3 V | 3,3 V |
Schritt für Schritt: erstes Programm mit dem Mega (Lauflicht mit 16 LEDs)
- Verbinde den Mega per USB-B-Kabel mit dem Computer; hat dein Klon einen CH340-USB-Chip, installiere zuerst den Treiber.
- Wähle in der Arduino IDE unter Werkzeuge > Board den Eintrag Arduino Mega or Mega 2560; als Prozessor bleibt ATmega2560 (Mega 2560) eingestellt.
- Wähle unter Werkzeuge > Port den Port des Boards (unter Windows z. B. COM3, unter macOS ein Name, der mit /dev/cu.usbmodem oder /dev/cu.wchusbserial beginnt).
- Schließe 16 LEDs jeweils mit einem 220-Ω-Widerstand an die Pins 22–37 an und führe die kurzen Beinchen (Kathode) an die GND-Leitung. Bei einer roten LED fließen (5 − 2) / 220 ≈ 13,6 mA; für andere Farben nutzt du den LED-Widerstandsrechner.
- Lade den folgenden Code hoch; die LEDs laufen nacheinander blinkend durch. Da immer nur eine LED leuchtet, bleibt der Gesamtstrom unter 20 mA. Den Hin-und-her-Effekt findest du in Knight Rider und Lauflicht.
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}Wann brauchst du den Arduino Mega?
- Wenn die Pins nicht reichen: Ein 4x4-Keypad braucht allein 8 Pins, ein paralleles LCD 6 Pins; kommen noch Relais, Taster und Sensoren dazu, sind die 20 Pins des Uno schnell weg.
- Wenn du mehrere serielle Geräte hast: GPS, Bluetooth und GSM gleichzeitig abzuhören ist mit dem Uno fast unmöglich; beim Mega bekommt jedes seinen eigenen Hardwareport.
- Wenn der Speicher knapp wird: Meldet der Compiler zu wenig Speicher oder nutzt du TFT-Display, SD-Karte und Menücode zusammen, bringen 256 KB Flash und 8 KB RAM viel Luft; Details in Arduino Speicher reicht nicht.
- Bei vielen analogen Sensoren: Mit 16 Kanälen liest du Bodenfeuchte, Gas, Licht und Potentiometer ohne Multiplexer.
- Bei Robotern mit vielen Servos: Die Servo-Bibliothek unterstützt auf dem Mega bis zu 48 Servos (Uno: 12); geeignet für Roboterarme und Laufroboter.
- Wenn du den Mega nicht brauchst: Für WLAN, hohe Geschwindigkeit oder geringen Stromverbrauch ist der ESP32 sinnvoller (Arduino oder ESP32?); fehlen nur ein paar Ausgänge, ist es günstiger und kleiner, die Pins des Uno mit einem 74HC595-Schieberegister zu erweitern.
Arduino Mega im 3D-Drucker und RAMPS 1.4
Viele selbstgebaute 3D-Drucker und kleine CNC-Maschinen liefen jahrelang mit dem Arduino Mega und dem aufgesteckten RAMPS 1.4; dieses Duo ist bis heute die verbreitetste Druckerelektronik für Lernzwecke. Der Grund ist einfach: Eine Drucker-Firmware wie Marlin überschreitet mit Display- und SD-Karten-Unterstützung locker 100 KB; fünf Schrittmotortreiber (X, Y, Z und zwei Extruder), drei MOSFET-Ausgänge, sechs Endschalter, Thermistoren, LCD und SD-Karte brauchen zusammen Dutzende Pins. Bei RAMPS liegen die Step- und Richtungssignale der X-Achse an 54 und 55 (A0 und A1), die der Y-Achse an 60 und 61 (A6 und A7), die der Z-Achse an 46 und 48 und die des ersten Extruders an 26 und 28. Die Düsenheizung wird über Pin 10, das Heizbett über Pin 8 und der Lüfter über den PWM-Pin 9 gesteuert; die Thermistoren von Düse und Bett werden an A13 und A14 gelesen. Diese Belegung zeigt auch schön, wie effizient sich analoge Pins als digitale Ausgänge nutzen lassen. Zu Stromeinstellung und Mikroschritten der Treiber siehe A4988 Schrittmotortreiber.
Beispiel mit vielen Sensoren: Pins richtig planen
| Modul | Mega-Pin | Warum dieser Pin? |
|---|---|---|
| HC-05 Bluetooth | 18 (TX1), 19 (RX1) | Die Kommunikation mit dem Smartphone läuft über einen Hardwareport, es gehen keine Daten verloren |
| NEO-6M GPS | 16 (TX2), 17 (RX2) | Das GPS sendet jede Sekunde viele Zeilen und braucht einen eigenen Port |
| SIM800L GSM | 14 (TX3), 15 (RX3) | Dritter unabhängiger Port für SMS und Anrufe |
| I2C-LCD + BME280 | 20 (SDA), 21 (SCL) | Beide Geräte teilen sich mit unterschiedlichen Adressen dieselbe I2C-Leitung |
| RC522 RFID | 50, 51, 52, 53 + RST 49 | Hardware-SPI-Bus, als CS dient 53 |
| Bodenfeuchtesensor (4 Stück) | A0–A3 | Die ersten vier der 16 analogen Kanäle |
| MQ-2 Gassensor | A4 | Sensor mit analogem Ausgang |
| Durchflusssensor | 2 | Externer Interrupt-Pin, damit keine Impulse verloren gehen |
| 8-Kanal-Relaismodul | 22–29 | Einfache digitale Ausgänge ohne PWM |
| Lüfter (über MOSFET) | 6 | PWM zur Drehzahlregelung (Timer4) |
| Servo (Klappe) | 8 | Das Servosignal lässt sich an jedem digitalen Pin erzeugen; da Timer5 belegt wird, bleiben 44–46 nicht für PWM frei |
Häufige Fehler und Lösungen
| Symptom | Ursache | Lösung |
|---|---|---|
| Code lässt sich nicht hochladen, avrdude meldet Timeout | Noch Uno als Board gewählt, falscher Port oder ein Modul an Pin 0 und 1 | Wähle im Menü Werkzeuge den Mega 2560 und den richtigen Port, ziehe beim Upload die Kabel an 0 und 1 ab |
| I2C-Display oder -Sensor wird nicht gefunden | Kabel aus Uno-Gewohnheit an A4 und A5 gesteckt | SDA an 20, SCL an 21 anschließen |
| SPI-Modul auf dem Shield funktioniert nicht | Das Shield greift SPI an den Pins 11–13 ab | ICSP-Header oder Pins 50–52 verwenden |
| Nach dem Einbinden von Servos stoppt analogWrite an 44–46 | Die Servo-Bibliothek belegt Timer5 | PWM-Ausgang auf einen Pin zwischen 2 und 13 verlegen |
| SoftwareSerial empfängt keine Daten | Der gewählte RX-Pin unterstützt keine Pin-Change-Interrupts | Hardwareports Serial1, Serial2 oder Serial3 nutzen |
| Board wird heiß oder startet von selbst neu | Motor, Relaisspule oder viele LEDs direkt am Pin | Transistor, MOSFET oder Motortreiber nutzen, externe Versorgung ergänzen |
| Analogwerte schwanken ständig | Offener Eingang gelesen oder Übersprechen zwischen Kanälen | Nur Kanäle mit angeschlossenem Sensor lesen, jeden Kanal zweimal lesen und mitteln |
Der Arduino Mega ist für alle, die den Uno kennen, der bequemste Wachstumsschritt: derselbe Code, dieselben Bibliotheken, aber viel mehr Pins, Ports und Speicher. Für kleinere Projekte sind auch die Guides zur Arduino Uno Pinbelegung und Arduino Nano Pinbelegung nützlich. In der BlueGrays-App findest du pinintensive Projekte wie eine 4-stellige 7-Segment-Uhr, ein Codeschloss mit Keypad und LCD, einen Hindernis-Ausweich-Roboter und einen smarten Elektroniksafe, jeweils mit Schaltplan und Code, und kannst die Pinbelegung an deinen eigenen Mega anpassen.
Häufige Fragen
Wie viele Pins hat der Arduino Mega?
Der Arduino Mega 2560 hat 54 digitale Ein-/Ausgänge und 16 analoge Eingänge, also insgesamt 70 Signalpins. 15 der digitalen Pins liefern PWM, und die analogen Pins (A0–A15) lassen sich bei Bedarf auch als digitale Pins 54–69 nutzen. Dazu kommen Spannungs- und Steuerpins wie 5V, 3.3V, Vin, GND, AREF, IOREF und RESET.
Welche Pins beim Arduino Mega haben PWM?
Beim Mega liefern die Pins 2 bis 13 sowie 44, 45 und 46 PWM, insgesamt also 15 PWM-Ausgänge. Die Pins 4 und 13 laufen mit etwa 980 Hz, die übrigen mit etwa 490 Hz. Wird die Servo-Bibliothek benutzt, ist PWM an 44, 45 und 46 deaktiviert.
Wo liegen SDA und SCL beim Arduino Mega?
Beim Mega liegt der I2C-Bus an Pin 20 (SDA) und 21 (SCL); bei R3-Boards findest du dieselben Signale auch auf der Leiste neben AREF. A4 und A5 sind beim Mega im Gegensatz zum Uno normale analoge Eingänge, kein I2C. SPI liegt an den Pins 50 (MISO), 51 (MOSI), 52 (SCK) und 53 (SS) sowie auf dem ICSP-Header.
Läuft Uno-Code auch auf dem Mega?
Die meisten Uno-Sketches lassen sich ohne Änderung für den Mega kompilieren und laufen; du musst nur im Menü Werkzeuge das Board Mega 2560 wählen. Probleme entstehen meist bei der Hardware: I2C- und SPI-Pins liegen woanders, und Code, der direkt auf Timer- und Portregister zugreift, muss angepasst werden. Auch SoftwareSerial-Code läuft zuverlässiger, wenn du ihn auf die Hardware-Serialports des Mega umstellst.
Welche Interrupt-Pins hat der Arduino Mega?
Die externen Interrupt-Pins für attachInterrupt sind 2, 3, 18, 19, 20 und 21. Da 18 und 19 zu Serial1 und 20 und 21 zu I2C gehören, bleiben dir bei Nutzung dieser Schnittstellen nur 2 und 3. Verwende digitalPinToInterrupt(pin), statt die Interrupt-Nummer von Hand zu schreiben, um Fehler zu vermeiden.
Kann ich einen 3,3-V-Sensor an den Arduino Mega anschließen?
Ja, aber mit Vorsicht. Der Mega arbeitet mit 5 V Logik; einen 3,3-V-Ausgang liest er meist als HIGH, doch der 5-V-Ausgang des Mega kann einen 3,3-V-Eingang beschädigen. Nutze deshalb an den Eingangspins des Moduls einen Spannungsteiler oder Pegelwandler; bei I2C ist wegen der 5-V-Pull-ups auf dem Board ein bidirektionaler Pegelwandler die bessere Wahl.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED-Lauflicht
Lichter, die nacheinander aufleuchten, als würden sie laufen. Der Arduino schaltet sechs LEDs einzeln ein; jede leuchtet kurz auf und geht wieder aus, sodass das Licht von vorn nach hinten wandert…

Knight-Rider-Lauflicht
Das klassische Lauflicht, das hin und her wandert: Ein Lichtpunkt gleitet über sechs LEDs von einem Ende zum anderen und kommt wieder zurück.

HC-SR04 Abstandsmessung (serielle Anzeige)
Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

Digitaluhr mit 4-stelliger 7-Segment-Anzeige
Eine leuchtende vierstellige Digitaluhr, ähnlich wie die am Backofen. Das Uhrmodul DS1302 hält die Zeit, der Arduino liest jede Sekunde Stunden und Minuten aus und zeigt sie auf der vierstelligen…

Passwortschloss mit 4x4-Tastenfeld und LCD
Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

Roboter zur Hindernisvermeidung
Wie wäre es, ein intelligentes Fahrzeug zu bauen, das seinen Weg selbst findet? Der Obstacle Avoiding Robot scannt dank des Ultraschallsensors vor ihm ständig seine Umgebung.

Intelligenter elektronischer Safe
Ein kleiner Tresor für deine Wertsachen, der sich mit einem Code öffnet. Du tippst deinen vierstelligen Code auf dem Tastenfeld ein; stimmt er, öffnet der Servomotor das Schloss, das grüne Licht geht…

Servo-Kreis-Choreografie - Animierte Muster mit 32 Servos
Ein visuelles Animationsprojekt mit 32 kreisförmig angeordneten Servomotoren an einem Arduino Mega. Die Servos werden in einem einzigen Array verwaltet, hängen an den Pins 22–53 des Mega und zeigen vier Bewegungsabläufe: ein chaotisches Zittern in zufälligen Winkeln, einen synchronen Schwenk, eine um den Kreis laufende Welle und eine hin und her pendelnde Kompassnadel.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

