Schlagwort-Archive: Python

Raspberry Pi Wetterdatalogging Fortsetzung

Raspberry Webcam Software Ausbau

Ich habe das bestehende Steckbord (Wetterdatensammler, siehe älterer Beitrag) durch eine Lötleiste ersetzt und wieder den DHT11 Temperatur/Feuchtigkeitssensor, DS18B20 Temperatursensor und den BMP085 Luftdrucksensor verbaut. Dadurch wurde die Messplatform wesentlich kleiner und robuster.

Foto

In diesem Beitrag beschreibe ich das Datalogging mittels dem Luftdrucksensor BMP085.

Die Messwerte des Sensors sollen in einer Round Robin Datenbank gespeichert werden. Mit Hilfe dieser Datenbank sollen Kurven geplottet und als PNG-Datei auf dem Webserver abgelegt werden, um sie dann über eine Html-Seite abrufen zu können. Somit benötigen wir auf dem Raspberry einen Webserver und das RRD-Tool. Um das RRD-Tool über Python ansprechen zu können, gibt es eine Erweiterung. Das hat die ganze Sache sehr einfach gestaltet (Details):

$ sudo apt-get install apache2 rrdtool python-rrd

Ist das erledigt, erstellt ihr einen Ordner im WWW-Verzeichnis eures Servers, wo ihr später die Grafiken ablegt:

$ mkdir /var/www/plots

Des Weiteren habe ich in das gleiche Verzeichnis eine ganz einfache HTML-Datei hinterlegt, welche schon die richtigen Links zu den Grafiken beinhaltet und sich alle 60 Sekunden automatisch neu lädt:

https://www.leben-zwo-punkt-null.com/wp-content/gallery/raspberry-pi/index_html.png

Das Python-Script mit dem Hauptprogramm habe ich unter /home/pi/BMP085/ abgelegt, da sich dort auch die Bibliothek zum Ansprechen des Sensors befindet. Als globale Variablen habe ich den Datenbank-Name, den Filename, den Zeitintervall für die Messung, den Pfad für die Grafiken und die Schleifenbedingung deklariert.

Das Hauptprogramm ist – wie ich finde – selbsterklärend. Es werden die drei Werte ermittelt, anschließend in die RRD-Datei geschrieben und danach wird die Funktion zum Plotten der Grafik aufgerufen. Wichtig ist die richtige Höhe über Meer (Wohnort bei mir 510 m) einzutragen in der Formel. (Zeile 105!):

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#!/usr/bin/python
# -*- coding: utf-8 -*-

# Library für den Sensor
from Adafruit_BMP085 import BMP085

import rrdtool
import sys
import time
import Adafruit_DHT

# Festlegung globaler Variablen
dbname = 'bmp085'                                               # Name fuer Grafiken etc
filename = dbname +'.rrd'                                       # Dateinamen mit Datum
steps = 60                                                      # Zeitintervall fuer die Messung in Sekunden
path = '/var/www/plots/'                                        # absoluter Pfad zum Ablegen der Plots
i = 0                                                           # Schleifenbedingung für den Hauptteil
DHT_TYPE = Adafruit_DHT.DHT11
DHT_PIN = 4
humidity, temp = Adafruit_DHT.read(DHT_TYPE, DHT_PIN)

# RRD-Datenbank anlegen, wenn nicht vorhanden
try:
    with open(filename): pass
    print "Datenbankdatei gefunden: " + filename
    i=1
except IOError:
    print "Ich erzeuge eine neue Datenbank: " + filename
    ret = rrdtool.create("%s" %(filename),
                         "--step","%s" %(steps),
                         "--start",'0',
                         "DS:bmp085_temp:GAUGE:2000:U:U",
                         "DS:bmp085_pres:GAUGE:2000:U:U",
                         "DS:bmp085_alti:GAUGE:2000:U:U",
						 "DS:bmp085_feuchte:GAUGE:2000:U:U",
                         "RRA:AVERAGE:0.5:1:2160",
                         "RRA:AVERAGE:0.5:5:2016",
                         "RRA:AVERAGE:0.5:15:2880",
                         "RRA:AVERAGE:0.5:60:8760",)
    i=1                          

