Archiv für den Monat: April 2014

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.