Bauteile · 9 Min. Lesezeit

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.

Arduino Mega 2560 Board mit Pin-Leisten
Arduino Mega 2560: ATmega2560-Prozessor, 54 digitale und 16 analoge Pins; die doppelreihige Leiste am rechten Rand trägt die digitalen Pins 22–53.

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.

MerkmalWert
MikrocontrollerATmega2560 (8-Bit-AVR)
Taktfrequenz16 MHz
Flash-Speicher256 KB (8 KB davon Bootloader)
SRAM8 KB
EEPROM4 KB
Betriebsspannung5 V
Eingangsspannung (Buchse / Vin)7–12 V empfohlen, 6–20 V Grenze
Digitale E/A54 (15 davon PWM)
Analoge Eingänge16 (A0–A15, 10 Bit)
Hardware-Serialports4 (Serial, Serial1, Serial2, Serial3)
Externe Interrupt-Pins6
Strom pro Pin20 mA empfohlen, 40 mA absolute Grenze
Strom am 3.3V-Pinmaximal 50 mA
Abmessungen101,5 × 53,3 mm

Arduino Mega und Uno im Vergleich

MerkmalArduino Uno R3Arduino Mega 2560
MikrocontrollerATmega328PATmega2560
Taktfrequenz16 MHz16 MHz
Digitale Pins1454
PWM-Pins6 (3, 5, 6, 9, 10, 11)15 (2–13, 44, 45, 46)
Analoge Eingänge6 (A0–A5)16 (A0–A15)
Hardware-Serialports14
Externe Interrupt-Pins2 (2, 3)6 (2, 3, 18, 19, 20, 21)
Flash / SRAM / EEPROM32 KB / 2 KB / 1 KB256 KB / 8 KB / 4 KB
I2C-PinsA4 (SDA), A5 (SCL)20 (SDA), 21 (SCL)
SPI-Pins10, 11, 12, 1353, 51, 50, 52
Abmessungen68,6 × 53,4 mm101,5 × 53,3 mm

Arduino Mega Pinout: alle Pin-Gruppen

Pin-GruppePin-NummernFunktion und Hinweise
Gemeinsame digitale Pins mit dem Uno0–130 (RX0) und 1 (TX0) sind die USB-Serialleitung; an 13 hängt die interne LED
Zusätzliche Serial-Pins14–1914 TX3, 15 RX3, 16 TX2, 17 RX2, 18 TX1, 19 RX1
I2C20 (SDA), 21 (SCL)Wire-Bibliothek; auf dem Board sind 10-kΩ-Pull-ups nach 5 V vorhanden
Doppelreihige digitale Leiste22–53Allgemeine Ein-/Ausgänge; außer 44, 45 und 46 ohne PWM
PWM2–13, 44, 45, 46Nutzung mit analogWrite(pin, 0–255)
SPI50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS)Dieselben Signale liegen auch auf dem ICSP-Header
Analoge EingängeA0–A15 (digital 54–69)Auslesen mit analogRead, auch als digitale Pins nutzbar
Spannung und Steuerung5V, 3.3V, Vin, GND, IOREF, AREF, RESETAREF ist der externe analoge Referenzeingang; bei LOW an RESET startet das Board neu
Jeder Ein-/Ausgang des Mega verträgt maximal 40 mA; bleib zur Sicherheit unter 20 mA. Der Prozessor kann über alle Pins zusammen nur etwa 200 mA liefern. Nur weil es 54 Pins gibt, solltest du nicht 54 LEDs gleichzeitig direkt treiben oder Motoren und Relaisspulen direkt anschließen – das zerstört den Prozessor. Nutze für solche Lasten einen Transistor oder einen Treiber. Außerdem hängen die Pins 0 und 1 an der USB-Serialleitung; ist dort ein Modul angeschlossen, lässt sich der Code unter Umständen nicht hochladen.

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.

TimerPWM-PinsStandardfrequenzKonflikt mit
Timer0 (8 Bit)4, 13~980 Hzmillis() und delay()
Timer1 (16 Bit)11, 12~490 HzServo-Bibliothek (13.–24. Servo)
Timer2 (8 Bit)9, 10~490 HzFunktion tone()
Timer3 (16 Bit)2, 3, 5~490 HzServo-Bibliothek (25.–36. Servo)
Timer4 (16 Bit)6, 7, 8~490 HzServo-Bibliothek (37.–48. Servo)
Timer5 (16 Bit)44, 45, 46~490 HzServo-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.

PortTX-PinRX-PinTypische Verwendung
Serial10USB und Serieller Monitor
Serial11819HC-05 Bluetooth-Modul
Serial21617NEO-6M GPS-Modul
Serial31415SIM800L GSM oder Fingerabdrucksensor
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}

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.

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

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}

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