# Sensor initialisieren
bmp = BMP085(0x77, 3, debug=False)

# Bildschirmausgabe
def ausgabe(d,u,t,p,a,f):
    sys.stdout.write(str('Datum: ') + d + '\n')
    sys.stdout.write(str('Uhrzeit: ') + u + '\n')
    sys.stdout.write(str('Temperatur:' ) + str(t) + '\n')
    sys.stdout.write(str('Luftdruck: ') + str(p) + '\n')
    sys.stdout.write(str('Höhenlage: ') + str(a) + '\n')
    sys.stdout.write(str('Feuchtigkeit: ') + str(f) + '\n')    

def plotten(a):

# Funktion zum Plotten der Grafiken
# a:   Wert, der geplottet werden soll
    
    # Beschriftung für die Grafiken festlegen
    if a == 'temp':
            title = 'Temperatur'
            label = 'in °C'
    elif a == 'pres':
            title = 'Luftdruck'
            label = 'in hPa'
    elif a == "alti":
            title = 'Hoehe'
            label = 'm über 0'
    elif a == "feuchte":
            title = 'Feuchtigkeit'
            label = 'in %'
                                              
                                                    
    # Aufteilung in drei Plots
    for plot in ['daily' , 'weekly', 'monthly']:
                                          
        if plot == 'weekly':
                 period = 'w'
        elif plot == 'daily':
                 period = 'd'
        elif plot == 'monthly':
                 period = 'm'
                                                                                                                                 
                                                                                         
        # Grafiken erzeugen                                                                                                                            
        ret = rrdtool.graph("%s%s_%s-%s.png" %(path,dbname,a,plot),
                             "--start",
                             "-1%s" %(period),
                             "--title=%s (%s)" %(title,plot),
                             "--vertical-label=%s" %(label),
                             '--watermark=Altstaetten',
                             "-w 800",
                             "--alt-autoscale",
			                 "--alt-y-grid",
			                 "--slope-mode",
                             "DEF:%s=%s:%s_%s:AVERAGE" %(a, filename, dbname, a),
                             "LINE1:%s#0000FF:%s_%s" %(a, dbname, a))

while i!=0:
    datum = time.strftime('%d %m %Y')
    uhrzeit = time.strftime('%H:%M:%S')
    
    # Messung von Temperatur, Druck, Luftfeuchte
    bmp085_temp=bmp.readTemperature()
    bmp085_pres=bmp.readPressure() / pow((1.0 - ( 510 / 44330.0 )), 5.255) / 100
    bmp085_alti=bmp.readAltitude(102600)
    bmp085_feuchte=humidity
     
    # Messwerte in die RRD-Datei schreiben
    from rrdtool import update as rrd_update
    ret = rrd_update('%s' %(filename), 'N:%s:%s:%s:%s' %(bmp085_temp, bmp085_pres, bmp085_alti, bmp085_feuchte));
    
    # Grafiken erzeugen
    print "Erzeuge Grafiken"
    plotten('temp')
    plotten('pres')
    plotten('feuchte')
    
    # Bildschirmausgabe der Messwerte
    ausgabe(datum,uhrzeit,bmp085_temp,bmp085_pres,bmp085_alti,bmp085_feuchte)
    
    # Warten, bis die neue Messung beginnt 
    print "Neue Messung startet in %s Sekunden" %(steps)
    time.sleep(steps)

Nach ein paar Stunden Testlauf bekam mein Auge dann die folgenden Graphen zu sehen und ich war vorerst zufrieden:

webserverBald schon kam der Wunsch auf, diese Grafiken auf Google Drive zu transportieren, um die Daten auch von extern einzusehen.

Dazu brauchen wir die halboffizielle Google Drive Application für Raspian unter:

https://github.com/odeke-em/drive

Wir erstellen auf dem Raspi zwei neue Ordner:

$ mkdir /home/pi/drive

