Raspberry Pi Workshop: Automatisiertes 4K-Zeitraffer-Kamera-Rig (libcamera, rpicam-still & FFmpeg)

Erstellt: 06.11.2026 Aktualisiert: 06.11.2026

Management Summary: Veraltete Raspberry-Pi-Kamera-Tutorials verweisen häufig noch auf raspistill und picamera – proprietäre Broadcom MMAL-Werkzeuge, die in 64-Bit Debian Bookworm vollständig entfernt wurden. Sie wurden durch den quelloffenen Linux-Kernel V4L2 + libcamera (rpicam-apps / Picamera2) Stack abgelöst. In diesem Workshop konstruieren wir eine autonome 4K-Zeitrafferkamera: Wir binden ein Raspberry Pi Camera Module 3 oder eine HQ Camera über den High-Speed MIPI CSI-2 Bus an, sperren Weißabgleich und Belichtungsverstärkung gegen störendes Bildflackern, triggern Aufnahmen über einen präzisen systemd-Timer und fügen Tausende Einzelbilder mit ffmpeg und temporalem Deflickering zu einem flüssigen 60 fps H.264 MP4-Video zusammen.

MIPI CSI-2 & libcamera-Stack

Direkte Ansteuerung von Sony IMX708 (Camera Module 3) oder IMX477 (HQ Camera) Sensoren über den modernen Linux Media Controller und die rpicam-still ISP-Pipeline.
Anti-Flacker-Belichtungsverriegelung

Vermeidung störender Helligkeits- und Farbsprünge durch manuelles Sperren von Auto-Weißabgleich (--awb), Autofokus (--lens-position) und Belichtungsmessung.
Präziser systemd-Timer

Deterministische Frame-Erfassung (OnCalendar / AccuracySec=1s) mit integrierter Speicherplatz-Notabschaltung, damit die Festplatte niemals zu 100 % vollläuft.
ffmpeg 4K 60fps-Rendering

Kompilieren sequenzieller JPEGs in ein universell kompatibles yuv420p H.264 MP4-Video mit deflicker-Filter und Zeitstempel-Einblendung.

1. Kamera-Architektur: MIPI CSI-2 & Die moderne `rpicam`-Pipeline

Im Gegensatz zu USB-Webcams, die das Videobild auf einem kleinen Sensorchip komprimieren und den USB-Bus belasten, überträgt ein MIPI CSI-2 (Camera Serial Interface) Flachbandkabel unkomprimierte 10-Bit/12-Bit Bayer-Rohdaten (RAW10/RAW12) mit bis zu 4 Gbit/s direkt in den Hardware-Image Signal Processor (ISP) des Raspberry Pi.

%%{init: {'flowchart': {'wrappingWidth': 600}}}%%
flowchart TB
    SENS["📷 Sony IMX708 / IMX477<br/>(MIPI CSI-2 Flachbandkabel)<br/>12 MP Raw Bayer Stream"]
    ISP["⚡ Broadcom / PiSP Hardware<br/>Demosaicing, Lens Shading,<br/>Denoise & AWB-Tuning"]
    LIB["🛠️ libcamera + rpicam-still<br/>(V4L2 Media Controller)<br/>Speichert High-Bitrate JPEG"]
    FFM["🎬 FFmpeg Render-Pipeline<br/>deflicker + scale=3840:-2<br/>-> 4K 60fps MP4"]

    SENS ==>|"CSI-2 Lanes"| ISP
    ISP ==>|"DMA-Buffer"| LIB
    LIB -->|"frame_00001.jpg"| FFM

Hardware-Sicherheit & Hinweis zu Pi 5 Anschlüssen

Fahre das System immer herunter (sudo poweroff) und trenne das USB-C-Netzteil, bevor du das CSI-Flachbandkabel verbindest oder löst – ein Hot-Plugging kann die 3,3V-Schiene der Kamera kurzschließen.
Der Raspberry Pi 5 besitzt kleinere 22-Pin (0,5 mm Rastermaß) MIPI-Anschlüsse mit der Beschriftung CAM/DISP 0 und CAM/DISP 1, während der Raspberry Pi 4 einen breiteren 15-Pin (1,0 mm Rastermaß) Anschluss nutzt. Verwende beim Anschluss an einen Pi 5 das offizielle 22-Pin auf 15-Pin Adapterkabel.

2. Sensorerkennung verifizieren & `rpicam-apps` + `ffmpeg` installieren

