Arduino Uno Pinbelegung: Digitale, PWM-, Analog- und Power-Pins

Die Arduino Uno Pinbelegung umfasst 32 Anschlüsse, die auf den schwarzen Buchsenleisten an den beiden langen Kanten der Platine aufgereiht sind: 14 digitale Ein-/Ausgänge (0–13), von denen 6 PWM ausgeben können (~3, 5, 6, 9, 10, 11), 6 analoge Eingänge (A0–A5) und die Versorgungspins, die das Board speisen oder andere Bauteile mit Strom versorgen (Vin, 5V, 3.3V, GND, IOREF, AREF, RESET). Jeder Pin hat eine Hauptaufgabe, viele aber noch eine zweite: A4 und A5 sind zugleich der I2C-Bus, 10–13 bilden den SPI-Bus, 2 und 3 sind Interrupt-Pins, und 0 und 1 sind die serielle Leitung, über die das Board mit deinem Computer spricht.

Den richtigen Pin zu wählen, ist der Unterschied zwischen einem Projekt, das auf Anhieb läuft, und stundenlanger Fehlersuche. Mit den Tabellen in diesem Artikel verstehst du leicht, warum PWM an den Pins 9 und 10 aufhört, sobald du einen Servo anschließt, warum sich der Sketch bei angeschlossenem Bluetooth-Modul nicht hochladen lässt oder warum ein paar LEDs das Board überlasten können. Am Ende findest du außerdem einen Test-Sketch, der alle Pin-Arten gleichzeitig ausprobiert, einen Beispiel-Pinplan und die Pin-Unterschiede zwischen Uno R3 und R4.

Arduino Uno Pinout-Diagramm: Wo liegt welcher Pin?

Leg das Board so vor dich, dass USB-Buchse und Hohlbuchse links liegen. Die beiden Leisten an der oberen Kante tragen die digitalen Pins; die Nummern steigen von rechts nach links, der Pin ganz rechts ist also 0 (RX) und der digitale Pin ganz links 13. An der unteren Kante trägt die linke Leiste die Versorgungspins und die rechte die analogen Eingänge. Die ~ (Tilde) neben einer Nummer zeigt, dass dieser Pin PWM ausgeben kann. Die 2×3-Gruppe aus Stiftleisten an der rechten Kante ist der ICSP-Anschluss.

Die große Pin-Tabelle: D0–D13 und A0–A5

Wie funktionieren die digitalen Pins (0–13)?

Jeder digitale Pin wird mit pinMode() als Eingang oder Ausgang festgelegt. Als Ausgang zieht digitalWrite(pin, HIGH) den Pin auf etwa 5 V, LOW auf 0 V. Als Eingang vergleicht digitalRead() die Spannung mit einer Schwelle: Läuft der ATmega328P mit 5 V, gilt alles über 3,0 V sicher als HIGH, alles unter 1,5 V sicher als LOW, dazwischen liegt ein undefinierter Bereich. Deshalb wird der Ausgang eines 3,3-V-Sensors am Uno meist als HIGH gelesen; der 5-V-Ausgang des Uno darf aber nicht direkt an den Eingang eines 3,3-V-Moduls, dazwischen gehört ein Pegelwandler.

Ein Eingang, der mit nichts verbunden ist, floatet und liest zufällig HIGH oder LOW, schon wenn du die Hand annäherst. Die Lösung: Zieh den Pin mit einem Widerstand auf einen festen Pegel. pinMode(pin, INPUT_PULLUP) schaltet den 20–50 kΩ großen Widerstand im Chip ein, und der Taster kommt zwischen Pin und GND. Details findest du in Taster am Arduino anschließen. An Pin 13 hängt die Onboard-LED L; beim originalen R3 wird sie über einen Operationsverstärker als Puffer angesteuert, daher macht der Pin als Eingang keine Probleme. Bei manchen Klonen sitzen LED und Vorwiderstand aber direkt am Pin und können das Lesen eines Tasters mit internem Pull-up stören.

PWM-Pins (~3, 5, 6, 9, 10, 11) und Timer

Der Uno kann keine echte analoge Spannung ausgeben; stattdessen liefern diese sechs Pins PWM, also ein Rechtecksignal, das sehr schnell ein- und ausschaltet. Mit analogWrite(pin, wert) legst du zwischen 0 und 255 fest, wie lange das Signal eingeschaltet bleibt: 0 ist ganz aus, 127 etwa die Hälfte, 255 ganz an. So steuerst du LED-Helligkeit, Motordrehzahl und Lüftergeschwindigkeit. Die sechs PWM-Pins hängen paarweise an drei Hardware-Timern, und genau das ist der Grund für Konflikte mit manchen Bibliotheken. Wie PWM funktioniert und wie man den Tastgrad berechnet, erklärt Was ist PWM?.

