Zum Inhalt

Raspberry Pi GPIO-Grundlagen: 40-Pin-Header, Steckbrett-Elektronik & Python-Steuerung

Erstellt: 08.11.2026 Zuletzt aktualisiert: 08.11.2026

Management Summary: Die herausragende Stärke des Raspberry Pi im Vergleich zu einem herkömmlichen PC ist seine 40-polige GPIO-Steckleiste (General Purpose Input/Output). Sie schlägt die Brücke zwischen der digitalen Welt von Linux und der physischen Realität: Mit einfachen Python-Skripten lassen sich Leuchtdioden schalten, Taster abfragen, Sensordaten erfassen und Motoren steuern. Dieser Leitfaden erklärt den Aufbau der Pinleiste, löst die Verwirrung zwischen physischer und BCM-Zählweise auf, schärft das Bewusstsein für die strikte 3,3V-Grenze und führt Schritt für Schritt durch das erste eigene Elektronik-Projekt auf dem Steckbrett mit gpiozero.

  • Die Pinleisten-Architektur

    Die 40 Pins entschlüsseln: Feste Stromversorgungs-Pins (3,3V, 5V, GND) von programmierbaren GPIO-Signalleitungen unterscheiden.

  • BCM vs. Board-Nummerierung

    Verstehen, warum die physischen Pin-Nummern (1–40) nicht mit den BCM-Kanalnummern übereinstimmen und wie Software darauf zugreift.

  • Die lebenswichtige 3,3V-Regel

    Die Platine vor irreparabler Zerstörung bewahren: Begreifen, warum GPIOs keine 5V vertragen und wie man gefahrlos verdrahtet.

  • Erstes Elektronik-Labor

    Eine LED mit Vorwiderstand und einen Taster auf dem lötfreien Steckbrett aufbauen und mit 5 Zeilen Python zum Leben erwecken.

1. Aufbau der 40-poligen GPIO-Steckleiste

Alle modernen Raspberry-Pi-Modelle (Pi 5, Pi 4, Pi 3, Pi Zero 2 W) besitzen eine einheitliche, zweireihige 2×20 Pin-Steckleiste:

                  ┌──────────────────────┐
    +3.3V (DC) ── │ 01 (●)  (●) 02 │ ── +5.0V (DC)
 GPIO 2 (SDA1) ── │ 03 (●)  (●) 04 │ ── +5.0V (DC)
 GPIO 3 (SCL1) ── │ 05 (●)  (●) 06 │ ── Masse (GND)
GPIO 4 (GPCLK) ── │ 07 (●)  (●) 08 │ ── GPIO 14 (TXD)
   Masse (GND) ── │ 09 (●)  (●) 10 │ ── GPIO 15 (RXD)
       GPIO 17 ── │ 11 (●)  (●) 12 │ ── GPIO 18 (PWM0)
       GPIO 27 ── │ 13 (●)  (●) 14 │ ── Masse (GND)
       GPIO 22 ── │ 15 (●)  (●) 16 │ ── GPIO 23
    +3.3V (DC) ── │ 17 (●)  (●) 18 │ ── GPIO 24
GPIO 10 (MOSI) ── │ 19 (●)  (●) 20 │ ── Masse (GND)
 GPIO 9 (MISO) ── │ 21 (●)  (●) 22 │ ── GPIO 25
GPIO 11 (SCLK) ── │ 23 (●)  (●) 24 │ ── GPIO 8 (CE0)
   Masse (GND) ── │ 25 (●)  (●) 26 │ ── GPIO 7 (CE1)
         ID_SD ── │ 27 (●)  (●) 28 │ ── ID_SC
       GPIO 5  ── │ 29 (●)  (●) 30 │ ── Masse (GND)
       GPIO 6  ── │ 31 (●)  (●) 32 │ ── GPIO 12 (PWM0)
GPIO 13 (PWM1) ── │ 33 (●)  (●) 34 │ ── Masse (GND)
GPIO 19 (MISO) ── │ 35 (●)  (●) 36 │ ── GPIO 16
       GPIO 26 ── │ 37 (●)  (●) 38 │ ── GPIO 20 (MOSI)
   Masse (GND) ── │ 39 (●)  (●) 40 │ ── GPIO 21 (SCLK)
                  └──────────────────────┘

