FHEM auf dem Raspberry Pi und EnOcean Pi 868 installieren

Beschreibung zum Einrichten von Fhem auf dem Raspberry Pi:

Der Raspberry Pi dient als Steuerzentrale.
Die Kommunikation mit dem Sensoren und Aktoren erfolgt über das Modul EnOcean Pi.

• Zuerst habe ich Raspian neu installiert um sicher zu sein, dass es keine Konflikte zwischen den Programmen gibt.
• Nach dem Booten einloggen: User: pi; Passwort: raspberry
• Das Setup.Menü mit "sudo raspi-config" aufrufen
• Tastatur, Zeitzone... einstellen
• Neuste Firmware installieren:
• sudo apt-get update
• sudo apt-get upgrade
• sudo apt-get install rpi-update
• sudo reboot -i
• Abschalten des seriellen Ports: (Erfolgt erst nach einem Neustart)
• sudo wget https://raw.github.com/lurch/rpi-serial-console/master/rpi-serial-console -O /usr/bin/rpi-serial-console && sudo chmod +x /usr/bin/rpi-serial-console
• sudo rpi-serial-console disable
• sudo reboot -i
• rpi-serial-console status => Serial console on /dev/ttyAMA0 is disabled
• Installieren und starten des FHEM-Server:
• Installieren von Perl und der FHEM-Bibliothek:
• sudo apt-get install perl libdevice-serialport-perl libio-socket-ssl-perl libwww-perl
• sudo apt-get install –f
• Installieren von FHEM im Verzeichnis /opt/fhem:
• wget http://fhem.de/fhem-5.5.deb
• sudo dpkg --install fhem-5.5.deb
• Starten des Programms:
• http://<Raspberry_Pi_IP>:8083/fhem im Browser (auf dem PC) starten

Lasst Euch nicht, wie ich, verwirren. Der Menüpunkt "EnOcean" erscheint erst nachdem ein Sensor oder Aktor angelernt wurde.

Hilfe gibt es unter fhem.de oder im Forum.

Auch wenn die Software erst neu installiert wurde: update durchführen!

Zugriff auf die Dropbox mit dem RaspberryPi

Anbei ein Hinweis auf die schöne Site von alex. Von dort ist auch dieser Tipp. Das Wichtigste habe ich hier übernommen und auf Deutsch übersetzt. Ich will mich ja nicht mit fremden Federn schmücken.

Als erstes benötigt man einen Dropbox-Account. 
- Den gibt es hier.

Dann kommt die Software von Andrea Fabrizi auf den Pi.
- Entweder direkt von GitHub, da findet Ihr auch eine ausführliche Anleitung,
- oder von der Linux-Ebene des Pi aus:
     cd ~
     git clone https://github.com/andreafabrizi/Dropbox-Uploader.git

Die Befehlszeile einfach markieren, mit <strg>+c kopieren und in der Terminalsitzung mit der rechten Maustaste klicken. Dann muss diese nicht abgetippt werden.

Dann in das neu erstellte Verzeichnis wechseln:
     cd Dropbox-Uploader

Nun muss auf der Dropbox eine APP installiert werden:
- Auf der Dropbox einloggen und dann diese Seite aufrufen: https://www.dropbox.com/developers/apps
- Dann "Create app" drücken:
- “Dropbox API app” auswählen,
- App mit “Files and datastores” definieren
- Als nächstes geht es um die Zugriffsrechte: "No" gibt vollen Zugriff auf die Dropbox.
- "All file types" gibt Zugriff auf alle Dateitypen.
-  Der App eine Namen geben und noch mal "Create app" drücken:
- Jetzt auf dem Pi ./dropbox_uploader.sh starten
- Das Programm fragt nun nach dem "App key:" und dem "App secret:". Beides von der inzwischen geöffneten Internetseite kopieren.
- Zugriffsrechte auswählen: "f" für Vollzugriff.
- Noch mal checken und mit "y" bestätigen.
- Es wird nun ein Token zur Identifikation angefordert. Dieses im Browser eingeben und "zulassen" drücken.
Hierzu die Zeile in der Terminalsitzung markieren, mit linker Maustaste kopieren und dann mit <strg>-v einfügen.
- Zum Schluss noch mal in der Terminalsitzung bestätigen.

Ausführen:
     /home/pi/Dropbox-Uploader/dropbox_uploader.sh upload /home/pi/dateiname dateiname
Lädt die Datei "dateiname" in das Root-Verzeichnis der Dropbox. Klappt auch mit dort eingerichteten Ordnern.

Oder als Programm in Python:

#!/usr/bin/env python3

from os import system

prog = "/home/pi/Dropbox-Uploader/dropbox_uploader.sh "
  # Pfad und Programmname
befehl = "upload"
  # Befehl an das Programm
von =  "/home/pi/blog.py"
  # Pfad und Dateiname auf dem Pi
nach = "blog.py"
  # Pfad und Dateiname auf der Dropbox

system(prog + befehl + " " + von + " " + nach)
  # Führt den Befehl auf der Systemebene aus

Weitere Befehle:
download, move, copy, mkdir ... mehr gibt es auf GitHub.