Analoge Pins (A0–A5) und AREF

Die analogen Pins messen eine Spannung zwischen 0 und 5 V mit 10 Bit Auflösung, und analogRead() liefert eine Zahl von 0 bis 1023. Ein Schritt entspricht etwa 4,9 mV; zur Umrechnung in Volt nutzt du Spannung = Wert × 5,0 / 1023, ein Messwert von 512 bedeutet also rund 2,5 V. Alle sechs Pins teilen sich nacheinander einen einzigen ADC, und eine Messung dauert etwa 100 µs, es sind also rund 10.000 Messungen pro Sekunde möglich. Für genaue Werte sollte der Ausgangswiderstand des Sensors 10 kΩ nicht überschreiten; ist er größer, können sich die Werte zweier direkt nacheinander gemessener Pins vermischen. Die erste Messung zu verwerfen und die zweite zu nehmen, löst das Problem. Um Spannungen über 5 V zu messen, wählst du passende Widerstände mit dem Spannungsteiler-Rechner.

Mit dem AREF-Pin änderst du die Obergrenze der Analogmessung. analogReference(DEFAULT) nutzt 5 V, analogReference(INTERNAL) die interne 1,1-V-Referenz des Chips und analogReference(EXTERNAL) die Spannung, die du an AREF anlegst (0–5 V), als Obergrenze. Bei einem Sensor mit 0–1 V Ausgang schrumpft ein Schritt mit der 1,1-V-Referenz auf etwa 1,1 mV, die Messung wird also etwa 4,5-mal feiner. Bauteile wie Potentiometer, LDR und Bodenfeuchtesensor kommen an diese Pins; die Details der Analog-Digital-Wandlung stehen im ADC-Artikel, ein Praxisbeispiel im Artikel über das Potentiometer.

Versorgungspins: Vin, 5V, 3.3V, GND, IOREF und RESET

Der Uno lässt sich auf drei Wegen versorgen. Über USB bekommt das Board 5 V direkt vom Computer, und eine rückstellbare 500-mA-Sicherung schützt den Port des Computers. Speist du 7–12 V über die Hohlbuchse oder Vin ein, senkt der Spannungsregler auf dem Board sie auf 5 V; steckt beides, schaltet das Board automatisch auf die externe Versorgung um, sobald Vin etwa 6,6 V übersteigt. Da der Regler die überschüssige Spannung in Wärme umwandelt, wird er bei 12 V Eingang schnell heiß, wenn du ein paar hundert mA aus dem 5V-Pin ziehst. Am gesündesten ist es, Lasten wie Servos, Motoren und LED-Streifen aus einer eigenen Quelle zu versorgen und nur die GNDs zu verbinden. Für Akkuwahl und Laufzeit hilft der Akkulaufzeit-Rechner, alle Versorgungsarten beschreibt Arduino richtig mit Strom versorgen.

Warum sollten Pin 0 und 1 frei bleiben?

Die Pins 0 (RX) und 1 (TX) sind die einzige serielle Hardware-Schnittstelle des ATmega328P und auf dem Board über 1-kΩ-Widerstände mit dem USB-Seriell-Wandler (ATmega16U2) verbunden. Dein Computer nutzt diese beiden Pins beim Hochladen und wenn du Text an den seriellen Monitor schickst. Hängt der TX-Ausgang eines Bluetooth-Moduls oder ein anderes Signal an Pin 0, kämpfen zwei Quellen um dieselbe Leitung, und der Upload bricht mit avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x00 ab. Außerdem wechselt Pin 1 bei jedem Serial.print() schnell den Zustand; eine dort angeschlossene LED oder ein Relais schaltet dann zufällig.

Lass 0 und 1 deshalb frei, bis dir die anderen Pins ausgehen. Willst du ein serielles Modul wie HC-05, GPS oder MP3-Player anschließen, erzeugt die Bibliothek SoftwareSerial eine zweite serielle Schnittstelle an zwei anderen Pins. Der folgende Sketch verbindet das Modul mit den Pins 8 (RX) und 7 (TX); er leitet alles, was du im seriellen Monitor tippst, an das Modul weiter und alles vom Modul an den Computer. Bei Modulen mit 3,3-V-Logik wie dem HC-05 verbindest du den TX-Ausgang des Uno (Pin 7) über einen Spannungsteiler mit dem RX-Pin des Moduls. Alle Lösungen für Upload-Probleme stehen in Arduino Sketch lässt sich nicht hochladen, die Grundlagen der seriellen Kommunikation in UART: serielle Kommunikation.