SignalArduino UnoArduino MegaESP32Raspberry Pi Pico
I2C SDAA420GPIO 21GP4
I2C SCLA521GPIO 22GP5
SPI MISO1250GPIO 19GP16
SPI MOSI1151GPIO 23GP19
SPI SCK1352GPIO 18GP18
SPI SS / CS1053GPIO 5GP17
Zusätzlicher Serialport TX / RXKeiner (SoftwareSerial)18 / 19 (Serial1)GPIO 17 / 16 (Serial2)GP0 / GP1 (UART0)
Logikpegel5 V5 V3,3 V3,3 V

Schritt für Schritt: erstes Programm mit dem Mega (Lauflicht mit 16 LEDs)

  1. Verbinde den Mega per USB-B-Kabel mit dem Computer; hat dein Klon einen CH340-USB-Chip, installiere zuerst den Treiber.
  2. Wähle in der Arduino IDE unter Werkzeuge > Board den Eintrag Arduino Mega or Mega 2560; als Prozessor bleibt ATmega2560 (Mega 2560) eingestellt.
  3. 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).
  4. 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.
  5. 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.
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}

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

ModulMega-PinWarum dieser Pin?
HC-05 Bluetooth18 (TX1), 19 (RX1)Die Kommunikation mit dem Smartphone läuft über einen Hardwareport, es gehen keine Daten verloren
NEO-6M GPS16 (TX2), 17 (RX2)Das GPS sendet jede Sekunde viele Zeilen und braucht einen eigenen Port
SIM800L GSM14 (TX3), 15 (RX3)Dritter unabhängiger Port für SMS und Anrufe
I2C-LCD + BME28020 (SDA), 21 (SCL)Beide Geräte teilen sich mit unterschiedlichen Adressen dieselbe I2C-Leitung
RC522 RFID50, 51, 52, 53 + RST 49Hardware-SPI-Bus, als CS dient 53
Bodenfeuchtesensor (4 Stück)A0–A3Die ersten vier der 16 analogen Kanäle
MQ-2 GassensorA4Sensor mit analogem Ausgang
Durchflusssensor2Externer Interrupt-Pin, damit keine Impulse verloren gehen
8-Kanal-Relaismodul22–29Einfache digitale Ausgänge ohne PWM
Lüfter (über MOSFET)6PWM zur Drehzahlregelung (Timer4)
Servo (Klappe)8Das 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

SymptomUrsacheLösung
Code lässt sich nicht hochladen, avrdude meldet TimeoutNoch Uno als Board gewählt, falscher Port oder ein Modul an Pin 0 und 1Wä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 gefundenKabel aus Uno-Gewohnheit an A4 und A5 gestecktSDA an 20, SCL an 21 anschließen
SPI-Modul auf dem Shield funktioniert nichtDas Shield greift SPI an den Pins 11–13 abICSP-Header oder Pins 50–52 verwenden
Nach dem Einbinden von Servos stoppt analogWrite an 44–46Die Servo-Bibliothek belegt Timer5PWM-Ausgang auf einen Pin zwischen 2 und 13 verlegen
SoftwareSerial empfängt keine DatenDer gewählte RX-Pin unterstützt keine Pin-Change-InterruptsHardwareports Serial1, Serial2 oder Serial3 nutzen
Board wird heiß oder startet von selbst neuMotor, Relaisspule oder viele LEDs direkt am PinTransistor, MOSFET oder Motortreiber nutzen, externe Versorgung ergänzen
Analogwerte schwanken ständigOffener Eingang gelesen oder Übersprechen zwischen KanälenNur Kanäle mit angeschlossenem Sensor lesen, jeden Kanal zweimal lesen und mitteln
Schreib den Pinplan vor Projektbeginn auf Papier: Setze zuerst die Pins mit Spezialaufgaben (Serialports, I2C, SPI, Interrupts und PWM) und verteile ganz zum Schluss die einfachen digitalen Pins 22–53. So musst du mitten im Projekt keine Kabel umstecken. Zum visuellen Vergleich der Pins nutzt du das Pinout-Tool, bei verrauschten Sensorwerten hilft Sensordaten filtern.

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.

Alle Projekte ansehen
LED-Lauflicht
AR-5Mittel

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…

4.6(87)
218
Knight-Rider-Lauflicht
AR-6Mittel

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.

4.8(107)
214
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

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…

4.6(50)
82
Digitaluhr mit 4-stelliger 7-Segment-Anzeige
AR-48Mittel
Premium

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…

4.8(56)
73
Passwortschloss mit 4x4-Tastenfeld und LCD
AR-64Fortgeschritten
Premium

Passwortschloss mit 4x4-Tastenfeld und LCD

Ein kleines elektronisches Türschloss, das niemanden ohne den richtigen Code hereinlässt.

4.8(59)
75
Roboter zur Hindernisvermeidung
AR-81Fortgeschritten
Premium

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.

5.0(38)
49
Intelligenter elektronischer Safe
AR-92Fortgeschritten
Premium

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…

4.7(42)
63
Servo-Kreis-Choreografie - Animierte Muster mit 32 Servos
AR-97Fortgeschritten
Premium

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.

4.5(40)
62