Schlagwort-Archive: RaspiCam

PinQam Update – Weißabgleich voreinstellen

PiCamera

In letzter Zeit habe ich den Code überarbeitet und bin von den os.system Aufrufen zu einem Python-Modul für die RaspiCam namens PiCamera  gewechselt. Leider funktioniert noch nicht alles einwandfrei und einige Funktionen habe ich noch nicht umgestellt, aber ein Anfang ist gemacht.

Neue Funktion – Weißabgleich einstellen

Es ist jetzt möglich den Weißabgleich per presets einzustellen. Somit kann die RaspiCam auf das Umgebungslicht angepasst werden.

Weissabgleich

Zur Auswahl stehen:

  • aus
  • automatisch
  • Sonnenlicht
  • bewölkt
  • Schatten
  • Glühlampe
  • Leuchtstoffröhre
  • Blitz

Probleme

Probleme Gibt es noch bei der Funktion die LED der Kamera zu aktivieren/deaktivieren. Ich nutze getpass.getuser() um festzustellen, wie der angemeldete Benutzer heißt, um damit die Pfade festzulegen. Das Programm müsste als root gestartet werden um die Funktion zu nutzen, was mir aber Probleme bereitet, da getpass.getuser() dann immer „root“ zurückgibt.

Ein weiteres Problem gibt es bei der Videofunktion. Wenn man als Format „mjpeg“ auswählt, hängt sich die Kamera auf. Das Problem mit „mjpeg“ ist aber bekannt, soweit ich im Internet lesen konnte und wird hoffentlich bald gelöst.

 

Update PinQam – Kamerabild in 90° Schritten drehen

Update

Zur Ablenkung vom Prüfungsstress habe ich PinQam heute eine kleine Erweiterung verpasst. Es ist nun möglich das Kamerabild in 90° Schritten zu drehen. Die Auswahl der Drehung muss vor der Aufnahme eines Fotos bzw. dem Aktualisieren des Live-Views getroffen werden.  Die Einstellung gilt dann für die gesamte Laufzeit des Programms und in allen Modi.

Rotation

 

Download

Den Download gibt es hier.

Das Programm kann auch über Github bezogen werden:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo git clone https://github.com/pinqin/pinqam.git
[/sourcecode]

Die Installation ist HIER beschrieben.

Filtereffekte und Videofunktion für PinQam

Es gibt zwei neue Funktionen für PinQam. Neben der Möglichkeit verschiedene Filtereffekte auszuwählen, können jetzt auch Videos aufgenommen werden.

Filtereffekte

Die Grundlage für die Filterauswahl ist raspistill. Dieses bietet 22 verschiedene Effekte an. Im Liveview kann man sich eine Vorschau mit dem aktuellen Filter anzeigen lassen. Mit einem Klick auf den Button Auslösen wird das Foto mit dem gewählten Filter aufgenommen. Gespeichert wird das Foto im PinQam Verzeichnis im Unterverzeichnis Filtereffekte.

Videofunktion

Für die Videofunktion wird Raspivid benutzt. Dieses bietet einige Funktionen für die Videoaufnahme an. Es kann sich wieder im Liveview eine Vorschau angezeigt werden lassen. Vor der Videoaufnahme können noch Einstellungen vorgenommen werden.

Es können folgende Eigenschaften geändert werden:

  • Breite
  • Höhe
  • Bitrate
  • Aufnahmedauer
  • FPS

Video

Das Video wird im Verzeichnis PinQam im Unterverzeichnis Video als *.h264 gespeichert. Ansehen kann man sich dieses anschließend mit dem unter Raspian vorinstallierten omxplayer.

Hierzu muss man in das Videoverzeichnis wechseln und folgendes auf der Konsole eingeben:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
omxplayer video_name.h264
[/sourcecode]

Download

Den Download gibt es hier.

Das Programm kann auch über Github bezogen werden:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo git clone https://github.com/pinqin/pinqam.git
[/sourcecode]

Die Installation ist HIER beschrieben.

PinQam Update – Speicherort wählen

Aufgrund von einigen Anfragen habe ich PinQam um eine Funktion erweitert. Es ist nun möglich den Speicherort selbst zu wählen.