1#include <SoftwareSerial.h>
2
3SoftwareSerial moduleSerial(8, 7);   // RX = 8, TX = 7; 0 ve 1 boş kalır / 0 and 1 stay free
4
5void setup() {
6  Serial.begin(9600);                // USB üzerinden bilgisayar / computer over USB
7  moduleSerial.begin(9600);          // HC-05 veri modu hızı / HC-05 data mode baud rate
8  Serial.println(F("Seri kopru hazir / Serial bridge ready"));
9}
10
11void loop() {
12  if (moduleSerial.available()) {
13    Serial.write(moduleSerial.read());   // modülden bilgisayara / module to computer
14  }
15  if (Serial.available()) {
16    moduleSerial.write(Serial.read());   // bilgisayardan modüle / computer to module
17  }
18}

Kommunikations-Pins: I2C (A4/A5), SPI (10–13) und Interrupt-Pins (2, 3)

Mit I2C verbindest du Dutzende Geräte über nur zwei Leitungen (SDA und SCL) am selben Bus; LCDs, OLEDs, RTC-Uhrmodule und Sensoren wie der BME280 nutzen diesen Weg. Beim Uno ist SDA = A4 und SCL = A5. Die SDA- und SCL-Pins neben AREF auf R3-Boards sind kein eigener Bus, sondern intern mit A4 und A5 verbunden; solange I2C läuft, kannst du A4 und A5 also nicht für Analogmessungen nutzen. Die Wire-Bibliothek arbeitet standardmäßig mit 100 kHz und schafft mit Wire.setClock(400000) 400 kHz. Adressen, Pull-up-Widerstände und einen I2C-Scanner findest du in Was ist I2C?, ein Praxisbeispiel in I2C-LCD-Display verwenden.

SPI ist schneller, braucht aber mehr Leitungen: MOSI = 11, MISO = 12, SCK = 13 und SS (CS) = 10. SD-Kartenmodule, RFID-Leser und TFT-Displays nutzen SPI. Mehrere Geräte können sich den Bus teilen: MOSI, MISO und SCK sind gemeinsam, jedes Gerät bekommt einen eigenen CS-Pin. Ein wichtiges Detail: Im SPI-Master-Modus muss Pin 10 ein Ausgang bleiben. Machst du Pin 10 zum Eingang und er wird auf LOW gezogen, schaltet sich der ATmega328P in den Slave-Modus, und SPI steht still. MISO, MOSI und SCK liegen auch am ICSP-Anschluss, manche Shields greifen SPI dort ab. Mehr dazu in Was ist SPI? und RFID RC522.

Ein Interrupt lässt dich eine Änderung an einem Pin sofort erfassen, egal was loop() gerade tut. Externe Interrupts gibt es beim Uno nur an den Pins 2 (INT0) und 3 (INT1): Du schreibst attachInterrupt(digitalPinToInterrupt(2), funktion, FALLING), als Auslöser sind LOW, CHANGE, RISING oder FALLING möglich. Encoder, Drehzahlsensoren, Durchflusssensoren und Taster, die nie verpasst werden dürfen, gehören an diese Pins. Die übrigen Pins haben zwar „Pin Change Interrupts“ (PCINT), doch alle Pins eines Ports teilen sich eine Interrupt-Funktion, und dein Code muss selbst herausfinden, welcher Pin sich geändert hat. Regeln und Beispiele stehen in Arduino Interrupts.

Beim Umstieg auf ESP32 oder Pico ist die Spannung der größte Unterschied: Beide Boards laufen mit 3,3 V, und ihre Pins sind nicht 5-V-tolerant. Für 5-V-Module, die du am Uno direkt anschließt, brauchst du deshalb unter Umständen einen Pegelwandler. Dafür bieten diese Boards Interrupts und PWM an fast jedem Pin, und I2C- und SPI-Bus lassen sich auf andere Pins legen. Zum Vergleich der Boards lies Arduino Uno oder ESP32, Pinbelegungen zeigt dir das Pinout-Tool; die Boards selbst stellen Was ist der ESP32? und Was ist der Raspberry Pi Pico? vor.

Wofür ist der ICSP-Anschluss da?