Die drei Pin-Kategorien im Überblick

  1. Feste Stromversorgungs-Pins (Spannungsausgänge):
  2. +3,3V (Pins 1 & 17): Liefert stabilisierte 3,3V Gleichspannung direkt von den platineneigenen Schaltreglern (maximal ca. 50 mA Gesamtlust über alle Pins).
  3. +5,0V (Pins 2 & 4): Ist direkt mit dem USB-C-Stromeingang verbunden. Dient zur Speisung von Lüftern, Relais-Platinen oder 5V-Sensoren.
  4. Masse (GND, 8 separate Pins: 6, 9, 14, 20, 25, 30, 34, 39): Das gemeinsame Bezugspotenzial (0V). Jeder elektrische Stromkreis muss zu einem dieser Pins zurückgeführt werden.
  5. Frei programmierbare GPIO-Pins (26 Pins):
  6. Per Software konfigurierbare Anschlüsse. Sie können als Ausgang (schaltet 3,3V HIGH oder 0V LOW) oder als Eingang (liest, ob von außen 3,3V oder 0V anliegen) definiert werden.
  7. Spezialisierte Hardware-Busse (Zweitfunktionen):
  8. Pins mit integrierter Hardware-Logik: I2C (GPIO 2/3), SPI (GPIO 7–11), UART/Seriell (GPIO 14/15) und Hardware-PWM (GPIO 12/13/18/19).

Physische vs. BCM-Pin-Zählweise entwirrt

Ein häufiger Stolperstein für Anfänger: Derselbe Steckplatz auf der Platine hat zwei unterschiedliche Bezeichnungen:

  • Physische Pin-Nummer (Board Numbering): Zählt schlicht die 40 Pins der Reihe nach von Pin 1 bis Pin 40 durch. Pin 1 befindet sich immer in der Ecke am MicroSD-Kartenleser.
  • BCM-Nummerierung (Broadcom GPIO): Bezeichnet den internen Silizium-Kanal des Prozessors (z. B. GPIO 17, GPIO 27).
Beispiel:
┌─────────────────────────────────────────────────────────────┐
│  Physischer Pin 11  ══════════>  BCM / Software: GPIO 17    │
│  Physischer Pin 13  ══════════>  BCM / Software: GPIO 27    │
│  Physischer Pin 06  ══════════>  Masse / Ground (GND)       │
└─────────────────────────────────────────────────────────────┘

Standard in der modernen Programmierung

Verwende im Python-Code und in Shell-Skripten grundsätzlich die BCM-Nummerierung. Die Standard-Bibliothek gpiozero nutzt standardmäßig BCM (z. B. steuert LED(17) den physischen Pin 11 an).

2. Die lebenswichtige 3,3V-Regel

Der folgenschwerste Anfängerfehler beim Experimentieren mit dem Raspberry Pi ist eine falsche Spannung:

%%{init: {'flowchart': {'wrappingWidth': 600, 'subGraphTitleMargin': {'top': 15, 'bottom': 15}}}}%%
flowchart TB
    SAFE["3,3V Sensor / Signal"] -->|"Gefahrlose Betriebsspannung"| PI["Raspberry Pi GPIO-Eingangsstufe"]
    KILL["5,0V Signal (Arduino / 5V Sensor)"] -->|"Überspannung!"| PI
    PI --> DEAD["Spannungsdurchschlag im Silizium!<br/>SoC- / RP1-Eingangsstufe brennt durch!<br/>Platine dauerhaft zerstört!"]

GPIO-Pins sind NICHT 5V-tolerant!

Im Gegensatz zu vielen klassischen Arduino-Boards sind die GPIOs des Raspberry Pi nicht gegen 5V Überspannung geschützt. Sie führen ohne Schutzdioden direkt in die hochempfindlichen Transistoren des Broadcom- bzw. RP1-Chips. Eine anliegende Spannung von mehr als 3,6V an einem GPIO-Pin führt zur sofortigen, irreparablen Zerstörung des Prozessors! - Verbinde niemals ein 5V-Sensorsignal direkt mit einem GPIO-Pin. - Verwende für 5V-Bauteile immer einen Pegelwandler (Logic Level Shifter 3,3V ↔ 5V) oder einen ohmschen Spannungsteiler.