Unter Raspberry Pi OS (Debian 12 Bookworm) ist camera_auto_detect=1 in /boot/firmware/config.txt standardmäßig aktiv. Prüfe die Erkennung über den Linux-Kernel V4L2-Treiber und installiere die Rendering-Tools:

# Datei: /opt/timelapse/01_verify_camera_setup.sh
#!/usr/bin/env bash
set -euo pipefail

# 1. Moderne rpicam-apps (libcamera CLI), Picamera2 und FFmpeg installieren
sudo apt update && sudo apt install -y rpicam-apps python3-picamera2 ffmpeg

# 2. Benutzer Berechtigung für Video-/DMA-Heap-Gerätedateien gewähren
sudo usermod -aG video "$USER"

# 3. Angeschlossene MIPI CSI-2 Sensoren auflisten
rpicam-still --list-cameras

3. Zeitraffer-Mathematik & Anti-Flacker-Aufnahmeskript

Wende zur Planung von Aufnahmeintervall und Speicherbedarf die grundlegenden Zeitraffer-Formeln an:

Benötigte Bilder = Ziel-Videolänge (Sekunden) × Wiedergabe-Bildrate (fps)
Aufnahmeintervall (Sekunden) = Echtzeit-Dauer des Ereignisses (Sekunden) ÷ Benötigte Bilder

Ziel-Motiv	Reale Dauer	Aufnahmeintervall	Aufgenommene Bilder	Fertiges Video (`@ 30 fps`)	Ca. Speicherplatz (`4K JPEG`)
Schnelle Gewitterwolken / Sonnenuntergang	`1 Stunde` (`3.600 s`)	Alle `3 Sekunden`	`1.200 Bilder`	`40 Sekunden`	`~3,0 GB`
Tag-zu-Nacht Stadtskyline	`12 Stunden` (`43.200 s`)	Alle `15 Sekunden`	`2.880 Bilder`	`96 Sekunden`	`~7,2 GB`
3D-Druck / Baustelle	`24 Stunden` (`86.400 s`)	Alle `30 Sekunden`	`2.880 Bilder`	`96 Sekunden`	`~7,2 GB`
Pflanzenwachstum / Keimung	`14 Tage` (`1.209.600 s`)	Alle `10 Minuten`	`2.016 Bilder`	`67 Sekunden`	`~5,0 GB`

Produktives Aufnahmeskript (`/opt/timelapse/capture_frame.sh`)

Warum flackern Amateur-Zeitraffer oft unruhig? Wenn Auto-Weißabgleich (--awb auto) und kontinuierlicher Autofokus aktiv bleiben, passt die Kamera Farbtemperatur und Fokus bei jedem Vorbeiziehen einer Wolke neu an!

Unser Skript friert den Weißabgleich ein (--awb daylight), fixiert den manuellen Fokus auf Unendlich (--autofocus-mode manual --lens-position 0.0) und überprüft den freien Festplattenspeicher vor dem Schreiben:

# Datei: /opt/timelapse/capture_frame.sh
#!/usr/bin/env bash
set -euo pipefail

OUTPUT_DIR="/var/lib/timelapse/frames/$(date -u +%Y-%m-%d)"
MIN_FREE_MB=2048

mkdir -p "$OUTPUT_DIR"

# 1. Notabschaltung bei Speicherengpass: Abbruch bei weniger als 2 GB freiem Speicher
FREE_MB=$(df -BM --output=avail "$OUTPUT_DIR" | tail -n1 | tr -dc '0-9')
if (( FREE_MB < MIN_FREE_MB )); then
    echo "[KRITISCH] Freier Speicherplatz unter ${MIN_FREE_MB} MB (nur noch ${FREE_MB} MB). Aufnahme übersprungen!" >&2
    exit 1
fi

TIMESTAMP=$(date -u +"%Y%m%d_%H%M%S")
OUT_FILE="${OUTPUT_DIR}/frame_${TIMESTAMP}.jpg"

# 2. 4K-Frame (3840x2160) mit fixiertem Tageslicht-Weißabgleich und Fokus auf Unendlich erfassen
rpicam-still \
    --nopreview \
    --immediate \
    --width 3840 \
    --height 2160 \
    --quality 93 \
    --awb daylight \
    --metering centre \
    --autofocus-mode manual \
    --lens-position 0.0 \
    --denoise cdn_hq \
    --output "$OUT_FILE"

echo "[OK] Gespeichert: $OUT_FILE"

Skript ausführbar machen: sudo chmod +x /opt/timelapse/capture_frame.sh