ICSP (In-Circuit Serial Programming) ist ein 2×3-Anschluss, über den der Mikrocontroller ohne USB und Bootloader direkt über die SPI-Leitungen programmiert wird. Der ICSP an der rechten Kante gehört zum ATmega328P, der kleine ICSP1 neben der USB-Buchse zum USB-Seriell-Chip (ATmega16U2). Im Alltag brauchst du ihn nicht; ICSP kommt ins Spiel, wenn der Bootloader beschädigt ist, wenn du einen Bootloader auf einen neuen ATmega328P brennst oder Code mit einem Programmer wie dem USBasp hochlädst. Machst du einen zweiten Uno mit dem Beispiel ArduinoISP zum Programmer, gehen dessen Pins 10, 11, 12 und 13 an RESET, MOSI, MISO und SCK des Zielboards; ein 10-µF-Kondensator zwischen RESET und GND am Programmer-Uno verhindert dessen automatischen Reset. Ob dein Board Schaden genommen hat, findest du mit Ist mein Arduino kaputt? heraus.

20 mA pro Pin, 200 mA insgesamt: Stromgrenzen

Ein Uno-Pin wird sicher mit höchstens 20 mA betrieben. Die 40 mA im Datenblatt des ATmega328P sind das absolute Maximum, also der Wert, oberhalb dessen der Chip dauerhaft beschädigt werden kann, kein Betriebswert. Der Gesamtstrom über die VCC- und GND-Pins des Chips darf 200 mA nicht überschreiten. Das Datenblatt teilt die Pins zudem in Gruppen: Beim Liefern von Strom (HIGH) sollten D0–D4 zusammen mit A0–A5 sowie D5–D13 untereinander jeweils unter 150 mA bleiben, beim Aufnehmen von Strom (LOW) die Gruppen D0–D4, D5–D13 und A0–A5 jeweils unter 100 mA. Betreibst du eine rote LED mit 220-Ω-Vorwiderstand an 5 V, fließen (5 − 2) / 220 ≈ 13,6 mA. Zehn gleichzeitig leuchtende LEDs ergeben 136 mA; das liegt unter 200 mA, sitzen aber alle in derselben Gruppe, ist die 150-mA-Gruppengrenze fast erreicht. Leuchten die LEDs bei LOW (Vorwiderstand von 5V zum Pin) und hängen die meisten in derselben Gruppe, ist die 100-mA-Grenze überschritten. Verteile die LEDs auf die Gruppen oder erhöhe den Widerstand auf 330–470 Ω. Den passenden Widerstand findest du mit dem LED-Vorwiderstand-Rechner oder dem Rechner für das Ohmsche Gesetz.

• Motoren: Schon ein kleiner Gleichstrommotor zieht Hunderte mA und erzeugt Spannungsspitzen; nutze einen Motortreiber wie den L298N oder einen Transistor.
• Relaisspulen: Eine 5-V-Relaisspule zieht etwa 70–90 mA; nimm ein Relaismodul mit Transistor und Diode.
• Servomotoren: Die Signalleitung darf an einen Pin, die Versorgung des Servos sollte aber aus einer eigenen Quelle kommen, nicht vom 5V-Pin; Details im Artikel über den Servomotor.
• LED-Streifen und Hochleistungs-LEDs: 12-V-Streifen und 1-W-LEDs brauchen einen Logic-Level-MOSFET.
• Kurzschluss: Einen Ausgang im Zustand HIGH direkt mit GND zu verbinden, zieht weit mehr als 40 mA aus dem Pin und zerstört ihn dauerhaft.

Test-Sketch: digitale, PWM-, analoge und Interrupt-Pins gemeinsam ausprobieren

1. Schließ an Pin 9 eine LED mit 220-Ω-Vorwiderstand an: langes Bein zum Widerstand, kurzes Bein an GND.
2. Verbinde die beiden äußeren Anschlüsse eines Potentiometers mit 5V und GND, den mittleren mit A0.
3. Schließ einen Taster zwischen Pin 2 und GND an; ein eigener Widerstand ist nicht nötig, weil der interne Pull-up genutzt wird.
4. Lade den Sketch hoch, öffne den seriellen Monitor und stell 9600 Baud ein.
5. Dreh am Potentiometer: Die Helligkeit der LED an Pin 9 ändert sich, die Onboard-LED L (Pin 13) leuchtet, sobald die Spannung 2,5 V übersteigt, und mit jedem Tastendruck steigt der Zähler um eins.

