Raspberry Pi: Kamera einrichten und verwenden Prof. Jürgen Plate

Raspberry Pi: Kamera einrichten und verwenden

Seit Mai 2013 ist für den Raspberry Pi ein winziges, aber leistungsfähiges Kamera-Modul erhältlich. Anfang 2014 kan ein zweites Modell hinzu, das Nachtaufnahmen mit Infrarot-Beleuchtung erlaubt. Die technischen Daten sind in der folgenden Tabelle zusammengefasst:

Abmessungen	25 mm x 20 mm x 9 mm
Sensor	5 Megapixel mit Fixfokusobjektiv
Fotoauflösung	bis 2592 x 1944 Pixel
Videoauflösung	1920 x 1080 / 30 Frames 1280 x 720 / 60 Frames 640 x 480 / 60 oder 90 Frames
Kabellänge	ca. 150 mm
Versionen	Raspberry Pi Kamera Raspberry Pi Kamera Infrarot

Das Kamera-Modul wird in einem Antistatikbeutel mit vormontiertem Flachbandkabel geliefert. Der Anschluss der Kamera erfolgt über die 15-polige serielle MIPI-Schnittstelle (CSI - Camera Serial Interface) auf dem Raspberry Pi. Der Vorteil dieser Schnittstelle gegenüber USB besteht in der direkten Verbindung von Kamera-Modul und dem Broadcom BCM2835 (SoC). Die Infrarot-Version (NoIR) kann "im Dunklen sehen", zeigt aber bei Tageslicht eine leichte Farbverfälschung. Hier wird besser die "Normalversion" verwendet - oder man spendiert einen Infrarotfilter.

Da hier nur die wichtigsten Optionen und Möglichkeiten von Kamera und Software besprochen werden, sei jetzt schon auf die Dokumentation im Web verwiesen:

• Ausführliche Dokumentation als Open-Office-Dokument
• Python-Software-Paket
• Dokumentation dazu

Kamera anschliessen

Die CSI-Schnittstelle befindet sich zwischen der HDMI- und der Ethernet-Buchse. Um das 15-polige Flachbandkabel vom Kamera-Modul mit dem Board zu verbinden zieht man den oberen Teil des CSI-Steckverbinders etwas nach oben, steckt dann das Flachbandkabel mit der blauen Markierung zum Ethernet-Anschluss hin ein und drückt den Verschluss wieder nach unten. Nun ist der Kontakt hergestellt und das Kabel sitzt fest.

Nun muss noch der Kamera-Support in Raspbian aktiviert werden, was am Einfachsten über das Konfigurationstools raspi-config erledigt wird. Dort einfach die Kamera auf "Enable" setzen. Zum Abschluss muss der Raspberry Pi noch rebootet werden, damit die Kamera genutzt werden kann.

Wenn Sie die rote Aufnahme-LED stört, können Sie diese deaktivieren. Dazu ist ein neuer Eintrag in der Datei /boot/config.txt mit anschließendem Neustart notwendig:

disable_camera_led=1

sudo echo "5" > /sys/class/gpio/export
sudo echo "out" > /sys/class/gpio/gpio5/direction
sudo chmod 666 /sys/class/gpio/gpio5/value

echo "1" > /sys/class/gpio/gpio5/value

echo "0" > /sys/class/gpio/gpio5/value

Einzelbilder oder Bildsequenzen aufnehmen

Das Kamera-Modul wird über die beiden Programme raspistill (für Bilder) und raspivid (für Videos) angesprochen, die über zahlreiche Optionen verfügen. Auch eine Python-Bibliothek ist verfügbar. raspivid speichert Videos ausschließlich im H264-Format ab. Die Datei muss daher für die meisten Zwecke zuerst in ein gebräuchliches Format konvertieren werden (etwa mit gpac). Das Aufnehmen von Bildern ist recht einfach, wie die folgenden Beispiele zeigen:

# Aufnahme im JPG-Format (default)
raspistill -o image.jpg

# Aufnahme in anderen Formaten mit -e <Format>
# möglich sind: jpg, bmp, gif und png, z. B.
raspistill –e png -o image.png

# Aufnahme ohne Preview mit -n oder --nopreview
raspistill -n -o image.jpg

# Zeitverzögerte Aufnahme mit -t <Millisekunden>
# ACHTUNG: Default ist -t 5000, wenn es schnell gehen
# soll, dann -t 0 verwenden
raspistill  -t 2000 -o image.jpg

# Aufnahme in einer niedrigeren Auflösung mit -w und -h
# z. B. 640 x 480 pixel
raspistill  -w 640 -h 480 -o image.jpg