$ mkdir /home/pi/drive/wetter

Jetzt klären wir ab welche Version von „drive“ wir für unseren Raspi benötigen:

$ cat /proc/cpuinfo | grep „model name“

model name : ARMv6-compatible processor rev 7 (v6l)

Bei mir läuft ein Raspberry Pi2+, d.h. es ist eine ARM6 v6 CPU. Unter URL sind die div. Versionen:

https://github.com/odeke-em/drive/releases/

Wir holen uns die richtige Version in meinem Fall:

$ sudo wget https://github.com/odeke-em/drive/releases/download/v0.3.8/drive_armv6 -O /usr/local/bin/drive

Das wird das Binaryfile „drive“ im Ordner /usr/local/bin downloaden. Jetzt noch ausführbar machen:

$ sudo chmod +x /usr/local/bin/drive

Jetzt initialisieren wir „drive“ und teilen ihm mit wo der Sync Ordner ist:

$ drive init /home/pi/drive

Beim initialisieren von „drive“ wird eine extrem lange URL von accounts.google.com herausgegeben. Diese kopieren wir und tragen sie im Browser eines anderen Computers mit eingeloggtem Google User Konto ein, das wir für diesen Zweck benützen möchten.
Die Frage, ob wir „drive“ erlauben auf das Google Konto zuzugreifen
beantworteten wir mit „yes“ und der Key String der dabei entsteht kopieren und im Raspi unter Verification Code eintragen.
Jetzt ist Google Drive bereit mit dem Raspi zu kommunizieren.
Statt nun die Daten jedesmal vom Webserver
in den Drive Ordner zu kopieren legen wir einen Link an:

$ ln -s /var/www/plots/ /home/pi/drive/wetter/

Jetzt geht’s los, wir wechseln in den Ordner wo die Daten sind:

$ cd /home/pi/drive

und laden die Daten hoch zu Google Drive:

$ sudo drive push wetter

Nach ein paar Sekunden sind die Grafiken auf Google Drive sichtbar.

Um den push Befehl zu automatisieren habe ich das bash script „wetter.sh“ geschrieben:

#!/bin/bash
cd /home/pi/drive
sudo drive push -quiet wetter
cd /home/pi

Das Script ausführbar machen:

$ sudo chmod +x /home/pi/wetter.sh

und mit crontab -e aktiviert (Alle 10 min ein push Befehl):

2,12,22,32,42,52 * * * * /home/pi/wetter.sh > /dev/null 2>&1

Wünsch viel Spass damit!

 

Advertisements

Raspberry als billige Webcam, Bewegungsmelder und Wetterdatensammler

Dieser Artikel beschreibt den Bau einer kostengünstigen Ueberwachungskamera mittels eines Raspberry PI als Mikrocomputer. Es werden Videos in HD Qualität bei Bewegung aufgezeichnet und mittels WiFI auf einen Cloud hochgeladen. Live – Bilder und Wetterdaten sind mittels Webbrowser auf Smartphone oder Computer jederzeit sichtbar. Normalerweise ist so eine Einrichtung ein Kostenfaktor, aber diese Lösung ist für ca. 100 chf machbar.

Ich wiederhole hier nochmals die Daten aus einem vorhergehenden Artikel, was wir bei diesem Projekt benötigen sind:

Einen Raspberry Pi mit 700Mhz ARM Prozessor und 512MB RAM bestückt. (Variante B Rev.2).

Als Betriebssystem verwende ich ein spezielles Linux Derivat, das bereits auf den ARM Prozessor abgestimmt ist. Das Raspian Image (zip File) kann von dieser Seite heruntergeladen und entpackt werden.

Nebst einem bestehenden PC mit SD-Card Reader, Netzwerkkabel, Wlan-Router habe ich folgende Hardware beschafft:

Steckernetzteil 5.25V 1.5A (Speziell für den Pi entwickelt)

8 GB SDHC Speicherkarte, Class 10 (Kingston, SanDisk,Transcend)

Miniature WiFi (802.11b/g/n) Modul für Raspberry Pi