1const byte BUTTON_PIN = 2;    // kesme pini INT0 / interrupt pin INT0
2const byte PWM_LED    = 9;    // ~9: PWM çıkışı / PWM output
3const byte STATUS_LED = 13;   // kart üzerindeki L LED'i / onboard L LED
4const byte POT_PIN    = A0;   // analog giriş / analog input
5
6volatile unsigned int pressCount = 0;   // ISR içinde değişir / changed inside the ISR
7
8void onButton() {
9  static unsigned long lastPressMs = 0;
10  unsigned long now = millis();
11  if (now - lastPressMs > 50) {         // 50 ms sıçrama filtresi / 50 ms debounce
12    pressCount++;
13    lastPressMs = now;
14  }
15}
16
17void setup() {
18  Serial.begin(9600);                   // 0 ve 1 numaralı pinleri kullanır / uses pins 0 and 1
19  pinMode(STATUS_LED, OUTPUT);
20  pinMode(PWM_LED, OUTPUT);
21  pinMode(BUTTON_PIN, INPUT_PULLUP);    // dahili pull-up direnci / internal pull-up resistor
22  attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), onButton, FALLING);
23}
24
25void loop() {
26  int raw = analogRead(POT_PIN);        // 0-1023 arası ham değer / raw value 0-1023
27  float volts = raw * 5.0 / 1023.0;     // volta çevir / convert to volts
28  analogWrite(PWM_LED, raw / 4);        // 0-255 arası PWM / PWM from 0 to 255
29  digitalWrite(STATUS_LED, volts > 2.5 ? HIGH : LOW);   // 2,5 V eşiği / 2.5 V threshold
30
31  noInterrupts();                       // sayacı güvenle kopyala / copy the counter safely
32  unsigned int presses = pressCount;
33  interrupts();
34
35  Serial.print(F("A0: "));
36  Serial.print(raw);
37  Serial.print(F("  V: "));
38  Serial.print(volts, 2);
39  Serial.print(F("  Buton / Button: "));
40  Serial.println(presses);
41  delay(200);
42}

Der Sketch nutzt vier Pin-Arten des Uno gleichzeitig. analogRead(A0) liest einen Wert von 0 bis 1023, raw / 4 skaliert ihn auf den Bereich 0–255, den analogWrite() erwartet. Damit Kontaktprellen nicht mitgezählt wird, ignoriert die Interrupt-Funktion Signale, die weniger als 50 ms nach dem letzten Druck eintreffen. Der im Interrupt veränderte Zähler ist als volatile deklariert, und loop() kopiert ihn, während Interrupts kurz gesperrt sind: Der 8-Bit-Uno liest eine 16-Bit-Zahl in zwei Schritten, und ein Interrupt dazwischen könnte einen falschen Wert liefern. Die Pins 0 und 1 dienen nur Serial, deshalb hängt dort nichts anderes.

Beispiel-Pinplan: Welches Bauteil an welchen Pin?

Pins in einem Projekt mit vielen Bauteilen wahllos zu verteilen, führt zu Konflikten. Setz zuerst die Bauteile mit Sonderfunktion (I2C, SPI, Interrupt, PWM) auf ihre Pins und verteile dann die einfachen digitalen Aufgaben auf die freien Pins. Unten siehst du einen Beispielplan für ein RFID-Türschloss: RC522-Leser, I2C-LCD, Servo, Buzzer, Taster und zwei LEDs. Da Servo und tone() gemeinsam genutzt werden, fällt PWM an 3, 9, 10 und 11 ohnehin weg; der Plan berücksichtigt das.

Pin-Unterschiede zwischen Arduino Uno R3 und R4

Kurz gesagt: Beim R4 bleiben Pinnummern und Funktionen gleich (PWM ~3, 5, 6, 9, 10, 11; I2C A4/A5; SPI 10–13; Interrupts 2, 3), aber der Strom pro Pin sinkt auf 8 mA. Eine LED, die du am R3 direkt am Pin betrieben hast, braucht am R4 einen größeren Vorwiderstand (zum Beispiel 1 kΩ für etwa 3 mA) oder einen Transistor. Den ausführlichen Vergleich findest du in Arduino Uno R4. Suchst du ein kleineres Board, helfen dir Arduino Nano Pinbelegung und Welchen Arduino soll ich kaufen? weiter.

Häufige Fehler und Lösungen

Wenn du die Pins des Arduino Uno kennst, musst du nicht auswendig lernen, wohin welches Bauteil gehört; du schaust, was das Bauteil braucht, und wählst den richtigen Pin selbst. Willst du die Grundlagen wiederholen, beginne mit Was ist Arduino?. In der BlueGrays-App findest du Projekte wie LED schalten, Taster lesen, Lichtmessung mit LDR, RGB-LED mit PWM, I2C-LCD, RFID und zwei Arduinos, die über eine serielle Leitung kommunizieren, jeweils Schritt für Schritt mit Schaltplänen, die zeigen, warum welcher Pin gewählt wurde, und mit fertigem Code.