# Aufnahme in einer niedrigeren Qualität (Angabe in %-Werten)
raspistill -q 50 -o image.jpg

Zeitraffer-Aufnahmen

raspistill kann auch für Zeitraffer-Aufnahmen genutzt werden. Dazu muss beim Dateinamen ein Zähler festgelegt werden. Das geschieht durch einen Platzhalter, wie er bei der C-Funktion printf oder auch beim time-Kommando verwendet wird. Er hat die Form "%xxd", wobei für xx die Zahl der Dezimalstellen eingesetzt wird. Damit später beim Sortieren kein Mist entsteht, müssen alle Zahlenwerte gleich lang sein, denn sonst kommt "10" nach "1" und nicht die "2". Das wird durch eine führende "0" erreicht. Für beispielsweise vier Stellen schreibt man "%04d". Das ergibt dann insgesamt z. B. einen Dateiangabe wie "bild_%04d.jpg", die zu den Namen "bild_0001.jpg", "bild_0002.jpg" usw. führt.

Im Fall von Zeitrafferaufnahmen wird mit -t die gesamt-Aufnahmedauer angegeben und mit -tl die Wartezeit zwischen zwei Aufnahmen (alle erfolgen wieder in Millisekunden). Mit dem folgendem Befehl wird eine Stunde lang (-t 3600000) alle 10 Sekunden (-tl 10000) ein Bild aufgenommen:

raspistill -tl 10000 -t 3600000 -o camera/bild_%04d.jpg

Bei längeren Intervallen, z. B. nur eine Aufnahme pro Stunde verwendet man besser ein Shellscript, das per crontab aktiviert wird. Ein derartiges Script könnte etwa folgendermaßen aussehen:

#!/bin/bash

# Bilderverzeichnis
IMGDIR='/home/pi/images'

# Zeitstempel fuer Dateinamen generieren,
# %s: Sekunden seit 1970-01-01 00:00:00 UTC
TIME=$(date +%s)

# Dateinamen erzeugen
FILENAME=$IMGDIR/${TIME}.jpg

# Foto erstellen,  die Parameter -w und -h
# reduzieren die Dateigroesse
raspistill -o $FILENAME -w 1024 -h 768 -n

0,30 * * * * /home/pi/bin/zeitraffer.sh

Aus den Einzelbildern soll nun ein Video entstehen. Es ist schon möglich, das Video auch auf dem Raspberry Pi erstellen zu lassen. Jedoch ist es sinnvoll, bei diesem Schritt einen etwas schnelleren Linux-Rechner zu verwenden - sofern verfügbar. Denn die Aufgabe erfordert einiges an Prozessorleistung.

Eine Möglichkeit, ein Zeitraffer-Video zu bekommen, ist aus den vielen Einzelbildern mittels ffmpeg ein Video erzeugen:

ffmpeg -qscale 5 -r 4 -b 9600 -i camera/bild_%04d.jpg camera/filmchen.mp4

Eine weitere Möglichkeit bietet das Programm mencoder. Sie installieren dies und die entsprechenden Abhängigkeiten mit dem Kommando

sudo apt-get -y install mencoder

mencoder "mf://*.jpg" -mf type=jpg:fps=25 -ovc lavc -lav copts\
vcodec=mpeg4:mbd=2:trell:vbitrate=8000 -vf scale=1280:720 -oac\
copy -o filmchen.mp4

Hinter dem Parameter "fps=" steht die Anzahl der Bilder pro Sekunde (Frames per Second). Ein Fernseher liefert 25 Bilder pro Sekunde, deshalb steht oben dieser Wert. Je höher dieser Wert ist, desto mehr Bilder benötigen Sie für die gleiche Dauer des Films. "scale=" legt die Auflösung des Videos fest. Im Beispiel würde das Zeitraffervideo im HD-Format von 1280 x 720 Pixel vorliegen. Für Full HD müssten Sie "1920:1080" angeben. Die Qualität des Videos beeinflust die Zahl hinter "vbitrate=". Hier müssen Sie einfach etwas herumprobieren, bis der Film Ihren Ansprüchen genügt.

Mit mencoder kann man eigentlich alles machen, was im Bereich Videobearbeitung möglich ist, nicht nur Zeitrafferfile erzeugen. Einige Beispiele sind die Umwandlung eines Videoformates in ein anderes, das Rippen von DVDs und Video-CDs, das separate Rippen einer Audiospur, die Aufzeichnung von TV-Sendungen über eine TV-Karte, die Reskalierung von Filmen und vieles mehr. Einige Infos liefern folgende Webseiten:

• Allgemeiner Gebrauch von MEncoder
• Encodieren mit MEncoder
• Kurzanleitung zu MEncoder
• MEncoder Scripts

