Schlagwort-Archive: Python

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.

USB-Mini-Scope-Modul

Da ich immer wieder vor dem Problem stand, dass ich kein Oszi besitze, habe ich mir das USB-Mini-Scope-Modul von ELV als Bausatz bestellt. Der Bausatz war schnell zusammengelötet und die Inbetriebnahme ging gut von der Hand. Gleich vorweg, dieses Gerät ist natürlich keine hoch präzise Messtechnik! Für meine Anwendung ist das Modul allerdings ausreichend und auch preislich interessant (39,95€ ohne Tastkopf).

1. Test

Bestätigen kann ich, dass es besser ist die Trimmpotis durch Spindelpotis zu ersetzen, damit der Abgleich komfortabler durchgeführt werden kann.

Gekauft habe ich mir dieses Modul hauptsächlich, um Signale zu kontrollieren, welche ich mit dem RaspberryPi generiere und über die GPIO-Ports ausgebe. Zum Testen habe ich folgendes Signal verwendet:

[sourcecode language=“python“ wraplines=“false“ collapse=“true“]
import RPi.GPIO as GPIO
import time

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup (7, GPIO.OUT)

while (True):

GPIO.output(7, True)
time.sleep(0.005)
GPIO.output(7, False)
time.sleep(0.005)

GPIO.output(7, True)
time.sleep(0.01)
GPIO.output(7, False)
time.sleep(0.01)
[/sourcecode]

Mit der mitgelieferten Software konnte ich folgenden Graphen aufzeichnen:
TestgraphUm die Signale bewerten zu können, kann man mit Hilfe von Schiebereglern die Amplitude, bzw. Periodendauer anfahren und bekommt die Werte angezeigt.

 

Bei der Periodendauer weicht das Ergebnis um 1Hz ab, was evtl. auch an time.sleep liegt. Mir ist nicht bekannt, wie genau der „Schlaf“ ist.

Ich konnte das Modul auch gut einsetzen, um die Funktion des Ultraschallsensors HC SR04 am Nibobee zu kontrollieren und würde sagen, dass das Modul ein nettes kleines Werkzeug für den Bastler ist.

Technische Daten

Spannungsversorgung: USB-powered
Stromaufnahme: 100 mA
Messkanäle: 1
Messbereich: -10 bis +10 V
Grenzfrequenz: ca. 200 kHz
Samplerate: max. 8 MS/s
Eingangswiderstand: 1 MΩ
Spannungsskalierung: 100 mV/DIV, 200 mV/DIV, 400 mV/DIV, 1 V/DIV, 2 V/DIV
Zeitskalierung: 1 µs/DIV–5 s/DIV
Triggerungsarten: Auto, Normal,Single
Triggerflanke: Steigend/fallend/beide
Messeingang: BNC
Abm. (B x H x T): 109 x 58 x 24 mm

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 der GPIO-Ports des RaspberryPi

Um die GPIO-Ports in Betrieb nehmen zu können werden folgende Pakete benötigt:

  • Python Entwicklungstools
  • Python GPIO Library

Die GPIO – Ports können auch ohne der Library benutzt werden. Allerdings macht sie die Arbeit viel komfortabler.

 

Schritt 1: Installation der Python Entwicklungstools

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

 

Schritt 2: Installation der Python GPIO Library

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

 

Schritt 3: Code

Der Code wird unter dem Dateinamen gpio.py gespeichert. Dieser kann natürlich angepasst werden.

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

import time
import RPi.GPIO as GPIO

#Setup der GPIO-Ports
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)

#Definition der GPIO-Pins 3, 5, 7 als Ausgang
GPIO.setup(3, GPIO.OUT)
GPIO.setup(5, GPIO.OUT)
GPIO.setup(7, GPIO.OUT)

#Endlosschleife
while True:
#GPIO 3 auf HIGH setzen, 2 sec warten und auf LOW setzen
GPIO.output(3, GPIO.HIGH)
time.sleep(2)
GPIO.output(3, GPIO.LOW)

#GPIO 5 auf HIGH setzen, 2 sec warten und auf LOW setzen
GPIO.output(5, GPIO.HIGH)
time.sleep(2)
GPIO.output(5, GPIO.LOW)

#GPIO 7 auf HIGH setzen, 2 sec warten und auf LOW setzen
GPIO.output(7, GPIO.HIGH)
time.sleep(2)
GPIO.output(7, GPIO.LOW)

[/sourcecode]

 

Schritt 4: Script starten

Das Script wird über den Terminal gestartet.

ACHTUNG: Man muss sich im selben Ordner befinden, in dem auch das Script gespeichert ist. Am einfachsten kann man das sicherstellen, indem man den Ordner öffnet in dem sich das Script befindet und dann über

„Werkzeuge“ -> „Aktuellen Ordner im Terminal öffnen“

den Terminal startet und folgendes eingibt.

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

Gestoppt werden kann das Script mit CTRL + C.

Um den Code zu testen kann man sich einen kleinen Tester mit LED´s aufbauen. Die LED´s sind wie folgt anzuschließen:

gpio

Die Spannung an den GPIO´s beträgt 3,3V. Die Vorwiderstände berechnen sich wie folgt.