3. Elektronik-Grundlagen: Das lötfreie Steckbrett & Ohmsches Gesetz

Um Schaltungen ohne Lötkolben aufzubauen, nutzen wir ein lötfreies Steckbrett (Breadboard):

      (+) ──────────────────────────────────────────  Spannungsschiene (+)
      (-) ──────────────────────────────────────────  Masseschiene (-)
          a   b   c   d   e       f   g   h   i   j
      01 [●]─[●]─[●]─[●]─[●]     [●]─[●]─[●]─[●]─[●] 01  <- Klemmleiste:
      02 [●]─[●]─[●]─[●]─[●]     [●]─[●]─[●]─[●]─[●] 02     Jeweils 5 Löcher
      03 [●]─[●]─[●]─[●]─[●]     [●]─[●]─[●]─[●]─[●] 03     horizontal verbunden!
  • Versorgungsschienen (+ und - am Rand): Sind über die gesamte Länge vertikal miteinander verbunden.
  • Klemmleisten in der Mitte (Reihen 1–30): Jeweils 5 Löcher (a–e und f–j) sind horizontal leitend verbunden. Der Mittelsteg isoliert die linke von der rechten Seite.

Warum jede LED zwingend einen Vorwiderstand braucht

Eine Leuchtdiode (LED) ist ein Halbleiterbauteil. Sobald ihre Schwellenspannung erreicht ist, sinkt ihr Innenwiderstand gegen Null. Schließt man eine LED ohne Widerstand an 3,3V an, schießt ein unkontrollierter Überstrom durch die Diode: Sie brennt im Bruchteil einer Sekunde durch und kann dabei den GPIO-Ausgangstreiber des Raspberry Pi beschädigen.

Die Dimensionierung des Widerstands erfolgt über das Ohmsche Gesetz:

Widerstand (R) = (Versorgungsspannung - LED-Flussspannung) ÷ Nennstrom

Für eine gewöhnliche rote LED: - Versorgungsspannung = 3,3V - LED-Flussspannung = ~1,8V - Empfohlener Betriebsstrom = 10 mA (0,01 A) - Rechnung: (3,3V - 1,8V) ÷ 0,01A = 150 Ω

Ein 220 Ω oder 330 Ω Widerstand ist die perfekte Wahl: Die LED leuchtet hell genug, während der Strom auf sichere ~5–7 mA begrenzt wird – weit unter dem Maximum von 16 mA pro Pin.

4. Hands-on Praxis: Die erste LED-Schaltung aufbauen

Benötigte Bauteile

  1. 1× Lötfreies Steckbrett (Breadboard)
  2. 1× Rote Standard-LED (5mm)
  3. 1× 330 Ω Widerstand (Farbringe: Orange-Orange-Braun-Gold)
  4. 2× Steckbrücken-Kabel (Female-to-Male)

Der Schaltplan

Raspberry Pi                  Steckbrett
┌──────────────┐              ┌───────────────────────────┐
│ Pin 11       │ ───────────> │ [Reihe 10] Widerstand     │
│ (GPIO 17)    │              │    │ (330 Ω)              │
│              │              │    v                      │
│              │              │ [Reihe 11] LED-Anode (+)  │
│              │              │    │ (Langes Bein)        │
│              │              │    v                      │
│              │              │ [Reihe 12] LED-Kathode (-)│
│ Pin 06 (GND) │ <─────────── │ (Kurzes Bein / flache Kante)
└──────────────┘              └───────────────────────────┘
  1. LED-Pole erkennen: Das längere Beinchen ist die Anode (+). Das kürzere Beinchen (sowie die abgeflachte Kante am Gehäuse) ist die Kathode (-).
  2. Verbinde Pin 11 (GPIO 17) mit einem Ende des 330 Ω Widerstands.
  3. Verbinde das andere Ende des Widerstands mit der Anode (+) der LED.
  4. Verbinde die Kathode (-) der LED mit Pin 6 (GND) des Raspberry Pi.

5. Die LED mit Python steuern (gpiozero)

Logge dich per SSH auf deinem Raspberry Pi ein und installiere die moderne Hardware-Steuerungsbibliothek:

Installation von gpiozero
sudo apt install -y python3-gpiozero python3-rpi.gpio

Erstelle ein neues Python-Skript:

Erstellen des Blink-Skripts
nano blink_led.py