Eventgesteuerte Abfrage der RPi.GPIO

Endlich komme ich wieder dazu mich meinem Projekt zu widmen.
An meinem Programm hat mich die Abfrage des Tasters durch eine Endlosschleife gestört.
Darum habe ich mich mal durch die Hilfeseiten geklickt und auch ein wenig im Netz gesucht.
Dabei ist folgendes heraus gekommen:

Programm zur Auswertung der RPi.GPIOs mittels Interrupt

Hinweis: Das Programm geht davon aus, dass die übergebene Variable abgeholt wird bevor der Taster erneut betätigt wird.

#!/usr/bin/env python3

import RPi.GPIO as GPIO
import time
tst1 = 15                      # GPIO-Eingang des IO "Tasters"

GPIO.setmode(GPIO.BCM)
GPIO.setup(tst1, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
     # GPIO.IN: definiere tst1 als Eingang
          # pull_up_down = GPIO.PUD_DOWN:
          # Eingang wird über SoC auf "Null" gezogen
          # ein Pulldown-Widerstand wird somit überflüssig

def tst_callback(channel):     # definiere Callback-Funktion für Tasterdruck
     global tst_td, tst_dt
     if channel == 0:
          tst_td = 0           # Zeitdauer des Tastendrucks
          tst_dt = False       # neue Daten vorhanden?
          return()
     if GPIO.input(tst1):      # Taster gedrückt?
          tst_td = time.time()
     else:                     # Übergebe Wert an globale Variable
          tst_td = time.time() - tst_td
          tst_dt = True

# definieren des Events
GPIO.add_event_detect(tst1, GPIO.BOTH, callback = tst_callback, bouncetime = 50)
     # GPIO.BOTH: reagiert sowohl auf ansteigende als auch auf abfallende Flanken
          # callback = tst_callback: legt die aufzurufende Funktion fest
               # bouncetime = 50: verhindert, dass auf ein prellen reagiert wird

tst_callback(0)                # einmaliger Aufruf zum Setzen der globalen Variablen

try:
     while True:               # starte Endlosschleife
          if tst_dt:           # neue Daten vorhanden?
               print(tst_td)   # Ausgabe der Länge des Tastendrucks
               tst_dt = False  # Zurücksetzen der Variablen
          time.sleep(0.1)      # Verzögerung der Schleife
except KeyboardInterrupt: pass # Warten auf <ctrl> + c
finally: GPIO.cleanup()        # Rücksetzen der IO

Hardware Rollladensteuerung

Maschinenlesbare Wetterdaten

Eigentlich wollte ich eine autonome Steuerung und die Wetterdaten von Meteotime über DCF77 nutzen. Leider habe ich keine Informationen über die Entschlüsselung der Daten gefunden.

Hat jemand einen Tipp?

Zum Glück bietet der DWD (Deutsche Wetterdienst) eine kostenlose Grundversorgung an. Diese beinhaltet den FTP-Zugriff auf viel Megabyte an Wetterdaten, Satellitenbildern, Unwetterwarnung und auch aufbereitete Vorhersagen im Textformat.

Nach einer kostenlosen Anmeldung bekommt man einen Benutzernamen und ein Passwort zugesendet.

Link zur Anmeldung.

Mit einem kleinen Programm landet die Vorhersage auf der eigenen Festplatte:

import urllib.request

# Liest Inhalt von URL in die Datei "wetterdaten"

urllib.request.urlretrieve \

   ("ftp://name:passwort@ftp-outgoing2.dwd.de/gds/specials/forecasts/tables/germany/Daten_West_nacht",

    "wetterdaten")

Das Ergebnis sieht dann so aus:

Vorhersage von Temperatur und Wetter für die Nacht von Dienstag auf Mittwoch 28/29.01.2014

----------------------------------------------------------------------------------------

Münster            2   wolkenlos                                           

Bad Lippspringe    1   heiter                                              

Düsseldorf         3   heiter                              Windböen        

Kahler Asten      -3   in Wolken                                           

Aachen             3   bewölkt                                             

Köln               3   heiter                                              

Gießen             0   bewölkt                                             

 

Temperatur in Grad Celsius

Da ich nur die Temperatur für die Steuerung der Beschattung brauche reicht mir diese Form voll aus.

Laboraufbau Rolllladensteuerung Raspberry Pi

So! Der Aufbau der Hardware steht im Wesentlichen:

Was gibt es hier zu sehen? Von links: Statusanzeige und Taster zum Bedienen, breakout, Lichtsensor, ein MCP3008 (10 Bit-A/D-Wandler mit 8 Eingängen) und zwei Relais mit Transistoren zur Signalverstärkung. Die zwei weiteren LEDs zeigen nur den Status der Relais an. Diese entfallen bei der Umsetzung.

Berechnung des Sonnenaufgangs und Sonnenuntergangs in Python

Der erste Schritt war nicht besonders schwer, dank der Vorlage von Dr. Roland Brodbeck in C++.
Vielen Dank dafür!

Anbei ein Programm in Python 3 zur Berechnung des Sonnenauf- und -unterganges: Link