Standardmäßig ist /home/“user“/Desktop/PinQam der Speicherort.

Des Weiteren werden die Fotos nun in den Ordnern Zeitraffer, Webcam und Liveview organisiert.

Download und Installation wie HIER beschrieben.

 

PinQam Update – Motivprogramme und Webcam

Update

Ich habe heute eine neue Version von PinQam hochgeladen. Das Tool hat zwei neue Funktionen bekommen. Motivprogramme und Webcam.

Motivprogramme

Unter dem Reiter Motivprogramme hat man die Möglichkeit zwischen verschiedenen Voreinstellungen zu wählen. Nach einem Klick auf Auslösen wird das Foto im Verzeichnis PinQam auf dem Desktop gespeichert. Des weiteren kann über den Button Aktualisieren eine Vorschau des Fotos mit der gewählten Voreinstellung im Live-View Fenster angezeigt werden.

Motivprogramme

Es kann zwischen 9 Einstellungen gewählt werden:

  • antishake
  • automatisch
  • Feuerwerk
  • heller Hintergrund
  • Langzeitbelichtung
  • Nachtaufnahme
  • Schnee
  • Sport
  • Strand

Webcam

Unter dem Reiter Webcam kann die Raspicam als Webcam gestartet werden. Es wird alle 3 Sekunden ein Foto gemacht und dargestellt. Zusätzlich wird ein Zeitstempel des letzten Fotos angezeigt.

Webcam

Download

Den Download gibt es hier.

Das Programm kann auch über Github bezogen werden:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
git clone https://github.com/pinqin/pinqam.git
[/sourcecode]

Die Installation ist HIER beschrieben.

PinQam um Timelapse-Funktion erweitert

Update

PinQam hat heute ein Update bekommen. Neben der manuellen Bedienung der Kamera ist es jetzt auch möglich Zeitrafferaufnahmen anzufertigen. Die Aufnahmen werden im Verzeichnis Zeitraffer gespeichert und fortlaufend nummeriert.

DownLoad: PinQam

PinQam mit TimelapseCode

[sourcecode language=“python“ wraplines=“false“ collapse=“true“]
#!/usr/bin/python

from PyQt4 import QtCore, QtGui
from gui_pinqam import Ui_MainWindow as Dlg
import sys
import os
import getpass
import time

#Ordner anlegen
if not os.path.exists(‚/home/’+getpass.getuser()+’/Desktop/PinQam/‘):
    command = ‚mkdir /home/$USER/Desktop/PinQam/‘
    os.system(command)

#Zeitraffer – Ordner anlegen
if not os.path.exists(‚/home/’+getpass.getuser()+’/Desktop/PinQam/Zeitraffer‘):
    command = ‚mkdir /home/$USER/Desktop/PinQam/Zeitraffer‘
    os.system(command)