Füge folgenden Quellcode ein:

blink_led.py
#!/usr/bin/env python3
"""Einfaches LED-Blinkskript mit gpiozero unter Raspberry Pi OS."""

import time
from gpiozero import LED

# Initialisiere BCM GPIO 17 (Physischer Pin 11)
led = LED(17)

print("LED-Blinker auf GPIO 17 gestartet... (Beenden mit Strg+C)")

try:
    while True:
        led.on()
        print("LED ist: AN  (:material-lightbulb-on:)")
        time.sleep(1.0)

        led.off()
        print("LED ist: AUS (:material-lightbulb-off:)")
        time.sleep(1.0)

except KeyboardInterrupt:
    print("\nProgramm beendet. LED wird sicher abgeschaltet.")
    led.off()

Starte das Skript:

Ausführen des Skripts
python3 blink_led.py

Die physische Leuchtdiode auf deinem Steckbrett blinkt nun im präzisen Sekundentakt!

6. Eingangssignale einlesen: Einen Taster anschließen

Das Gegenstück zum Schalten von Ausgängen ist das Einlesen von Eingängen, wie etwa einem einfachen Drucktaster.

%%{init: {'flowchart': {'wrappingWidth': 600, 'subGraphTitleMargin': {'top': 15, 'bottom': 15}}}}%%
flowchart TB
    NOISE["Schwebender Pin (Floating Pin)<br/>Wirkt wie eine Antenne: fängt HF-Störungen ein!<br/>Löst chaotisch zufällige 0- und 1-Zustände aus!"]
    PULLUP["Interner Pull-Up-Widerstand aktiv<br/>Zieht den Pin im Ruhezustand sanft auf 3,3V (HIGH / 1)"]
    BUTTON["Taster gedrückt: Verbindet Pin mit Masse<br/>Zieht das Potenzial stabil auf 0V (LOW / 0)"]

    NOISE -. "Wird gelöst durch" .-> PULLUP
    PULLUP -->|"Tastendruck"| BUTTON

Das Problem des „schwebenden Pins“ & Pull-Up-Widerstände

Wäre ein Eingangspin unbeschaltet, würde er wie eine Antenne wirken und durch minimale elektromagnetische Felder willkürlich zwischen 0 und 1 springen (Floating Pin).

Der Broadcom-SoC besitzt eingebaute, zuschaltbare Pull-Up-Widerstände (~50 kΩ). Sind diese aktiv, wird der Pin im Ruhezustand verlässlich auf 3,3V (HIGH) gezogen. Wird der Taster gedrückt, schließt er den Pin nach GND (LOW) kurz.

Taster-Schaltung & Ereignissteuerung

  1. Verbinde ein Bein eines Tasters mit Pin 13 (GPIO 27).
  2. Verbinde das gegenüberliegende Bein des Tasters mit Pin 14 (GND).
button_controlled_led.py
#!/usr/bin/env python3
"""Interaktive Tastersteuerung mit Hardware-Entprellung."""

from signal import pause
from gpiozero import LED, Button

led = LED(17)
# pull_up=True aktiviert den internen Pull-Up; bounce_time verhindert Prell-Fehler
button = Button(27, pull_up=True, bounce_time=0.05)

print("Bereit! Drücke den Taster, um die LED einzuschalten. (Strg+C zum Beenden)")

# Hardware-Events mit Aktionen verknüpfen
button.when_pressed = led.on
button.when_released = led.off

# Wartet ereignisgesteuert ohne CPU-Last im Leerlauf
pause()

Starte das Skript mit python3 button_controlled_led.py. Die LED leuchtet nun exakt so lange, wie du den Taster gedrückt hältst!

Nächste Schritte

Mit deinen ersten erfolgreichen Hardware-Schaltungen hast du den Grundstein gelegt. Im nächsten Kapitel rüsten wir dich gegen typische Fehler: Wir lernen, wie man Blinkcodes der grünen ACT-LED analysiert, SSH-Fehler löst und Unterspannungsprobleme behebt:

  • Nächstes Kapitel: Troubleshooting & LED-Fehlercodes

    Die Blinkcodes der grünen ACT-LED decodieren, "Connection Refused"-Fehler beheben und Unterspannung in der Firmware diagnostizieren.

    Zum Troubleshooting-Leitfaden