Videos aufnehmen

Für die Aufnahme von Videos wird raspivid verwendet. Das Programm kennt viele der Bildbarameter von raspistill, darunter -v, -w, -h, -o oder die Einstellungen von Kontrast, Helligkeit etc. Die Framerate kann mit -fpr (frames per second) eingestellt werden. Mit dem Parameter -t gibt man die Aufnahmezeit in Millisekunden an. Für eine beliebig lange Aufnahme (z. B. für einen Stream) wird der Wert auf 0 gesetzt (Default: 5 Sekunden). Das voreingestellte Videoformat ist 1080p (1920 x 1080 Pixel). Abgespeichert wird, wie erwähnt, im H264-Format. Die folgenden Beispiele erklären die wichtigsten Parameter:

# 10-Sekunden-Video in 1080p (1920 x 1080)
raspivid  -t 10000 -o video.h264

# 10-Sekunden-Video in 720p (1280 x 720)
raspivid -t 10000 -w 1280 -h 720 -o video.h264

# 10-Sekunden-Video mit individueller Bitrate (3 MBits/s)
raspivid -t 10000 -b 3000000 -o video.h264

# 10-Sekunden-Video mit individueller Framerate (10 Frames/Sekunde)
raspivid -t 10000 -f 10 -o video.h264

# 10-Sekunden-Videostream an stdout schicken (Dateiname ist "-")
raspivid -t 10000 -o -

Um das erzeugte H264-Video in das gebräuchlichere MPEG4-Format umzuwandeln, greifen wir auf das Zusatzpaket gpac zurück, das sich unter Raspbian mittels apt-get installieren lässt. Die Konvertierung erfolgt dann z. B. mit:

MP4Box -fps 30 -add video.h264 video.mp4

ffmpeg einrichten

Zum Codieren von AVI-Videos nach MP$ (H.264) wird gerne das Kommandozeilenprogramm ffmpeg verwendet, das leider beim RasPi nicht als fertiges Binary verfügbar ist (Stand: Anfang 2017). Deshalb muss man sich das Programm aus den Quelltexten selber bauen. Zuerst holen und compilieren Sie die H.264-Bibliothek und anschliessend ffmpeg. Für die Quelldateien etc. richten Sie am Besten ein eigenes Arbeitsverzeichnis ein (eventuell müssen Sie zuvor auch noch git per apt-get install git einrichten). Beachten Sie, dass nach dem '\' am Zeilenende nur noch das Newline folgen darf (keine Leerzeichen):

# Arbeitsverzeichnis einrichten
mkdir -p ~/Work

# Bibliothek bauen
cd ~/Work
git clone --depth 1 git://git.videolan.org/x264
cd x264
sudo ./configure \
    --host=arm-unknown-linux-gnueabi\
    --enable-static\
    --disable-opencl
make -j 4
sudo make install

# ffmpeg bauen
cd ~/Work
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
sudo ./configure \
    --arch=armel\
    --target-os=linux\
    --enable-gpl\
    --enable-libx264\
    --enable-nonfree
make -j 4
sudo make install

Streaming auf ein anderes System

Sie können, falls der RasPi ohne Grafik läuft, die Videos auch gleich auf einen anderen Linux-Rechner streamen. Dafür kommt das "Schweizer Taschenmesser des Internets", Netcat zum Einsatz. Netcat kann auch wieder mit apt-get installiert werden. Auf dem Raspberry wird der Video-Stream in Netcat (nc) geleitet, das für die Übertagung zum fernen Client mit der IP-Adresse 10.1.1.1 sorgt. Als Portnummer wird hier 4711 verwendet:

raspivid  -w 1280 -h 720 -t 0 -o - | nc 10.1.1.1 4711

Auf dem Linux-Client wird zusätzlich zu Netcat der Videoplayer MPlayer (oder VLC oder was auch immer) installiert, um den Stream direkt auf der grafischen Oberfläche anzuzeigen. Netcat läuft hier im Servermodus und wartet auf dem Port 4711 auf die Anfrage des RasPi (beim mplayer wird die Standardeingabe durch den Dateinamen "-" repräsentiert):

nc -l -p 4711 | mplayer -fps 31 -cache 1024 -

Programmierung

Im Prinzip reichen die beiden Kommandozeilentools vollkommen aus. Will man die Kamera jedoch in eigene Programme einbinden ist es manchmal lästig und nicht zuletzt fehleranfälliger, mit Systemaufrufen zu hantieren. So ist es erfreulich, dass im Python-Modul "Picamera" alle Optionen der Kamera vollständig implementiert. Die Links im ersten Abschnitt führen zur Software und zur Dokumentation. Zu installieren ist das Paket python-picamera. Danach steht dann die Library picamera zur Verfügung.

