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

Arduino – Get started!

Gerade eben habe ich mein neues Spielzeug in Betrieb genommen. Ich bin seit ein paar Tagen Besitzer eines Arduino UNO R3. Die Entwicklungsumgebung Arduino 1.0.6 macht auf den ersten Blick einen ordentlichen Eindruck und bringt zahlreiche Code Examples mit, was für den Einstieg sehr gut ist.

Aber das beste ist natürlich, dass es die Software auch für den MAC gibt!

Und was macht man als erstes? Richtig! Eine Led zum leuchten bringen!

Benötigt wird:

  • Arduino
  • Taster (im Beispiel ein Öffner)
  • LED mit Vorwiderstand

Aufgabe:

Beim Betätigen des Tasters soll die LED leuchten!

Aufbau

Steckplatine

 

Code

Der Sketch sieht wie folgt aus:

/*
- Einfaches Projekt zur Darstellung des Setups der Ein- / Ausgänge
- Durch betätigen des Tasters wird eine LED eingeschalten
- ACHTUNG: Im Beispiel handelt es sich bei dem Taster um einen Öffner!
*/

//Variablendeklaration
int Button=1;
const int LED_1 = 12;
const int Btn = 13;

//Setupfunktion für die IO's
void setup()
{
pinMode(Btn, INPUT);
pinMode(LED_1, OUTPUT);
}

//Hauptfunktion
void loop()
{
Button = digitalRead(Btn);

if (Button == 0)
{
digitalWrite(LED_1, HIGH);
}

else
{
digitalWrite(LED_1, LOW);
}
}

 

 

Luftdrucksensor BMP085 am RaspberryPi B+

Dieses kleine Tutorial soll zeigen, wie man den Sensor BMP085 mit dem RaspberryPi B+ verheiratet. Folgende Werte können mit diesem später ausgewertet werden:

  • Barometrischer Luftdruck
  • Temperatur
  • Höhe

Vorerst geht es nur um die Inbetriebnahme des Sensors. Eine Verwendung in einem eigenem Projekt/Programm folgt später.

Das Datenblatt des Chips gibt es HIER.

 

Beschaltung

Der Sensor  wird über den I2C-Bus an den RaspberryPi angeschlossen. In diesem Beispiel speziell an den RaspberryPi B+. Das folgende Schema zeigt das Pinout des RPi B+ und die dazugehörigen Bezeichnungen der GPIO´s.

GPIO Expansion

Quelle: http://www.raspberrypi.org/documentation/hardware/raspberrypi/schematics/Raspberry-Pi-B-Plus-V1.2-Schematics.pdf

Es werden folgende Pin´s benutzt:

  • Pin 01 – 3,3VDC
  • Pin 03 – GPIO2 (SDA1)
  • Pin 05 – GPIO3 (SCL1)
  • Pin 39 – Ground

Der Sensor wird gemäß der Beschriftung auf der Platine an den RPi angeschlossen.

Steckplatine

Steckplatine

 

Schritt 1: I2C-Bus aktivieren

Zuerst müssen die zwei Kernelmodule i2c-bcm2708 und i2c-dev aktiviert werden. Das geschieht, in dem sie in die Datei /etc/modules eingetragen werden. Mit folgendem Kommando wird die Datei geöffnet:

sudo nano /etc/modules

 

Jetzt werden die beiden Zeilen hinzugefügt:

i2c-bcm2708
i2c-dev

 

Im Anschluss kann mit CTRL+O gespeichert, der Dateiname mit ENTER bestätigt und die Datei mit CTRL+X geschlossen werden.

Außerdem müssen zwei Blacklisteinträge in der Datei /etc/modprobe.d/raspi-blacklist.conf gelöscht oder auskommentiert werden. Also auch diese Datei öffnen

sudo nano /etc/modprobe.d/raspi-blacklist.conf

 

und die Beiden Einträge auskommentieren

#blacklist spi-bcm2708
#blacklist i2c-bcm2708

 

Weil der Sensor später mit Python angesprochen werden soll, werden gleich noch 2 Module installiert, welche die Arbeit mit dem I2C-Bus unter Python ermöglichen.

sudo apt-get install python-smbus i2c-tools

 

Jetzt muss der RPi neu gebootet werden!

Nach dem Reboot sollte das Kommando

sudo i2detect -y 1

 

folgende Ausgabe bringen

i2detect -y 1

Der Sensor ist nun erfolgreich mit dem RPi verbunden und kann verwendet werden.

 

Schritt 2: Testen des Sensors

Zum Testen des Sensors benutze ich die BMP Python Library von Adafruit und ein kleines Testtool. Zuerst wird die Library mit folgenden Kommandos installiert:

git clone https://github.com/adafruit/Adafruit_Python_BMP.git
cd Adafruit_Python_BMP
sudo python setup.py install

 

Im Anschluss wird das Testtool gestartet und sollte eine ähnliche Ausgabe bringen

cd examples
sudo python simpletest.py

 

simpletest.py

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]