August 10, 2017

Anschließen und Betreiben einer Raspberry Pi Kamera

Eine Raspberry Pi Kamera ist eine tolle Sache und lässt neue Möglichkeiten zu. Man kann die Kamera unter anderem zur Bewegungserkennung oder Überwachung Ihrer Räume einsetzen. In diesem Tutorial wird gezeigt, wie man die Raspberry Pi Kamera einrichtet, Fotos und Videos macht und einen Video-Stream über das Netzwerk von einem anderen System abrufen kann.

Die Raspberry Pi Kamera hat einen festen Fokus und liefert 5 Megapixel. Videos können in 1080p, 720p oder 640×480 mit maximal 30 Bildern pro Sekunde aufgenommen werden und Fotos haben eine maximale Auflösung von 2592 × 1944 Pixel.

Raspberry Pi Kamera einrichten

Der Anschluss für die Camera sitzt bei allen Modellen hinter dem Ethernet Anschluss und nennt sich CSI (bei den Zero-Modellen ist die Schnittstelle gegenüber dem MicroSD-Slot angebracht). Trennt den Pi vom Strom. Hebt dort die Verschluss-klemme etwas an steckt das Kabel ein (achtet darauf das die blanken Pins weg von der Klemme zeigen), zum Befestigen die Klemme einfach wieder etwas andrücken.

Startet euren Raspberry Pi und ruft via SSH oder via Tastatur und Monitor nach dem Anmelden mit pi und raspberry das folgende Kommandos zum Aktualisieren eures Systems auf.

sudo apt-get -y update && sudo apt-get -y upgrade

sudo rpi-update

Danach starten wir das Konfigurations-Tool raspi-config um die Kamera zu aktivieren

Zum aktivieren wählt ihr den Punkt 5 “Enable Camera” und aktiviert das Modul.

Das war auch schon die Einrichtung, nun solltet ihr euren Pi einmal neu starten.

Fotos mit der RasPi Cam aufnehmen

Als zentrales Tool zur Aufnahme von Fotos mit dem Raspberry Pi verwenden wir das in Raspbian bereits vorinstallierte Tool raspistill. Es bietet eine Viehlzahl von Optionen, falls ihr auf dem Desktop angemeldet seit wird euch sogar ein kurzes Preview Fenster angezeigt.

Zum Testen ob die Kamera überhaupt funktioniert machen wir ein Testbild mit den Optionen -o (Festlegen des Dateinamens) und -v (Verbose Ausgabe).

raspistill -v -o test.jpg

Jetzt solltet ihr in eurem aktuellen Verzeichnis ein test.jpg haben, falls etwas nicht geklappt hat wird euch raspistill zwecks der -v Option einen detaillierten Fehler präsentieren (z.B. das die Kamera nicht via raspi-config aktiviert wurde o.ä.).

Fotos im Jpeg-Format aufnehmen

raspistill -o test.jpg

Fotos im PNG-Format aufnehmen

Mit dem Parameter -e können verschiedene Formate wie jpg, bmp, gif und png erzeugt werden.

raspistill -o test.png –e png

Aufnahme von Fotos ohne Preview Fenster (-n)

raspistill -o test.jpg -n

Aufnahme auf Knopdruck (Enter)
Ersetzt man test.jpg durch test%02d.jpg wird bei jedem Knopdruck ein neues Foto mit dem Dateinamen image01.jpg, image02.jpg usw. erstellt. Abbrechen könnt ihr die Serie mit STRG+C

raspistill -t 0 -k -o test%02d.jpg

Zeitverzögertes Foto (3 Sekunden), die Angabe erfolgt in Millisekunden

raspistill -o test.jpg -t 3000

Aufnahme von Fotos mit anderer Auflösung (640×480), die Parameter w und h geben die Weite und die Höhe in Pixeln an

raspistill -o test.jpg -w 640 -h 480

Fotos mit reduzierter Qualität aufnehmen (-q)
Dadurch kann Speicherplatz eingespart werden, es sind Werte von 0 bis 100 möglich.

raspistill -o image.jpg -q 20

Raspberry Pi Kamera LED abschalten

Wenn euch die rote Aufnahme-LED stört, können ihr diese deaktivieren, dazu ist ein neuer Eintrag in der Datei /boot/config.txt mit anschließendem Neustart notwendig. Tragt hierzu einfach die folgende Zeile in eure config.txt mit einem beliebigen Editor ein.