Die Library bietet nicht nur viele Konfigurationsmöglichkeiten (brightness, contrast, saturation, image effects, exposure modes etc.) sondern erlaubt auch das Kamerabild live anzuzeigen. Natürlich sind, wie auf der Kommandozeile auch Captures und Videos möglich. Ich gestehe auch, dass die Beispiele von der Dokumentation des Moduls inspiriert wurden.

camera.sharpness = 0
camera.contrast = 0
camera.brightness = 50
camera.saturation = 0
camera.ISO = 0
camera.video_stabilization = False
camera.exposure_compensation = 0
camera.exposure_mode = 'auto'
camera.meter_mode = 'average'
camera.awb_mode = 'auto'
camera.image_effect = 'none'
camera.color_effects = None
camera.rotation = 0
camera.hflip = False
camera.vflip = False
camera.crop = (0.0, 0.0, 1.0, 1.0)

Beim ersten Python-Programm handelt es sich um ein Pendant des Kommandozeilenaufrufs oben. Nach dem Importieren der benötigten Module wird ein Kamera-Objekt erzeugt, die Auflösung eingestellt und ein Bild geschossen:

import picamera
from time import sleep

cam = picamera.PiCamera()
cam.resolution = (640, 480)
cam.start_preview()
time.sleep(5)
cam.stop_preview()
cam.capture('bild.jpg')
cam.close()