class MainWindow(QtGui.QDialog, Dlg):
    
    def __init__(self):
        QtGui.QDialog.__init__(self)
        self.setupUi(self)

        #Buttons
        self.connect(self.btnAkt, QtCore.SIGNAL("clicked()"), self.aktualisieren)
        self.connect(self.btnAkt_2, QtCore.SIGNAL("clicked()"), self.aktualisieren_timelapse)
        self.connect(self.btnAusl, QtCore.SIGNAL("clicked()"), self.takePicture)
        self.connect(self.btnClear, QtCore.SIGNAL("clicked()"), self.clear)
        self.connect(self.btnClose, QtCore.SIGNAL("clicked()"), self.close)
        self.connect(self.btnClose_2, QtCore.SIGNAL("clicked()"), self.close)
        self.connect(self.btnStart, QtCore.SIGNAL("clicked()"), self.Start)

        #Progressbar auf 0 setzen
        self.progressBar.setValue(0)
        
        
    def aktualisieren(self):            
        #Werte einlesen
        sharpness   = self.boxSharpness.value()
        contrast    = self.boxContrast.value()
        brightness  = self.boxBrightness.value()
        saturation  = self.boxSaturation.value()
        iso = self.boxIso.value()

        command = ‚raspistill -t 300 -sh %i -co %i -br %i -sa %i -ISO %i -w 256 -h 192 -o /home/’+getpass.getuser()+’/Desktop/PinQam/liveview.jpg -n‘
        os.system(command % (sharpness, contrast, brightness, saturation, iso))
        
        #Foto im Liveview anzeigen
        self.labLive.setPixmap(QtGui.QPixmap(‚/home/’+getpass.getuser()+’/Desktop/PinQam/liveview.jpg‘))

    def aktualisieren_timelapse(self):
        command = ‚raspistill -t 300 -w 256 -h 192 -o /home/pi/Desktop/PinQam/liveview_timelapse.jpg -n‘
        os.system(command)

        #Foto im Liveview anzeigen            
        self.labLive_2.setPixmap(QtGui.QPixmap(‚/home/’+getpass.getuser()+’/Desktop/PinQam/liveview_timelapse.jpg‘))

    def takePicture(self):
        #Werte einlesen
        sharpness   = self.boxSharpness.value()
        contrast    = self.boxContrast.value()
        brightness  = self.boxBrightness.value()
        saturation  = self.boxSaturation.value()
        iso = self.boxIso.value()

        command = ‚raspistill -t 300 -sh %i -co %i -br %i -sa %i -ISO %i -o /home/’+getpass.getuser()+’/Desktop/PinQam/Foto.jpg -n‘
        os.system(command % (sharpness, contrast, brightness, saturation, iso))

    def Start(self):
        #Werte einlesen
        zeitraum    = self.boxZeitraum.value()
        bilderzahl  = self.boxAnzahl.value()
        zeiteinheit = 0

        #Zeitraum und Zeiteinheit bestimmen
        if self.radioSec.isChecked():
            zeitraum *= 1000
            zeiteinheit = zeitraum / bilderzahl
           
        elif self.radioMin.isChecked():
            zeitraum *= 1000 * 60
            zeiteinheit = zeitraum / bilderzahl   

        elif self.radioHour.isChecked():
            zeitraum *= 1000 * 3600
            zeiteinheit = zeitraum / bilderzahl

        #Setup Progressbar
        self.progressBar.setMinimum(1)
        self.progressBar.setMaximum(bilderzahl)

        #Zaehlervariable definieren
        i=1

        #Time Lapse – Schleife
        while bilderzahl>0:
            bilderzahl -=1
            command = ‚raspistill -t 300 -o /home/’+getpass.getuser()+’/Desktop/PinQam/Zeitraffer/Zeitraffer%i.jpg.jpg -n &‘
            os.system(command % (i))
            self.progressBar.setValue(i)
            time.sleep(zeiteinheit/1000)
            i+=1
        
    def clear(self):
        self.boxSharpness.setValue(0)
        self.boxContrast.setValue(0)
        self.boxBrightness.setValue(0)
        self.boxSaturation.setValue(0)
        self.boxIso.setValue(100)

    def close(self):
        exit()
        
app = QtGui.QApplication(sys.argv)
dialog=MainWindow()
dialog.show()
sys.exit(app.exec_())
[/sourcecode]

 

PinQam – Steuertool für die RaspiCam

Was ist PinQam?

Um die manuelle Benutzung der RaspiCam zu vereinfachen, habe ich ein kleines Tool geschrieben. Dieses ermöglicht es, die Einstellungen der RaspiCam manuell vorzunehmen und sich anschließend eine Vorschau anzeigen zu lassen. Ist man mit dem Ergebnis zufrieden, kann ausgelöst werden und das Foto wird im Ordner PinQam auf dem Desktop gespeichert.

PinQam GUI

Download von Github

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
git clone https://github.com/pinqin/pinqam.git
[/sourcecode]

Vorraussetzungen

Vorraussetzungen für die Nutzung des Tools sind:

  • RaspberryPi
  • eine angeschlossene RaspiCam
  • pyqt4

Installation

Sollte pyqt4 nicht installiert sein, wird dies wie folgt gemacht:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo apt-get install python-qt4
[/sourcecode]

Seit der Umstellung auf die PiCamera Bibliothek ist es noch notwendig diese und die rpi.GPIO zu installieren. Vielen Dank an MetaKnight für den Hinweis!

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo apt-get install python-picamera python3-picamera python-rpi.gpio
[/sourcecode]

