Archiv der Kategorie: Tool

Neues Tool in Arbeit – PinsQan

Bei PinsQan handelt es sich um ein kleines Projekt mit einigen nützlichen Funktionen. Es steckt noch in den Kinderschuhen und ihr seit alle herzlich eingeladen die Entwicklung voran zu bringen.

PinsQan ist für mich ein Projekt um tiefer in die C# Programmierung ein zu steigen und hat keinen Anspruch ein kommerzielles Tool zu werden. Bitte geht also mit diesem Hintergrundwissen an die Benutzung und Bewertung der Software.

Bei Interesse testet das Tool einfach und gebt mir hier Feedback. Ich werde unter diesem Beitrag eine Bug-List führen und mich den Problemen nach und nach annehmen.

Wünsche für neue Funktionen sind natürlich genau so gern gesehen.

Die Grundfunktionen

  • Netzwerkscanner
  • WLAN-Scanner (in Arbeit)
  • SSH-Command an Netzwerk Client senden
  • RaspberryPi-GPIO Lesen und schreiben

Download

Die aktuelle Version findet ihr im Bereich Download

Screenshots

Bug-List

  • Netzwerkscanner funktioniert nur mit /24 Netzwerk

To-Do

  • Profile für SSH-Commands
  • SSH-Connection halten
  • GPIO Status Read Input/Output/Status
  • SSH-Commands + Ergebnis/Antwort in Ausgabe aufnehmen

Historie

  • 01.01.2018
    • Es wurden einige Klassen erstellt, um den Code besser lesbar zu machen
    • Überarbeitung der GUI
      • Progressbar, Button Connect und Button Disconnet entfernt
      • Button „GPIO Write“ hinzugefügt
      • Alle gesetzten Checkboxen werden gelesen und die GPIO’s während einer SSH-Verbindung geschrieben
      • Hinzufügen von RPi-Modellen vorbereitet
    • Überarbeitung der Console
      • Feedback zum Schreiben der GPIO’s in

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.