4. Frame-Erfassung mit einem präzisen `systemd`-Timer automatisieren

Im Gegensatz zu cron (mit minimalem 1-Minuten-Intervall) unterstützt ein systemd-Timer sekundengenaue Zyklen (OnUnitActiveSec=15s mit AccuracySec=1s) und garantiert, dass sich zwei Aufnahmevorgänge niemals überlappen:

1. /etc/systemd/system/timelapse-capture.service2. /etc/systemd/system/timelapse-capture.timer

# Datei: /etc/systemd/system/timelapse-capture.service
[Unit]
Description=Capture Single 4K Time-Lapse Frame via rpicam-still

[Service]
Type=oneshot
User=nejat
SupplementaryGroups=video
ExecStart=/opt/timelapse/capture_frame.sh

# Datei: /etc/systemd/system/timelapse-capture.timer
[Unit]
Description=Precision 15-Second Timer for 4K Time-Lapse Rig

[Timer]
OnBootSec=30s
OnUnitActiveSec=15s
AccuracySec=1s
Persistent=true

[Install]
WantedBy=timers.target

Timer aktivieren und Status prüfen:

# Datei: /opt/timelapse/02_enable_timer.sh
sudo mkdir -p /var/lib/timelapse/frames /var/lib/timelapse/renders
sudo chown -R "$USER:$USER" /var/lib/timelapse /opt/timelapse
sudo systemctl daemon-reload
sudo systemctl enable --now timelapse-capture.timer
systemctl list-timers timelapse-capture.timer

5. Flackerfreies 4K `60fps` MP4-Video mit `ffmpeg` rendern

Sobald die Bildsequenz eines Tages komplett ist, verwenden wir ffmpeg mit -pattern_type glob, dem temporalen deflicker-Filter (der feine Helligkeitssprünge über ein gleitendes 7-Frame-Fenster glättet) und dem universellen -pix_fmt yuv420p:

# Datei: /opt/timelapse/render_daily_timelapse.sh
#!/usr/bin/env bash
set -euo pipefail

TARGET_DATE="${1:-$(date -u +%Y-%m-%d)}"
FRAME_DIR="/var/lib/timelapse/frames/${TARGET_DATE}"
OUTPUT_MP4="/var/lib/timelapse/renders/timelapse_${TARGET_DATE}_4K60.mp4"

if [[ ! -d "$FRAME_DIR" ]]; then
    echo "Fehler: Bildverzeichnis $FRAME_DIR existiert nicht." >&2
    exit 1
fi

FRAME_COUNT=$(find "$FRAME_DIR" -name "frame_*.jpg" | wc -l)
echo "Rendere ${FRAME_COUNT} Frames aus ${FRAME_DIR} nach ${OUTPUT_MP4}..."

ffmpeg -y \
    -framerate 60 \
    -pattern_type glob \
    -i "${FRAME_DIR}/frame_*.jpg" \
    -vf "deflicker=mode=pm:size=7,scale=3840:2160:flags=lanczos,format=yuv420p" \
    -c:v libx264 \
    -preset slow \
    -crf 18 \
    -movflags +faststart \
    "$OUTPUT_MP4"

echo "[OK] 4K60 MP4 erfolgreich gerendert: $OUTPUT_MP4 ($(du -h "$OUTPUT_MP4" | cut -f1))"

Weiterführende Workshops & Architektur

Entdecke weitere Hardware-Engineering-Workshops rund um den Raspberry Pi:

Raspberry Pi Hardware-Architektur

ARM64-SoC-Architektur, NVMe-SSD-Booten über PCIe Gen 3 und vcgencmd-Spannungs- und Temperaturdiagnose.

Zur Raspberry Pi Einführung
Workshop: I2C Mini-Wetterstation

Zeitrafferaufnahmen mit kontinuierlicher Erfassung von Temperatur, Taupunkt und barometrischem Luftdruck via Bosch BME280 kombinieren.

Zum Wetterstation-Lab
Workshop: IoT-Sensor-Webserver

Live-Telemetrie und Prometheus-Metriken über einen entkoppelten Gunicorn + Flask + SQLite WAL Stack bereitstellen.

Zum IoT-Webserver-Lab

Raspberry Pi Workshop: Automatisiertes 4K-Zeitraffer-Kamera-Rig (libcamera, rpicam-still & FFmpeg)

1. Kamera-Architektur: MIPI CSI-2 & Die moderne rpicam-Pipeline

2. Sensorerkennung verifizieren & rpicam-apps + ffmpeg installieren