Alle Dateien von PinQam müssen heruntergeladen und in einen beliebigen Ordner kopiert werden. Anschließend müssen wir noch die Berechtigungen anpassen:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo chmod 0755 pinqam_prog.py
[/sourcecode]

Nun kann das Programm gestartet werden:

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
./pinqam_prog.py
[/sourcecode]

Bei den letzten 2 Befehlen ist darauf zu achten, dass man sich in dem Verzeichnis befindet, in dem sich die Dateien von PinQam befinden.

Inbetriebnahme des Kameramoduls – RaspiCam

Montage

Das Kameramodul wird über die CSI – Schnittstelle mit dem RaspberryPi verbunden. Dieser befindet sich zwischen dem Ethernet- und dem HDMI-Port. Um das Flachbandkabel des Kameramoduls anzuschließen, muss der schwarze Teil der CSI-Schnittstelle nach oben gezogen werden. Anschließend kann das Flachbandkabel mit der blauen Markierung in Richtung Ethernet-Port in den Steckverbinder geschoben werden. Zum Fixieren wird nun der schwarze Steckverbinder wieder nach unten gedrückt.

RaspiCam

Aktivierung und Inbetriebnahme

Nachdem das Kameramodul verbunden ist, kann der Raspberry eingeschalten werden. Das System sollte auf dem aktuellen Stand sein. Ein Upgrade des Systems macht man mit

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo apt-get update
sudo apt-get upgrade
[/sourcecode]

Aktiviert wird das Modul im Konfigurationsassistent. Diesen ruft man mit

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
sudo raspi-config
[/sourcecode]

auf. Hier wählt man Punkt 5 „Enable Camera“ mit Hilfe der Pfeiltasten an und bestätigt mit Enter. Im darauffolgenden Fenster bewegt man den Cursor mit den Pfeiltasten auf Enabled und bestätigt wieder mit Enter. Das Kameramodul ist nun aktiviert. Den Assistenten verlässt man nun über Finish. Im Anschluss wird man gefragt, ob ein Reboot durchgeführt werden soll. Hier bestätigt man mit Ja.

Test des Kameramoduls

Um einen Test des Kameramoduls durchzuführen, kann folgender Befehl genutzt werden.

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
raspistill -o test.jpg
[/sourcecode]

Nun wird für 5 Sekunden das Bild des Kameramoduls angezeigt und anschließend wird ein Foto gemacht. Das Foto wird unter dem angegebenen Namen gespeichert. Der Zielort ist hier der Ort, an dem man sich im Terminal befindet.

Der Befehl kann wie folgt angepasst werden, um zum Beispiel das aufgenommene Foto auf dem Desktop zu speichern. „pi“ ist der Benutzer und muss ggf. noch angepasst werden.

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
raspistill -o /home/pi/Desktop/test.jpg
[/sourcecode]

Weitere Funktionen

Alle Funktionen kann man aus der RaspiCam Dokumentation entnehmen. Interessant für den Anfang könnten noch Video- und Zeitrafferaufnahmen sein.

Videoaufnahmen

Ein Video wird wie folgt aufgenommen

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
raspivid -o test.h264 -t 5000
[/sourcecode]

Der Speicherort kann wie bei der Fotoaufnahme auch hier angepasst werden. Die Dauer des Videos wird mit -t in Millisekunden angegeben. Für das Beispiel wären das 5000 ms (Entspricht 5 Sekunden).

Zeitrafferaufnahmen

Für eine Zeitrafferaufnahme nutzt man folgenden Befehl

[sourcecode language=“python“ wraplines=“false“ collapse=“false“]
raspistill -tl 1000 -t 20000 -o foto%04d.jpg
[/sourcecode]

Mit dem Zusatz -tl gibt man vor, wann ein Foto gemacht werden soll. In diesem Beispiel ist das alle 1000 ms (jede Sekunde).  Bei -t gibt man die Dauer des Zeitraffers an. In diesem Beispiel sind das 20000 ms (20 Sekunden). Auch hier kann nach -o wieder der Speicherort angepasst werden. Mit %04d definiert man, dass die Dateinamen der Einzelaufnahmen eine 4-stellige fortlaufende Nummerierung bekommen.