disable_camera_led=1

Raspberry Pi Kamera über das Netzwerk Streamen

Um das Video von der Kamera in einem Web-Browser betrachten zu können, wird ein Python-Skript benötigt. Diesen findet man auf der offiziellen PiCamera-Documentation-Seite – Web streaming.

Erstellen Sie einen Python-Skript "rpi_camera_web_streaming.py"

nano rpi_camera_web_streaming.py

Kopieren Sie den unten angegebenen Code in den neu erstellten Skript:

import io
import picamera
import logging
import socketserver
from threading import Condition
from http import server

PAGE="""\
<html>
<head>
<title>picamera MJPEG streaming demo</title>
</head>
<body>
<h1>PiCamera MJPEG Streaming Demo</h1>
<img src="stream.mjpg" width="640" height="480" />
</body>
</html>
"""

class StreamingOutput(object):
def __init__(self):
self.frame = None
self.buffer = io.BytesIO()
self.condition = Condition()

def write(self, buf):
if buf.startswith(b'\xff\xd8'):
# New frame, copy the existing buffer's content and notify all
# clients it's available
self.buffer.truncate()
with self.condition:
self.frame = self.buffer.getvalue()
self.condition.notify_all()
self.buffer.seek(0)
return self.buffer.write(buf)

class StreamingHandler(server.BaseHTTPRequestHandler):
def do_GET(self):
if self.path == '/':
self.send_response(301)
self.send_header('Location', '/index.html')
self.end_headers()
elif self.path == '/index.html':
content = PAGE.encode('utf-8')
self.send_response(200)
self.send_header('Content-Type', 'text/html')
self.send_header('Content-Length', len(content))
self.end_headers()
self.wfile.write(content)
elif self.path == '/stream.mjpg':
self.send_response(200)
self.send_header('Age', 0)
self.send_header('Cache-Control', 'no-cache, private')
self.send_header('Pragma', 'no-cache')
self.send_header('Content-Type', 'multipart/x-mixed-replace; boundary=FRAME')
self.end_headers()
try:
while True:
with output.condition:
output.condition.wait()
frame = output.frame
self.wfile.write(b'--FRAME\r\n')
self.send_header('Content-Type', 'image/jpeg')
self.send_header('Content-Length', len(frame))
self.end_headers()
self.wfile.write(frame)
self.wfile.write(b'\r\n')
except Exception as e:
logging.warning(
'Removed streaming client %s: %s',
self.client_address, str(e))
else:
self.send_error(404)
self.end_headers()

class StreamingServer(socketserver.ThreadingMixIn, server.HTTPServer):
allow_reuse_address = True
daemon_threads = True

with picamera.PiCamera(resolution='640x480', framerate=24) as camera:
output = StreamingOutput()
camera.start_recording(output, format='mjpeg')
try:
address = ('', 8000)
server = StreamingServer(address, StreamingHandler)
server.serve_forever()
finally:
camera.stop_recording()

Speichern Sie die Angaben mit Strg+X, Y und Enter.

Starten Sie den Skript mit:

python3 rpi_camera_web_streaming.py

Rufen Sie nun den Web-Stream auf einem anderen PC / Smartphone / Tablet (aber im gleichen Netzwerk) in einem Web-Browser auf:

http://<Your_Pi_IP_Address>:8000

(z.B.: http://192.168.178.194:8000)

Videos aufnehmen

Auch für die Aufnahme von Videos über die Raspberry Pi Kamera haben wir unter Raspbian ein zentrales Tool, raspivid übernimmt hier alle wichtigen Aufgaben für uns.

Ein Video in 1080p aufnehmen (1920 x 1080)
Mit dem Parameter -t gibt man die Aufnahmezeit in Millisekunden an, für eine dauerhafte Aufzeichnung wird der Wert auf 0 gesetzt.

raspivid -o testvideo.h264 -t 50000

Ein Video in 720p aufnehmen (1280 x 720)

raspivid -o testvideo.h264 -t 50000 -w 1280 -h 720

Video mit anderer Framerate aufzeichnen (zb. 15 Frames/Sekunde)

raspivid -o testvideo.h264 -t 50000 -f 15

Das Original-Tutorial kann man hier nachlesen.

Zurück zu braspi blog

Raspberry Pi

Zubehör