Falls bei der Aufnahme auftretende Fehler abgefangen werden sollen (wenn beispielsweise die Kamera deaktiviert ist, kann man einen try-Block verwenden:

import picamera
from time import sleep

cam = picamera.PiCamera()
try:
   cam.resolution = (800, 600)
   cam.start_preview()
   time.sleep(2)
   cam.stop_preview()
   cam.capture('bild.jpg')
finally:
   cam.close()

import picamera
from time import sleep

with picamera.PiCamera() as cam:
try:
   cam.vflip = True
   cam.hflip = True
   cam.resolution = (800, 600)
   cam.start_preview()
   time.sleep(2)
   cam.stop_preview()
   cam.capture('bild.jpg')
finally:
   cam.close()

Sie können auch einmal mit Kameraparametern experimentieren und sich ansehen, was geschieht, wenn Sie die Helligkeit von 0 auf 100 Prozent hochregeln:

import picamera
from time import sleep

with picamera.PiCamera() as cam:
   cam.resolution = (800, 600)
   cam.start_preview()
   for i in range(100):
      cam.brightness = i
      time.sleep(0.2)
   cam.stop_preview()
   cam.close()

Mit Python können Sie aber noch wesentlich mehr anfangen. Das folgende Beispiel skizziert, wie sich das Kamerabild weiter nutzen lässt. Mit Hilfe des Moduls pygame haben Sie ruck-zuck ein Bildschirmfenster, in dem dann das gerade geschossene Bild angezeigt und mit dem Aktuellen Datum nebst Uhrzeit beschriftet wird. Erweiterungen seien Ihrer Phantasie überlassen:

import picamera
import time
import pygame

# Voreinstellungen
WIDTH=1280
HEIGHT=1024
FONTSIZE=50

# Kamera initialisieren
camera = picamera.PiCamera()
camera.vflip = False
camera.hflip = False
camera.brightness = 60

# Bildschirmfenster aufbauen, Hintergrund schwarz, Schrift weiss
pygame.init()
screen = pygame.display.set_mode((WIDTH,HEIGHT))
black = pygame.Color(0, 0, 0)
textcol = pygame.Color(255, 255, 0)
screen.fill(black)

while True:
    # Bild machen, als GIF speichern, gleiche Größe wie Fenster
    camera.start_preview()
    sleep(1)
    camera.capture('image.gif', format='gif', resize=(WIDTH,HEIGHT))
    camera.stop_preview()

    # altes Bild löschen
    screen.fill(black)
    pygame.display.update()

    # Bild einlesen und anzeigen
    img = pygame.image.load('image.gif')
    screen.blit(img, (0, 0))

    # Datum und Uhrzeit darüber legen
    font = pygame.font.Font('freesansbold.ttf', FONTSIZE)
    text = time.strftime("%d.%m.%Y um %H:%M:%S Uhr")
    font_surf = font.render(text, True, textcol)
    font_rect = font_surf.get_rect()
    font_rect.left = 100
    font_rect.top = 100
    screen.blit(font_surf, font_rect)
    pygame.display.update()

    # etwas warten
    sleep(5)

# aus die Maus
camera.close()
pygame.quit()

Die Aufzeichnung von Videos erfolgt nach einem ähnlichen Schema. Hierzu bauen wir den Kommandozeilenaufruf für die Videoaufzeichnung nach. Die Methoden start_recording() und stop_recording() steuern die Aufzeichnung. Auch hier müssen Sie, sofern gewünscht, ein Vorschaufenster explizit anfordern und wieder schließen. Die Aufnahmedauer wird über wait_recording() eingestellt. Die Methode prüft auch kontinuierlich, ob der Speicherplatz auf der SD-Karte für die Aufzeichnung noch ausreicht, und bricht die Aufnahme notfalls ab. Das folgende Beispiel zewichnet 30 Sekunden auf:

import picamera
from time import sleep

with picamera.PiCamera() as cam:
   cam.start_preview()
   cam.start_recording('filmchen.h264')
   cam.wait_recording(30)
   cam.stop_recording()
   cam.stop_preview()
   cam.close()

Bei vielen Webcams kann man mit der Software Motion arbeiten, die auf dem Standard-Linux-Videostack Video4linux basiert. Scheinbar unterstützte die Picam das aber nicht. Jedoch gibt es ein Python-Programm ( http://www.raspberrypi.org/phpBB3/viewtopic.php?t=45235), das zwar sehr viel einfacher gehalten ist, aber in der Regel ausreicht. Das Programm nimmt Bilder auf und speichert sie mit einemZeitstempel im Dateinamen. Dann vergleicht es in einem niedrig auflösenden Stream immer zwei aufeinanderfolgende Bilder. Überschreiten die Veränderungen einen Schwellenwert, speichert der Pi das entsprechende hochauflösendes Bild.

Wenn man externe Programme ausnutzt, läßt sich auch ein Zeitlupeneffekt realisieren. Zunächst wird mit raspivid ein Video mit der höchstmöglichen Framerate aufgezeichnet (beim RasPi sind dies 90 Bilder pro Sekunde). Weitere Parameter des Programmaufrufs sind '-w' und '-h' für die Bildgröße, '-t' für die Dauer, '-o' für die Ausgabedatei im H264-Format und natürlich '-fps' für die Framerate. Die so erzeugte Datei myvid.h264 wird danach mit dem Programm MP4Box ins MP4-Format konvertiert.

import os
import time

print("Aufnahme gestartet - 30 s.")
os.system("raspivid -w 640 -h 480 -fps 90 -t 30000 -o myvid.h264")
print("Aufnahme beendet")
print("Konvertierung gestartet.")
os.system("rm -f myvid.mp4")
os.system("MP4Box -add myvid.h264 myvid.mp4")
print("Konvertierung abgeschlossen.")

Wie Sie sehen, ist auch die Programmierung des Kamera-Interfaces mit Python nicht allzu schwierig. Viel Spass beim Experimentieren.

Die NoIR-Kamera

Für den RasPi gibt es ja zwei Kamera-Module, die normale Kamera und die NoIR-Kamera mit schwarzer Platine. "NoIR" steht für "No Infra Red (Filter)". Normalerweise haben Kameras einen eingebauten Infrarot-Filter, der die infraroten Anteile des Bildes unterdrückt und die deshalb Fotos liefern, die natürliche Farben wiedergeben. Die NoIR-Kamera ermöglicht Fotoeffekte, die auf dem Infrarot-Anteil des Lichts setzen. Der fehlende Infrarotfilter und ist vor allem für die Fotografie bei schlechten Lichtverhältnissen oder für Infrarotaufnahmen in der Dunkelheit geeignet. Man kann sie aber auch für atmosphärische Bilder bei Tageslicht einsetzen.

Für Infrarot-Effekte bei Tageslicht braucht man aber wieder einen entsprechenden Filter vor dem Objektiv, der einerseits möglichst viel Normallicht aussperrt und auf der anderen Seite einen möglichst hohen IR-Anteil durchlässt. Die NoIR-Kamera lässt einen genügend großen Anteil von Infrarotlicht zu ihrem Bildsensor passieren. Somit gelangt alles Infrarotlicht auf den Sensor, und die Belichtungszeiten werden nicht so hoch wie bei anderen Kameras mit IR-Filter. So kann man auch draussen fotografieren, wenn es nicht ganz windstill ist. Als Filter kommt u. a. der Polaroid Filter IR720 in Frage. Er filtert das meiste Licht unterhalb und oberhalb der Wellenlänge von 720 Nanometern (Nah-Infrarot), also das meiste sichtbare Licht. So lassen sich sogar Falschfarben-Aufnahmen machen. Gegebenenfalls muss der Weissabgleich nachträglich mit einer Bildverarbeitungssoftware gemacht werden.

Neue Raspberry-Pi-Kamera

Die Raspberry Pi Foundation hat im Mai 2016 eine neue Version der Kamera für den RasPi vorgestellt. Der Grund dafür liegt darin, dass die bislang in der Kamera eingebauten OmniVision-OV5647-Sensoren mit fünf Megapixeln seit Ende 2014 nicht mehr hergestellt werden. Im neuen Kameramodul V2.1 kommt der Sensor IMX219 von Sony zum Einsatz, der acht Megapixel Auflösung hat und zudem bessere Farben und eine höhere Bildqualität liefert.

(Bild: Raspberry Pi Foundation)

Die Kamera sitzt wie schon das erste Modell auf einer winzigen Platine und wird durch ein Flachbandkabel mit dem CSI-Port des Raspberry Pi verbunden. Das Modul soll mit denModellen 2 und 3 sowie den älteren Modellen A+ und B+ kompatibel sein. Neben der normalen Kamera ist auch wieder eine NoIR-Version erhältlich. Die neue Kamera beherrscht auch einen automatischen Weißabgleich. Er wird durchgeführt, während die rohen Sensordaten die Image Sensor Pipeline (ISP) durchlaufen dabei in Digitalbilder umgewandelt werden. Es sollen dabei auch Objektivverzerrungen, Rauschen oder fehlerhaften Pixel korrigiert werden. Einzelbilder sind mit einer Auflösung von maximal 3280 x 2464 Pixeln möglich. Videos mit 1080p kann die Kamera mit 30 Frames pro Sekunde (fps) aufnehmen, bei 720p liegt die maximale Bildrate bei 60 fps.
Quelle: www.raspberrypi.org/blog/new-8-megapixel-camera-board-sale-25

Bei einigen Kameramodulen zeigten sich Unschärfen bei der Abbildung. Der Raspberry-Pi-Gründer Eben Upton merkte dazu an, die ausgelieferten Exemplare des neuen Kameramoduls für den Einplatinenrechner seien alle für sich gesehen in Ordnung, nur jeweils unterschiedlich fokussiert. Inzwischen hat der Raspberry-Pi-Forums-Nutzer caerandir eine einfache Lösung demonstriert, mit der man den Fokus der Kamera anpassen kann. Prinzipiell geht es dabei darum, die Linse aus ihrer festen Verklebung zu befreien. Dazu bediente er sich einer Plastikkarte, bohrte ein ca. 5 Millimeter großes Loch hinein und versah es mit kleinen Aussparungen für die Noppen an der Linse. Durch etwas Druck mit der modifizierten Plastikkarte auf die Linse kann man sie losdrehen. Anschließend kann man sie vorsichtig mit einer kleinen Zange fokussieren. Das Bild zeigt verschiedene Varianten das "Wekzeugs". Wie man sieht, kommt es nicht auf Schönheit an.

Eine Leserin schrieb mir im November 2017, dass scheinbar der Kamera-Hersteller bereits auf das Problem reagiert hat. Bei dem Kauf ihrer Pi Camera im Oktober 2017 war ein Hilfsmittel dabei, ein Rändelknopf aus Kunststoff (siehe Bilder unten) welcher zur Einstellung der Schärfe verwendet werden kann, so dass niemand mehr eine modifizierten Plastikkarte erstellen muss.

   

Infrarot-Scheinwerfer

Nachdem das zweite Kameramodell für Infrarotlicht geeignet ist, soll sie auch nachts etwas "sehen"? Dabei hilft ein kleiner Infrarot-Scheinwerfer. Der hier vorgestellte Eigenbau-Infrarot-Scheinwerfer besteht aus 40 preiswerten Infrarot-LEDs und acht Widerständen. Er lässt sich auch vom Lötanfänger ganz einfach auf einer Lochrasterplatte aufbauen. Profis machen sich natürlich eine Platine, insbesondere wenn mehr als ein Scheinwerfer gebraucht wird. Bei 12 V Versorgungsspannung nimmt der Scheinwerfer ca. 200 mA auf, er sollte also ggf. vom Computer aus ein- und ausgeschaltet werden können (per Relais oder MOSFET-Schalttransistor). Die Schaltung des Scheinwerfers ist so einfach, das im folgenden Bild nur die Verdrahtung gezeigt werden muss. Es werden jeweils 5 LEDs und ein 100-Ohm-Widerstand in Reihe geschaltet.

Für den Außeneinsatz muss dann noch ein passendes Gehäuse mit Klarsichtdeckel spendiert werden.

Die Pi-Cam-Optik aufrüsten

Kamera- und Optik-Grundlagen

Bei der Objektivauswahl bildet der Kameraanschluss und damit der Abstand des Bildsensors zur Auflagekante der Kamera (Auflagemass) ein wichtiges Kriterium. Die bildseitige Schnittweite, der Abstand der Bildebene von der hintersten optischen Fläche des Objektivs, muss immer größer als das Auflagemass der Kamera sein. Wäre sie kleiner, würde immer vor dem Bildsensor fokussiert werden. Die Schnittweite ist durch das verwendete Grunddesign der Optik vorgegeben. Die meisten Kameraund Objektivhersteller haben sich auf ein oder mehrere Anschlusssysteme festgelegt.

Für industrielle Objektive gibt es mehrere Standards. Die C- und CS-Mount-Anschlüsse besitzen ein Gewinde mit 1”x32 TPI (tracks per inch) Steigung. Nach amerikanischer Norm (ANSI) wird dieses Gewinde auch mit 1-32UN-2B angegeben. Die Objektive besitzen das Gegenstück mit der Bezeichnung 1-32UN-2A. Die Anschlüsse C- und CS-Mount unterscheiden sich allein durch das Auflagemaß. Der C-Mount hat ein Auflagemaß von 17,53 mm, während der CS-Mount 5 mm kürzer ist, und damit 12,53 mm von der Mechanikkante zum Sensor misst.

Das S-Mount-Feingewinde M12x0,5 eignet sich besonders für Miniaturkameras oder abgesetzte Kameraköpfe. Diese Kameras werden überwiegend in Kombination mit sehr kurzbrennweitigen Objektiven eingesetzt. Das Objektiv hat auch eine kurze bildseitige Schnittweite, somit muss das Objektiv sehr nahe am CCD-Chip sitzen. Über das Feingewinde lässt sich das Auflagemaß des Objektivs zur Kamera exakt einstellen und ist leicht über einen Konterring zu fixieren. Einen genormten Abstand zum CCD–Sensor gibt es nicht.

Der F-Mount-Anschluss bezeichnet das Bajonett-System der Fa. Nikon, das bereits Ende der 50er Jahre entwickelt wurde. Das Auflagemaß beträgt hier 46,5mm. Der F-Mount-Anschluss wird vor allem für High Tech-Kameras mit besonders großen Sensoren benötigt, die eine besonders hohe Auflösung bei großen Pixeln bieten. Dies gilt für industrielle Flächen- und Zeilenkameras.

Die folgende Tabelle fasst die Auflagenmaße zusammen.

C-Mount	17,5 mm
CS-Mount	12,5 mm
F-Mount	46,5 mm
S-Mount	undef.

Objektive enden von den Abmessungen her selten an der Auflagefläche der Kamera, sondern tauchen darüber hinaus mit der letzten Linsengruppe in das Kameragehäuse ein (siehe Bild oben). Die Schnittweite bezeichnet hierbei das Maß vom Scheitelpunkt der letzten Linse bis zum Bildsensor. Besonders bei weitwinkligen tritt das häufig auf.

Ein Objekt vor der Kamera wird nur innerhalb bestimmter Grenzen scharf abgebildet. Die Schärfentiefe ist der Motivraum, der auf dem von der Kamera erzeugten Bild ausreichend scharf erscheint. In der folgenden Grafik wurde die Optik so fokussiert, dass das Objekt 1 scharf als Bild 1 auf dem Sensor abgebildet wird. Ein Gegenstand, der sich näher an der Optik befindet, erzeugt einen Schärfepunkt, der hinter dem Sensor liegt und daher ein unscharfes Bild. Ein ideal scharfes Pixel verschwimmt zu einem größeren Lichtfleck, dem Unschärfebereich (Unschärfekreis). Durch ein Nachfokussieren auf diesen Arbeitsabstand würde die Linsengruppe vom Sensor wegbewegt, um wieder ein scharfes Bild zu erzeugen. Beim S-Mount kann das Nachfokussieren sehr einfach durch Heraus- oder Hineinschrauben des Objektivs erreicht werden.

Für ein Kamerasystem mit festen mechanischen Dimensionen hat dagegen ausschließlich die Objektivblende einen Einfluss auf die Schärfentiefe. Schließt man die Blendenöffnung des Objektivs, nimmt die Schärfentiefe zu. Eine höhere Blendenzahl (= kleinere Öffnung) hat jedoch eine längere Belichtungszeit zur Folge. Die internationale Blendenskala ist so konzipiert, dass jede Stufe eine Halbierung bzw. Verdoppelung der der Belichtungszeit bedeutet. Durch Abblenden der Optik wird der Unschärfebereich auf dem Bildsensor kleiner. Die Objekte 1 und 2 können jetzt also viel weiter räumlich auseinander liegen, um denselben Unschärfebereich zu erzeugen.

Die Schärfentiefe ist umso größer

• je weiter ein Objekt von der Kamera entfernt ist (fast parallele Lichtstrahlen für beide oben gezeigten Abbildungsfälle),
• je kleiner die Brennweite der Optik ist. (es gilt auch: je kleiner der Sensor ist, desto kleinere Brennweiten benötigt er),
• je kleiner die eingestellte Blendenöffnung ist (siehe Bilder oben).

Die exakte Berechnung der Ausdehnung der Schärfentiefe erfordert beträchtliche Rechnerei. Die folgenden Gleichungen sind bereits vereinfachte Näherungsgleichungen. Die Bildschärfe und Schärfentiefe hängen stark von der optischen Konstruktion und ggf. optischen Fehlern ab.

Die hyperfokale Distanz: bezeichnet die Gegenstandsweite, bei der im Unendlichen liegende Objekte gerade noch mit einer akzeptablen Schärfe abgebildet werden, wenn genau auf diese Gegenstandsweite scharf gestellt wurde. Die Schärfentiefe reicht dann von der halben hyperfokalen Distanz bis Unendlich. Für die nachfolgenden Formeln muss zuerst die hyperfokale Distanz berechnet werden:

hyperfokale Distanz:    H = (f´* f´)  / (N * c) + f´

Mit Hilfe von H können die folgenden Werte berechnet werden:

Nahpunkt für akzeptable Bildschärfe:    g_n = G * (H - f´) / (H + g - 2 * f´)

Fernpunkt für akzeptable Bildschärfe:    g_f = G * (H - f´) / (H - g)

Gesamte Schärfentiefe:    g_n - g_f

Dabei sind:

Quelle: Greenleaf, Allen R.: Photographic Optics, The MacMillan Company.

Die Pi-Cam umbauen

Doch zuerst muss die alte Optik entfernt werden. Wie das Abschrauben funktioniert, steht weiter oben unter "Neue Raspberry-Pi-Kamera". Achten Sie beim Abmontieren der Originaloptik darauf, dass der Sensor unbeschädigt bleibt. Der neue Objektiv-Anschluss passt wie für die Pi-Cam gemacht, es lassen sich sogar die Befestigungslöcher auf der Pi-Cam zm Fixieren des Gewindes verwenden.

Bevor Sie den M12-Anschluss auf die Pi-Cam setzen können, ist noch etwas Nacharbeit notwendig: Auf der Seite des Flachkabel-Anschlusses muss der M12-Anschluss etwas ausgespart werden. Mit einer feinen Feile wird eine Vertiefung in die eine Seitenwand des Anschlussgehäuses eine Aussparung gefeilt, sodass das M12-Gehäuse plan auf der Platine aufliegt.

Beim quadratischen M12-Anschluss muss ggf. auch noch auf einer Ecke etwas gefeilt werden, damit die Bauteile R9 und D1 nicht gequetscht werden. Das M12-Gehäuse mit abgeschrägten Ecken erfordert hier keine Nacharbeit.

Ob Sie den M12-Anschluss dann auf das Pi-Cam-Board kleben oder mit den seitlichen Ösen festschrauben, bleibt Ihnen überlassen. Nun kann das Wunsch-Objektiv eingeschraubt und scharfgestellt werden. Zum Fixieren des Objektivs in der gewünschten Schärfeposition reicht in der Regel ein Tröpfchen Nagellack auf Gewinde und Gehäuse. Wenn sich gar kein scharfes Bild einstellen lässt, hift entweder ein M12-Zwischenring (Objektiv weiter weg vom Sensor) oder Abfräsen eine Stücks vom Gewindeteil (Objektiv näher am Sensor). Das ist aber nur bei ganz exotischen Anwendungen nötig.

Duch das M12-Gewinde kann man auch zwischen Weitwinkel-, Tele- oder Makroobjektiv wechseln - je nach Anwendungsfall. Für diee Beleuchtung in Nhbereich kann man sich dann noch ein Ringlicht aus weißen LEDs basteln.

Links

Allgemeine und weiterführende Informationen zum Betrieb von Webcams unter Linux und zu M12-Objektiven finden Sie unter

• Webcam am Linux-Rechner.
• Bildausgabe ohne X-Window-System mit fbi/OMXPlayer
• Bilder mit ImageMagick bearbeiten
• Stockoptics
• M12 Board Lens Holder for Raspberry PI Cameras
• Liste der vom RasPI unterstützten USB-Kameras

Copyright © Hochschule München, FK 04, Prof. Jürgen Plate
Letzte Aktualisierung: