Vor kurzem habe ich ein Kamera-Modul für den Raspberry Pi geschenkt bekommen. Daher bestellte ich mir darauf auch noch einen Pi, um die Kamera gleich ausprobieren zu können.
(Die folgenden Schritte wurden unter Microsoft Windows 10 gemacht.)
Eines der offiziellen Betriebssysteme für den RPi ist Raspbian, ein Derivat von Debian-Linux. Zunächst
lädt man das neueste Image von Raspbian herunter:
https://www.raspberrypi.org/downloads/raspbian/
Ich habe "Raspbian Stretch Lite" verwendet, da ich den RPi über eine SSH einrichten wollte und dazu keine Desktop-Umgebung
benötige. Nach dem Entpacken des .zip-Archivs wird das IMG auf die SD-Karte geflasht. Dazu kann z.B. das Programm
Etcher verwendet werden. Nach dem erfolgreichen Erstellen der geflashten
SD-Karte entstehen zwei Partitionen, wobei nur eine (boot) unter Windows lesbar ist. Um SSH unter Raspbian sofort nach dem booten zu aktivieren,
legt man einfach eine leere Textdatei mit dem Namen "ssh" in die Hauptebene der boot-Partition auf der SD-Karte.
Man steckt nun die vorbereitete SD-Karte in der RPi, verbindet ein LAN-Kabel zwischen RPi und dem eigenen Router (z.B. FritzBox) und
schließt den RPi an eine Stromquelle an (z.B. mitgeliefertes Netzteil oder Powerbank). Die Stromquelle sollte die Möglichkeit haben,
2000mA abzugeben, da sonst evtl. unerwartetes Verhalten des RPi auftreten kann.
Der boot-Vorgang dauert nur einige Sekunden und dann kann man sich über einen Terminal-Programm
(z.B. PuTTY) mit dem Raspberry Pi per SSH verbinden:
| Hostname: | raspberrypi.local |
|---|---|
| Benutzername: | pi |
| Passwort: | raspberry |
Der Hostname muss nicht verwendet werden, man kann auch im verbundenen Router die IP-Adresse (192.168.xxx.xxx) des RPi ermitteln.
Aus sicherheitsgründen sollte das Passwort ebenfalls nach dem ersten Einloggen umbenannt werden:
$ sudo raspi-config
Es können auch weitere Benutzer angelegt und der sudo-Gruppe zugeordnet werden, z.B.:
$ sudo useradd -m christian -G sudo
Raspbian ist ein Linux-Betriebssystem und hält, wie jedes andere Betriebssystem auch, Daten oft temporär in einen
Zwischenspeicher und schreibt diese erst später in den Datenspeicher. Auf keinen Fall sollte man den RPi einfach
"hart" ausschalten, d.h. nie einfach die Stromversorgung abschalten oder ausstecken. Das gefährdet die
Konsistenz der Daten und des Systems, bis hin zu möglichen Hardware-Schäden.
Herunterfahren des Systems:
$ sudo shutdown -h 0 bzw. sudo shutdown -h now
oder man kann den Alias verwenden:
$ sudo poweroff
Zum Neustart des Systems verwendet man folgende Befehle:
$ sudo shutdown -r 0 bzw. sudo shutdown -r now
oder der kürzere Alias:
$ sudo reboot
Für manche Aktionen muss man als root eingeloggt sein, dies löst man mit:
$ sudo su -
Statt einem echten BIOS verwendet der RPi die Konfigurations-Datei /boot/config.txt. In dieser textbasierten Datei können alle
BIOS-relevanten Einstellungen
vorgenommen werden.
$ less /boot/config.txt
Basis-Einstellungen können mit Hilfe eine kleinen Konfigurationsprogramms vorgenommen werden. Dazu gehören die Änderung
des Benutzer-Passworts, Lokalisierung, Aktivierung der Pi-Cam, Hostname, Zuweisung geteilten Speichers für den
Grafik-Koprozessor, Aktivierung eines SSH-Servers, Boot in die Kommandozeile oder zum Desktop u.a.
$ sudo raspi-config
Da viele Prozesse unter Raspbian (d.h. Linux) immer wieder kleinere und größere Daten auf die Festplatte, d.h.
auf die SD-Card schreiben, d.h. vor allem Log-Dateien, wird gezeigt, wie man die Schreib-Operationen auf die
SD-Card diesbezüglich verringern kann, um auch die Lebensdauer der SD-Card zu verlängern.
In folgender Datei:
$ sudo nano /etc/fstab
diese Zeile hinzufügen:
$ tmpfs /var/log tmpfs defaults,noatime,nosuid,mode=0755,size=100m 0 0
und dann das System neu booten.
$ sudo swapoff --all
schaltet das swappen auf die SD-Card vollständig ab und benutzt für die Prozesse nur noch dem RAM-Speicher.
Vorsicht: Bitte das swappen nur dann abschalten, wenn klar ist, was dies für Konsequenzen hat, denn
es kann zu enormen Performance-Einbrüchen kommen, wenn sehr RAM-intensive Programme laufen!
Zur Überprüfung kann das folgende Kommando verwendet werden:
$ sudo free -mh
Um den RPi unabhängig von einem LAN-Kabel ansprechen zu können müssen wir zunächst WLAN anschalten und einrichten, so dass unser RPi sich mit dem eigenen WLAN-Netzwerk verbinden kann (z.B. über eine FritzBox).
Zunächst prüft man, ob das System auch wirklich den WLAN-Adapter findet:
$ sudo iwlist scan
Der Name der Netzwerkkarte lautet im Fall des Raspberry Pi 3 wlan0, bei älteren RPi mit USB-WLAN-Adapter
erscheint je nach dem für die Karte verantwortlichem Kernel-Modul ein anderer Name.
Nun sucht man die Umgebung nach verfügbaren WLAN-Netzwerken ab:
$ sudo iwlist wlan0 scan bzw. sudo iwlist wlan0 scan | egrep "(ESSID|IEEE)"
Damit erhält man eine Liste mit allen in der Nähe befindlichen WLAN-Netzwerken. Unser gewünschtes
Netzwerk sollte in dieser Liste ebenfalls auftauchen.
Damit der RPi sich in unser WLAN-Netzwerk einloggen kann, müssen wir ihm die Authentifizierungsdaten
zur Verfügung stellen. Zunächst wird folgende Datei geöffnet:
$ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
Hier fügt man folgende Zeilen hinzu:
network={
ssid="XXXXX"
psk="YYYYY"
}
wobei XXXXX durch die SSID und YYYYY durch das Passwort des WLAN-Netzwerkes ersetzt werden muss.
Außerdem sollte der Energiesparmodus deaktiviert werden, währen das WLAN-Modul verwendet wird, da es sonst
passieren kann, dass sich der RPi vom WLAN-Netzwerk nach einiger Zeit automatisch trennt. Hierzu fügt man
folgende zwei Zeilen am Ende der Datei /etc/network/interfaces ein:
pre-up iw dev wlan0 set power_save off
post-down iw dev wlan0 set power_save on
Nun wird das Netzwerk kurz "neugestartet", das LAN-Kabel angezogen und WLAN sollte verfügbar sein:
$ sudo ifdown wlan0
$ sudo ifup wlan0
$ sudo ifconfig wlan0 | grep inet
Natürlich wird die offene SSH-Verbindung unterbrochen, man kann aber nun die Verbindung erneut
öffnen und diesmal wird per WLAN verbunden. Um zusätzlich zu prüfen, ob das WLAN-Netzwerk richtig
funktioniert, kann man eine öffentliche Seite im WWW anpingen, z.B.:
$ ping turanis.de
Falls die Verbindung über WLAN nicht funktionieren sollten, dann einmal den RPi neu booten.
Unterwegs kann es vorkommen (z.B. wenn man Zeitraffer-Aufnahmen machen will), dass man kein WLAN-Netzwerk zur Verfügung hat. Man kann sich aber über das Android-Phone mit dem RPi verbinden, indem man auf dem Smartphone einen WLAN-Hotspot einrichtet und diesen im RPi vorkonfiguriert. Dann kann man sich bequem vom Smartphone per SSH (z.B. mit der App JuiceSSH) verbinden.
Einrichten des mobilen WLAN-Hotspots auf dem Android-Phone (mit Samsung Galaxy S8 durchgeführt):
- ausschalten von "Datensparen" im Einstellungs-Menu "Datennutzung"
- "Mobile Hotspot und Tethering" im Einstellungs-Menu "Verbindungen" anwählen
- "Mobile Hotspot" anschalten und SSID und Passwort merken
Einrichtung des ausgebauten Hotspots auf dem RPi:
Zunächst wird folgende Datei geöffnet:
$ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf
Hier fügt man folgende Zeilen hinzu:
network={
ssid="XXXXX"
psk="YYYYY"
}
wobei XXXXX durch die SSID und YYYYY durch das Passwort des Hotspots ersetzt werden muss.
RPi neustarten:
sudo reboot
Nachdem der RPi hochgefahren ist, taucht der Eintrag in "Verbundene Geräte" auf dem Smartphone
im Menupunkt "Mobile Hotspot" auf. Nun darauf tippen und die Verbindung zulassen.
Nun sollte man sich die IP-Adresse des RPi merken und dann kann man sich in der SSH-App auf den RPi
verbinden.
Der Pairing-Modus des RPi wird wie folgt aktiviert:
$ sudo bluetoothctl
Jetzt befindet man sich in der Steuerung des Bluetooth-Moduls. Nun ist der Bluetooth-Agent zu aktivieren:
agent on
default-agent
Nun wird die nähere Umgebung nach kopplungsbereiten Bluetooth-Geräten abgesucht:
scan on
Diese werden nach und nach angezeigt. Wenn das gewünschte Bluetooth-Gerät zu sehen ist, kann es mit dem
folgenden Befehl gekoppelt werden:
pair xx:xx:xx:xx:xx:xx (angezeigte MAC-Adresse des Geräts)
Im Regelfall kommt dann eine Bestätigung mit
Device xx:xx:xx:xx:xx Connected: yes
Confirm passkey xxxxxx (yes/no):
Hier muss mit yes bestätigt werden. Nun sind beide Geräte gekoppelt.
Um eine oder mehrere mp3-Dateien auf dem RPi abspielen zu können benötigt man nur ein kleines
Hilfsprogramm, in diesem Fall den
"OMXPlayer":
$ sudo apt-get install omxplayer
Zum Test des Players kann man sich eine Beispieldatei herunterladen:
$ wget https://sample-videos.com/audio/mp3/crowd-cheering.mp3
und diese dann abspielen lassen:
$ omxplayer crowd-cheering.mp3
Um die mp3-Datein hören zu können, die nun gerade abgespielt wird, muss natürlich am Audio-Ausgang
des RPi Köpfhörer, Headset oder externe Lautsprecher angeschlossen sein.
Der RPi sollte heruntergefahren und ausgeschaltet werden, dann wird das Kamera-Modul mit dem RPi
verbunden und arretiert. Nach dem Neustart des RPi wird die Kamera zunächst aktiviert:
$ sudo raspi-config
Im Hauptmenü des Config-Tools geht man auf "Interfacing Options >> Camera" und
aktiviert die Kamera. Ist diese Option nicht verfügbar, so muss das System geupdated werden:
$ sudo apt-get update und dann
$ sudo apt-get upgrade
Nach dem Speichern der Einstellungen muss der RPi neu gebootet werden.
$ raspistill -v -o cam_test.jpg
Hierbei wird ein Foto mit einer (standardmäßig eingestellten) Verzögerung von 5 Sekunden
aufgenommen und als JPEG mit dem Namen "cam_test.jpg" im aktuellen Arbeitsverzeichnis
gespeichert. Es werden zusätzlich durch die v-Option noch einige Informationen auf der Konsole ausgegeben.
Der CCD-Chip benötigt eine gewisse Zeit zur Auto-Justierung, so dass der default-Wert auf 5000 Millisekunden eingestellt ist.
Somit wird jedes Fotos, welches ohne t-Option aufgenommen wird, erst nach 5 Sekunden auslösen.
$ raspistill -o image.jpg -t 1
Dabei ist die Verzögerung auf das Minimum von 1 Millisekunde herabgesenkt, jedoch leidet die Gesamtqualität des
Fotos deutlich, insbesondere der Farben und des Kontrastes.
700-1000 Millisekunden scheinen ein guter Wert zu sein, um vernünftige Fotos zu machen:
$ raspistill -o image.jpg -t 700
Je nachdem wie das Kamera-Modul verbaut und aufgestellt wurde, kann es sein dass man die Aufnahmen spiegeln möchte:
$ raspistill -hf -o image.jpg
spiegelt das Foto horizontal, während:
$ raspistill -vf -o image.jpg
das Foto vertikal spiegelt. Diese beiden Optionen können auch kombiniert werden.
$ raspistill -o image.jpg -w 800 -h 600
Nimmt ein Foto in geringer Auflösung (hier: 800×600 Pixel) auf.
$ raspistill -o image.jpg -q 25
Nimmt ein Foto mit reduzierter JPEG-Qualität auf, wobei die Dateigröße deutlich reduziert wird.
Es sind Werte von 0 bis 100 möglich, wobei 100 die beste Qualität darstellt.
Diese Option kann später sehr hilfreich sein, wenn man sehr viele Fotos
im Zusammenhang mit einer Zeitrafferaufnahme machen will.
$ raspistill -t 0 -k -o image%03d.jpg
ermöglicht Foto-Aufnahmen auf Tastendruck. Nach dem Drücken von [ENTER] wird ein
Foto gespeichert. In diesem Fall wird die Datei nicht überschrieben, sondern als Folge von
nummerierten Dateien (image001.jpg, image002.jpg, ...) gespeichert.
Um sich die langen Options-Parameter zu sparen und zusätzlich noch den Foto-Dateien
chronologische Namen zu geben. Die folgenden Zeilen werden dazu einfach in eine
Datei (z.B. ~/cam-shot.sh) gespeichert:
#!/bin/bash
DATE=$(date +"%Y-%m-%d_%H%M")
raspistill -o /home/pi/photos/$DATE.jpg
Nun wird noch der Ziel-Ordner für die Fotos im Home-Verzeichnis angelegt:
$ cd ~
$ mkdir photos
und die Rechte zum Ausführen der Script-Datei vergeben:
$ chmod +x cam-shot.sh
Nun kann je ein Foto aufgenommen werden, sobald man dies ausführt:
$ ./cam-shot.sh
In sehr dunkler Umgebung können auch interessante Aufnahmen gemacht werden, z.B. mit folgenden Einstellungen:
raspistill -co 90 -br 70 -t 2000 -ss 6000000 -awb off -awbg 1,1.3 -ISO 800 -n -q 100 -o night.jpg
$ for i in -24 -18 -12 -6 0 1 6 12 18 24; do raspistill -ev $i -o hdr-series${i}.jpg; done
nimmt eine Reihe von Fotos mit verschiedenen Belichtungszeiten auf. Diese Aufnahmen sollten exakt dasselbe
Motiv treffen, dann können sie später mit Luminance HDR
zu einem HDR-Foto zusammengebaut werden.
$ raspistill -o timelapse%03d.jpg -t 300000 -tl 1000 -q 25
nimmt 5 Minuten lang (=300000 Millisekunden) eine Reihe von Fotos im Abstand von jeweils 1 Sekunde (=1000 Millisekunden) auf.
Um etwas Platz zu sparen, ist die Qualität der Fotos auf 25% reduziert.
Die erstellte Foto-Reihe kann zu einem Zeitraffer-Film kombiniert werden, z.B.:
$ ffmpeg -framerate 25 -i timelapse%03d.jpg -vf scale=800:-1 timelapse-video.mp4
Hierbei werden die Einzelbilder auf 800 Pixel Breite skaliert, wobei die Höhe entsprechend angepasst wird.
(Natürlich können auch Video-Bearbeitungsprogramme wie z.B. Adobe Premiere verwendet werden)
Um eine Zeitrafferaufnahme zu machen, ohne dass man sie manuell starten muss (z.B. Sonnenaufgang), kann man
den Linux-Befehl at verwenden, um "raspistill" zu einem späteren Zeitpunkt aufzurufen.
Die folgende Zeitraffer-Aufnahme soll einen ganzen Tag andauern (d.h. von Sonnenaufgang bis -untergang) und
alle 10 Sekunden ein Foto aufnehmen.
...zum Rechner für Zeitraffer-Aufnahmen
Um nicht vor Sonnenaufgang den Prozess manuell starten zu müssen, wird folgender Befehl verwendet:
at 4:00 AM tomorrow
at> raspistill -o ~/timelapse/tl%04d.jpg -t 64800000 -tl 10000 -q 35
at> <EOT>
Die erste Zeile gibt den Startzeitpunkt vor (aufpassen, wie die Uhr des RPi gestellt ist); dann befindet
man sich in der at-Konsole. Hier wird der zu startende Befehl oder Script angegeben. Mit [Enter] wird
bestätigt und dann mit [Ctrl-d] beendet und gespeichert. Mit "atq" kann die Liste mit bestehenden
Jobs eingesehen werden und mit "atrm" kann auch ein Job wieder gelöscht werden.
Mehr Infos zu at/atq/atrm
Aus mir unbekannten Gründen stoppt "raspistill" nach einiger Zeit und speichert keine weiteren Aufnahmen. Daher habe ich mich entschlossen die Foto-Reihen mit einem Bash-Script (timelapse.sh) zu starten:
#!/bin/bash
while :; do
FILENAME=$(date +%Y%d%m_%H%M%S)
raspistill -t 3000 -n -o tl${FILENAME}.jpg -q 35
echo ${FILENAME}
sleep 10
done
Dieses Script wird nur noch ausführbar gemacht:
$ chmod +x timelapse.sh
und kann dann als Hintergrund-Job ausgeführt werden (damit man nicht die ganze Zeit eingeloggt sein muss)
$ nohup ./timelapse.sh &
Um die Aufnahme-Reihe wieder zu stoppen, loggt man sich erneut in den RPi ein und sucht sich die Prozess-ID
$ ps -ef | grep timelapse
Dann kann man den Prozess beenden (wobei xxx die PID ist):
$ kill xxx
Damit nicht bei jeder Aufnahme die rote Status-LED leuchtet und evtl. als Reflektion mit aufgenommen
wird, kann diese auch deaktiviert werden.
In der Datei /boot/config.txt fügt man folgende Zeile hinzu:
disable_camera_led=1
und bootet den RPi neu.
$ raspivid -o film.h264 -t 10000
nimmt ein Video von 10 Sekunden (=10000 Millisekunden) Länge auf. Für "unendlich" lange
Aufnahmen (z.B. beim Streaming) wird die t-Option auf 0 gesetzt.
Hier sind keinerlei weitere Optionen angegeben, daher wird die maximale Auflösung für
Videos verwendet, d.h. 1920×1080 (1080p)
$ raspivid -o film.h264 -t 10000 -w 1280 -h 720
nimmt ein Video in 720p auf.
$ raspivid -o film.h264 -t 10000 -b 3500000
nimmt ein Video in angepasster Bit-Rate auf (hier: 3,5MBit/s).
$ raspivid -o film.h264 -t 10000 -f 10
nimmt ein Video mit angepasster Frame-Rate auf (hier: 10 Frames/s).
$ raspivid -t 10000 -o -
nimmt ein Video auf und sendet den Stream an STDOUT.
$ sudo apt-get install gpac
installiert das Programm MP4Box zum Umverpacken der Videos.
$ MP4Box -fps 30 -add film.h264 film.mp4
verpackt einen Film in MPEG4
Mit dem Programm VLC (VideoLan) kann ein
Live-Stream von der Kamera auf dem PC wiedergegeben werden.
Auf dem Server (d.h. RPi) wird folgender Befehl ausgeführt, um damit das Streaming des Videos zu starten:
$ raspivid -o - -t 0 -n -w 800 -h 600 -fps 25 -g 100 | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8554/,mux=ts}' :demux=h264
Nun wird das Programm VLC gestartet und im Menüpunkte "Medien >> Netzwerkstream öffnen..."
wird folgende Adresse eingegeben:
rtsp://raspberrypi.local:8554/
Sobald man auf "Wiedergabe" drückt, startet der Live-Steam der Kamera.
Allerdings ist diese Art des streamens bei mir auch bei niedrigen Auflösungen sehr rucklig und fast nicht
brauchbar gewesen.
Mit dem PiCamera-Package
für Python lässt sich auch sehr einfach ein Live-Streaming implementieren.
Zunächst findest man die IP-Adresse seines RPi heraus:
$ ifconfig
(Die IP-Adresse sollte dann eine 192.168.xxx.xxx sein.)
Nun wird zunächst geprüft, ob das PiCamera-Package schon auf dem RPi vorhanden ist:
$ python3 -c "import picamera"
falls das Package noch nicht installiert wurde, dann kommt folgende Ausgabe:
ImportError: No module named 'picamera'
Dann wird das Package folgendermaßen installiert:
$ sudo apt-get install -y python3-picamera
Nun wird das Python-Script (stream.py) zum Video-Stream mit folgendem Inhalt erstellt
(Quelle: PiCamera: Web streaming):
import io
import picamera
import logging
import socketserver
from threading import Condition
from http import server
PAGE="""\
<html>
<head>
<title>Raspberry Pi - Streaming demo</title>
</head>
<body>
<h1>Raspberry Pi - 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()
#Uncomment the next line to change your Pi's Camera rotation (in degrees)
#camera.rotation = 90
camera.start_recording(output, format='mjpeg')
try:
address = ('', 8000)
server = StreamingServer(address, StreamingHandler)
server.serve_forever()
finally:
camera.stop_recording()
Nun kann das Script ausgeführt werden:
$ python3 stream.py
Öffnet man nun einen Webbrowser (der sich im selben Netzwerk wie der RPi befindet), so kann man den
Live-Stream unter folgender URL ansehen:
http://192.168.xxx.xxx:8000/index.html
Zunächst muss "motion",
dass Programm zur Bewegungserkennung, installiert werden (falls nicht schon vorhanden):
$ sudo apt-get install motion
Nun wird überprüft, ob die angeschlossene Kamera als Standard-Device erkannt wurde:
$ ls -l /dev/v*
Es sollt nun /dev/video0 als Gerät erscheinen. Falls nicht kann dies nachträglich hinzugefügt werden:
$ sudo modprobe bcm2835-v4l2
Mit folgendem Befehl wird nun die Bewegungs-Erkennung gestartet:
$ sudo
Für detaillierte Informationen über alle Optionen der Kamera siehe:
Offizielle Dokumentation der Kamera
Der RPi verfügt über mehrere USB-Schnittstellen, also lassen sich einfach auch Webcams o.ä. anschließen
und ansteuern.
(siehe auch: USB-Mikroskop & Raspberry Pi)
Informationen über angeschlossene Video-Geräte zu bekommen:
$ v4l2-ctl --all
Anzeige der verfügbaren Modi:
$ v4l2-ctl --device=/dev/video0 --list-formats-ext
Abfrage der USB-Kamera:
$ v4l2-ctl --list-formats-ext
Abfrage von Treiber-Informationen:
$ v4l2-ctl -D
$ mplayer -vo jpeg -frames 1 tv://
oder:
$ ffmpeg -i /dev/video0 -vframes 1 -s 800x600 output.png
oder:
$ fswebcam -r 1920x1080 --skip 1 --no-banner output.jpg
oder:
$ v4l2-ctl --set-fmt-video=width=1280,height=720,pixelformat=3
$ v4l2-ctl --stream-mmap=3 --stream-count=1 --stream-to=somefile.jpg
Will man den RPi mit einer Powerbank betreiben, dann sollte die Laufzeit möglichst lange sein. Durch einige softwareseitige Einstellungen kann man die Leistungsaufnahme des RPi senken.
zurück