PiNoIR Camera Modul mit Flachbandkabel

Steckbrett mit div Male/Female Kabeln, 10 kOhm Widerstand

DS18B20 Temperatursensor

BMP085 Luftdrucksensor

DHT11 Temperatur/Feuchtigkeitssensor

Dummy Ueberwachungskameragehäuse

Lieferbar z.B. Pi-Shop, Amazon, RS Component, Digitec

Webcam

Bei Betriebssystemen die auf Linux aufbauen kann man die gesamte Arbeit auf der Kommandozeile oder eben im Terminal erledigen. Wir stecken also die Speicherkarte in einen Computer oder Laptop und geben:

fdisk -l

Die SDHC Karte wird beispielsweise mit sdb1 angegeben, was darauf hinweist das wir die SDHC Karte mit sdb ansprechen.
Nun wechseln wir ins Directory wo sich unser entpacktes Raspian image befindet z.B.:

cd /home/user/download

Mit dem Befehl:

dd bs=4M if=xxx-wheezy-raspian.img of=/dev/sdb

kopieren wir das Image auf die SDHC Karte. Dies geht ca. 2 Minuten
Stecken Sie die Karte in Ihren Raspberry, verbinden Sie mit dem Netzwerkkabel und starten Sie den Raspi.
Finden Sie in Ihrem Router die IP Adresse heraus und gehen per SSH auf Ihren Raspi z.B. ssh pi@192.168.178.200 antworten Sie mit

yes und password raspberry

Jetzt sind Sie auf der Konsole vom Raspi und werden hier noch einige Aenderungen vornehmen:
Zuerst aktivieren wir das WiFi, indem wir die Datei folgendermassen anpassen z.B:

nano /etc/network/interfaces

auto lo
iface lo inet loopback
 iface eth0 inet dhcp
allow-hotplug wlan0
 iface wlan0 inet manual
 wpa-roam /etc/wpa_supplicant/wpa_supplicant.conf
 iface default inet static
 address  192.168.178.200
 netmask  255.255.255.0
 gateway  192.168.178.1

Die WPA Konfiguration für den WiFi Router noch eingeben, nano /etc/wpa_supplicant/wpa_supplicant.conf:


ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="Ihre SSID"
psk="Ihr WPA Code"
# Protocol type can be: RSN (for WP2) and WPA (for WPA1)
proto=WPA
# Key management type can be: WPA-PSK or WPA-EAP (Pre-Shared or Enterprise)
key_mgmt=WPA-PSK

# Pairwise can be CCMP or TKIP (for WPA2 or WPA1)
pairwise=TKIP

#Authorization option should be OPEN for both WPA1/WPA2 (in less commonly used $
auth_alg=OPEN
}

Wir starten den Raspi neu und prüfen, ob Wlan funktioniert ohne Ethernetkabel, dazu geben wir den Befehl ein: reboot
Falls Verbindung mit WiFi klappt geht’s weiter, ansonsten mit Ethernetkabel nochmals überprüfen, wo der Fehler liegt. Evtl muss SD Karte neu kopiert werden 😦
Mit ssh pi@192.168.178.200 sind wir mit WiFi wieder im Raspi und können noch die weiteren Befehle eingeben!
Jetzt updaten wir mal den Raspi:


sudo su
apt-get update
apt-get upgrade
apt-get install rpi-update
rpi-update
 

Wir konfigurieren den Raspi auf unsere Bedürfnisse und geben ein:

raspi-config

Expand Filesystem,Passwort ändern,Zeit,Sprache,Kamera ein, SSH ein, Optionen.Hostname etc.
Nun gehts weiter mit Zusatzsoftware installieren z.B Motion (Kamerasteuerung) Wir installieren zuerst das Standardpaket um alle Abhängigkeiten korrekt zu haben und ändern nachher auf eine Spezialversion (in Dropbox), die auf die Raspi Camera angepasst wurde:

apt-get install motion
cd /tmp
sudo apt-get install -y libjpeg62 libjpeg62-dev libavformat53 libavformat-dev libavcodec53 libavcodec-dev libavutil51 libavutil-dev libc6-dev zlib1g-dev libmysqlclient18 libmysqlclient-dev libpq5 libpq-dev
wget https://www.dropbox.com/s/xdfcxm5hu71s97d/motion-mmal.tar.gz
tar zxvf motion-mmal.tar.gz
sudo mv motion /usr/bin/motion
sudo mv motion-mmalcam.conf /etc/motion.conf
sudo nano /etc/default/motion

change line:

start_motion_daemon=yes

Weiter gehts:

sudo nano /etc/motion.conf
sudo chmod 664 /etc/motion.conf
sudo chmod 755 /usr/bin/motion
sudo touch /tmp/motion.log
sudo chmod 775 /tmp/motion.log

Im motion.conf ändern wir:nano /etc/motion.conf

daemon on
logfile /tmp/motion.log
width 640
height 480
framerate 2
pre_capture 2
post_capture 2
max_mpeg_time 600
fmpeg_video_codec msmpeg4
stream_localhost off

Da die SD Karte nicht viel Speicher hat werden wir später Videos auf einen Cloud hochladen.
In der Zwischenzeit eröffnen wir einen Pfad wo Fotos und Videos von Motion abgelegt werden:


mkdir /home/pi/Bilder  

Und im motion.conf ändern wir target dir /home/pi/Bilder

jetzt kann man motion starten:motion motion.conf >> LED rot leuchtet an Camera auf! Wir probieren Mal den Livestream im Webbrowser: http://192.168.178.200:8080 (8080 ist der Streamport den wir beliebig wählen können im motion.conf)


Nun Gehts weiter für die Sensoren: Billige digitale Temperatursensoren wie zb DS18B20 (siehe Amazon) 1-wire digital temperature sensor. Installation kann zb auf der linken Seite unten in der Webcam eingetragen werden Dazu die 1 wire anschlüsse installieren siehe hier http://www.raspberrypi-spy.co.uk/2013/03/raspberry-pi-1-wire-digital-thermometer-sensor/ Details und Verdrahtung auf einem Steckbrett sind dort gut dargestellt. Hier mein modifiziertes Programm:

 

nano sensor2motion.sh

#!/bin/bash

#########################################################################

#Name: sensor2motion.sh
#Subscription: This script fetches the tempreature from a sensor and send the forecast to motion
#by A. Laub
#andreas[-at-]laub-home.de
#Set the language
export LANG="de_DE.UTF-8"
#Load the Pathes
export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin 

#set the variables:

TEMP1=$(echo " $(grep 't=' /sys/bus/w1/devices/w1_bus_master1/28-00000585d789/w1_slave | awk -F't=' '{print $2/1000}')" )

#start the things

TEXT="Aussentemperature: $TEMP1 C"

# Set on Camera Image0

wget -q --delete-after "http://localhost:8081/0/config/set?text_left=$TEXT"

 im crontab -e

fügen wir diese zeile ein:

* * * * /home/pi/sensor2motion.sh*

Wir werden nun einige Programme in Python verwenden um weitere Schritte zu unternehmen dazu überprüfen wir, ob die entsprechenden Programme schon auf dem Raspi installiert sind:

apt-get install python
apt-get install python-pip
pip2 install gdata

Um Bilder und Videos im Google Drive hochzuladen kann dieses Python Programm weiterhelfen, Details siehe:

http://jeremyblythe.blogspot.pt/2012/06/motion-google-drive-uploader-and.html

Beim update von Raspian siehe uname -a! Falls Kernel grösser 3.18 dann sollte Raspi Config gemäss:

https://learn.adafruit.com/adafruits-raspberry-pi-lesson-4-gpio-setup/configuring-i2c

angepasst werden!

Um Feuchte und Temperatur zu messen habe ich folgende Anleitung angewendet funktioniert einwandfrei:

https://chrisbaume.wordpress.com/2013/02/10/beer-monitoring/

Damit ist ein tolles Tool aus der Webcam geworden! Viel Spass