Vorweg muss ich direkt sagen, das ich das Projekt erst einmal auf Eis gelegt habe.
Die Gründe sind zum einen der ungenaue Distanzsensor (kam mit diversen Objekten nicht zurecht), zum anderen die Tatsache das ich den PIR noch durch einen HF-Sensor austauschen muss ( PIR geht nicht durch Glasdusche ).
Zu guter letzt muss ich dann auch noch die Kabel besser abschirmen da immer wieder einzelne LED ohne zutun angehen.
Dabei kam mir dann die Idee den Spiegel neu zu bauen, mit Display hinter Spionspiegelglas.
Aber das Projekt ist auf das Jahr 2016 verlegt.
Trotzdem stelle ich das Projekt hier der Vollständigkeit halber nochmal kurz vor.
Beschreibung
Da in meinem Bad ein Spiegel gefehlt hat, kam ich auf die Idee zu diesem Projekt. Beim Material habe ich mich für HPL-Vollkernplatten entschieden, diese sind sehr robust und zudem wasserfest sind.
Am Anfang stand die Konstruktion des Spiegels, inklusiv Platz für die Elektronik und Beleuchtung. Vorderseite und Wandplatte sind anthrazitfarben, die Seitenteile karminrot. Der weiße Kern der HPL-Platten steht im Kontrast zu dem dunklen Anthrazit und bildet das optische Highlight.
Aufgebaut besteht der Spiegel aus der Wandplatte, daran sind die Seitenteile befestigt. An den Seitenteilen wiederum sind die Magnetschnapper befestigt, diese tragen dann im Abschluss die Frontplatte in welcher der Spiegel eingelassen ist. Die Bearbeitung der Platten erfolgte mittels einer CNC bei mir auf der Arbeit (Rink GmbH). Ich habe darauf geachtet dass der gesamte Spiegel wieder demontierbar ist. Außer der Spiegelfläche an sich, ist kein einziges Bauteil verklebt.
Das Projektziel ist die Erfassung von verschiedenen Sensor-Daten zwecks Steuerung von Licht & Heizung. Am Ende sollte es so sein, das ich zum einen auf meinem Tablet sehen kann wie warm es im Bad ist (und dabei auch direkt die gewünschte Temperatur einstellen kann) und zum anderen geht das Licht im Bad automatisch an sofern jemand im Raum ist und es nicht genug Tageslicht gibt (die RGB-Beleuchtung soll noch darauf reagieren wie weit entfernt man vom Spiegel steht und je nach Uhrzeit auch einen anderen Farbton haben). Außerdem kann ich sehen ob das Bad gelüftet werden muss (Feuchtigkeit).
Bauteile
Elektronik
Rasperry Pi, USB WLAN-Stick (rtl8192c), 5V 2A Schaltnetzteil, 5V 3A Schaltnetzteil, 2x Tinkerforge MasterBrick’s, Temperature Bricklet, IR Distance Bricklet, Ambient Light Bricklet, Humidity Bricklet, LED Strip Bricklet, Motion Detector Bricklet, 2m RGB-LED Band
Material
13mm HPL-Vollkernplatten (anthrazit+kaminrot) mit weißem Kern, Edelstahlverbinder, Schrauben M6, Schrauben M3, Mainboard-Abstandhalter, 4x Magnetschnapper
Software
wird auf jeden Fall selbstentwickelt. Server/Client-Programmierung mit python 3.4 und GUI über Browser mit bootstrap, jquery und javascript.
Zuerst habe ich mir überlegt aus welchem Material ich den Rahmen für den Spiegel baue. Einerseits musste ich es irgendwie bearbeiten können, andererseits sollte es aber auch wasserfest sein und nach etwas aussehen. Schnell fiel meine Wahl deshalb auf HPL-Vollkernplatten, ein Verbundstoff aus Harz und Papier.
Als nächstes stand die Konstruktion des Spiegels auf dem Programm. Das grobe Aussehen (große Wandplatte -> kleiner Kasten -> große Frontplatte mit Spiegel) war mir von Anfang an klar, im Prinzip ging es also nur noch um notwendige Bearbeitungen und Feinheiten.
Die Wandplatte hat 5 x Durchgangsbohrungen und wird mit 4 x Dübel direkt an den Fliesen befestigt. Das 5. Loch ist etwas größer und als Kabeldurchlass (Strom + Sensoren) gedacht.
Die Seitenteile werden mit Hilfe von 8 x Verbinder (2 x pro Seite) an der Wandplatte befestigt.
Die Frontplatte ihrerseits wird über Magnetschnapper mit den Seitenteilen verbunden.
Magnetschnapper deshalb, damit ich jederzeit schnell und problemlos zu Wartungs- oder Erweiterungszwecken auf das Innere des Spiegels zugreifen kann. Gleichzeitig hält sich aber der Montageaufwand in Grenzen.
In die Frontplatte ist der Spiegel eingelassen und eine Durchgangsfräsung für den IR Distanz Sensor.
Rückseitig ist die komplette Elektronik untergebracht (außer den beiden Schaltnetzteilen, diese sind mit Klettband an der Wandplatte befestigt) inklusiv dem RGB-LED-Band (eingefräst, so dass die Lichtstrahlung zum größten Teil nach Hinten, Richtung Wand, geleitet wird).
Die Module und die Sensoren werden mit Hilfe von Abstandshalter in die HPL-Platte geschraubt.
Die Sensoren für Temperatur, Luftfeuchtigkeit und Entfernungsmessung sind am Rand, außerhalb des „Rahmen-Kastens“ auf der Rückseite befestigt.
Innerhalb des Kastens sind die 2 x Tinkerforge Masterbricks, das LED-Bricklet und der Raspberry Pi montiert.
Die Sensoren für Helligkeit und Bewegungserkennung wollte ich zuerst auch noch im Spiegelgehäuse unterbringen, das hat allerdings richtig schlecht ausgesehen.
Außerdem bekam der Helligkeitssensor auch noch zu wenig Licht. Deshalb habe ich beide Sensoren in einem Aufputzgehäuse untergebracht und dieses an der Decke montiert.
Mittlerweile habe ich es durch ein Gehäuse aus dem 3D-Drucker ersetzt, das macht es optisch aber nicht viel besser.
Funksensoren wären hier eine Maßnahme.
Hier hat sich mittlerweile soviel getan das der alte Code fast komplett hinfällig ist.
Ich werde deshalb nicht viel dazu schreiben und heben mir das für den neuen Code 2016 auf.
Anbei nur der „alte“ Sourcecode.
Immerhin hat er ja funktioniert. Aber bitte im Hinterkopf behalten das meine aktuellen python Programme wesentlich besser programmiert sind, das hier waren so in etwa die ersten Gehversuche.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import datetime
from datetime import timedelta
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_led_strip import LEDStrip
from tinkerforge.bricklet_distance_ir import DistanceIR
from tinkerforge.bricklet_motion_detector import MotionDetector
from tinkerforge.bricklet_ambient_light import AmbientLight
from tinkerforge.bricklet_humidity import Humidity
from tinkerforge.bricklet_temperature import Temperature
class cls_LED_bricklet:
led_RED = 0
led_GREEN = 0
led_BLUE = 0
helligkeit = 0.0
led_verlauf = [0]*101
UID = "jGU"
def __init__(self):
self.bricklet = LEDStrip(self.UID, ipcon)
zahl = 12
multiplikator = 0.0
zaehler = 0
while zahl < 100:
multiplikator = zahl/46.2
zahl = round(zahl + multiplikator,3)
self.led_verlauf[zaehler] = zahl
zaehler = zaehler + 1
self.led_verlauf[zaehler-1] = 100.0
def setColor(self,vr,vg,vb,he):
self.led_RED = vr
self.led_GREEN = vg
self.led_BLUE = vb
self.helligkeit = he
vRED=(self.led_RED/100)*self.helligkeit
vGREEN=(self.led_GREEN/100)*self.helligkeit
vBLUE=(self.led_BLUE/100)*self.helligkeit
var_led_RED = [0]*16
var_led_GREEN = [0]*16
var_led_BLUE = [0]*16
for i in range(16):
var_led_RED[i] = int(vRED)
var_led_GREEN[i] = int(vGREEN)
var_led_BLUE[i] = int(vBLUE)
# LED's setzen
self.bricklet.set_rgb_values(0, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
self.bricklet.set_rgb_values(15, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
self.bricklet.set_rgb_values(30, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
self.bricklet.set_rgb_values(45, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
class cls_Motion_bricklet:
motion_detected = False
UID = "jX1"
def __init__(self):
self.bricklet = MotionDetector(self.UID, ipcon)
def callbackSet(self):
self.bricklet.register_callback(self.bricklet.CALLBACK_MOTION_DETECTED, self.__start)
self.bricklet.register_callback(self.bricklet.CALLBACK_DETECTION_CYCLE_ENDED, self.__stop)
def __start(self):
self.motion_detected = True
print(str(get_systemzeit()) + ' - Bewegung erkannt')
def __stop(self):
self.motion_detected = False
print(str(get_systemzeit()) + ' - Bewegung hört auf')
class cls_Temperature_bricklet:
temperature = 0.0
UID = "dXW"
def __init__(self):
self.bricklet = Temperature(self.UID, ipcon)
def callbackSet(self,timeframe=5000):
self.bricklet.set_temperature_callback_period(timeframe)
self.bricklet.register_callback(self.bricklet.CALLBACK_TEMPERATURE, self.__write)
def read(self):
te = self.bricklet.get_temperature()
self.temperature = (te/100.0)
print(str(get_systemzeit()) + ' - Temperatur: ' + str(te/100.0) + ' °C')
def __write(self, te):
self.temperature = (te/100.0)
print(str(get_systemzeit()) + ' - Temperatur: ' + str(te/100.0) + ' °C')
class cls_Humidity_bricklet:
humidity = 0.0
UID = "kdt"
def __init__(self):
self.bricklet = Humidity(self.UID, ipcon)
def callbackSet(self,timeframe=5000):
self.bricklet.set_humidity_callback_period(timeframe)
self.bricklet.register_callback(self.bricklet.CALLBACK_HUMIDITY, self.__write)
def read(self):
rh = self.bricklet.get_humidity()
self.humidity = (rh/10.0)
print(str(get_systemzeit()) + ' - Luftfeuchtigkeit: ' + str(rh/10.0) + ' %')
def __write(self, rh):
self.humidity = (rh/10.0)
print(str(get_systemzeit()) + ' - Relative Luftfeuchtigkeit: ' + str(rh/10.0) + ' %')
class cls_Ambient_bricklet:
ambient = 0.0
UID = "jy1"
def __init__(self):
self.bricklet = AmbientLight(self.UID, ipcon)
def callbackSet(self,timeframe=5000):
self.bricklet.set_illuminance_callback_period(timeframe)
self.bricklet.register_callback(self.bricklet.CALLBACK_ILLUMINANCE, self.__write)
def read(self):
il = self.bricklet.get_illuminance()
self.ambient = (il/10.0)
print(str(get_systemzeit()) + ' - Lichtstärke: ' + str(il/10.0) + ' lx')
def __write(self, il):
self.ambient = (il/10.0)
print(str(get_systemzeit()) + ' - Lichtstärke: ' + str(il/10.0) + ' lx')
class cls_IRDistance_bricklet:
distance = 0.0
distanceOld1 = 0.0
distanceOld2 = 0.0
distanceOld3 = 0.0
firstRun = True
UID = "ktd"
def __init__(self,ctbrick,chbrick):
self.ctrl_bricklet = ctbrick
self.chck_bricklet = chbrick
self.bricklet = DistanceIR(self.UID, ipcon)
def callbackSet(self,timeframe=200):
self.bricklet.set_distance_callback_period(timeframe)
self.bricklet.register_callback(self.bricklet.CALLBACK_DISTANCE, self.__changeDistance)
def __changeDistance(self,distNew):
if self.firstRun:
self.fristRun = False
self.distanceOld1 = distNew
self.distanceOld2 = distNew
self.distanceOld3 = distNew
mittelwert=round(((self.distanceOld1 + self.distanceOld2 + self.distanceOld3 + distNew)/40),1)
y = mittelwert
if mittelwert > 60 or mittelwert == 0:
mittelwert = 60
elif mittelwert < 10:
mittelwert = 10
x = round(99/50*(50 - (mittelwert - 10)),0)
led_leistung = self.ctrl_bricklet.led_verlauf[int(x)]
if self.chck_bricklet.motion_detected:
self.ctrl_bricklet.setColor(0,150,0,led_leistung)
print (str(get_systemzeit()) + ' - Entfernungsänderung: ' + str(distNew/10.0) + ' cm => gemittelter ' + str(y) + ' => Wert ' + str(x) + ' => ' + str(led_leistung) + ' %')
self.distanceOld1 = self.distanceOld2
self.distanceOld2 = self.distanceOld3
self.distanceOld3 = distNew
def get_systemzeit():
now = datetime.datetime.utcnow()+timedelta(hours=1)
return(now)
if __name__ == "__main__":
ipcon = IPConnection()
# Bricklets
Temperature_bricklet = cls_Temperature_bricklet()
Humidity_bricklet = cls_Humidity_bricklet()
Ambient_bricklet = cls_Ambient_bricklet()
LED_bricklet = cls_LED_bricklet()
Motion_bricklet = cls_Motion_bricklet()
IRDistance_bricklet = cls_IRDistance_bricklet(LED_bricklet,Motion_bricklet)
ipcon.connect("192.168.127.81", 4223)
# Callbacks
Temperature_bricklet.callbackSet(10000)
Humidity_bricklet.callbackSet(10000)
Ambient_bricklet.callbackSet(10000)
Motion_bricklet.callbackSet()
IRDistance_bricklet.callbackSet(50)
choice = input("Press key to exit\n")
ipcon.disconnect()