Jump to content

derAngler

Members
 Profil anzeigen  Aktivitäten des Benutzers anzeigen

  • Gesamte Inhalte

    136

  • Benutzer seit

  • Letzter Besuch

 Inhaltstyp 

Posts erstellt von derAngler

    [Python] Wetterstation

    in Software, Programmierung und externe Tools

    Geschrieben

    Anbei mein "altes" Python Script 

    import asyncore
import socket
import select
import subprocess
import os

class Client(asyncore.dispatcher_with_send):
    def __init__(self, socket=None, pollster=None):
        asyncore.dispatcher_with_send.__init__(self, socket)
        self.data = ''
        if pollster:
            self.pollster = pollster
            pollster.register(self, select.EPOLLIN)

    def handle_close(self):
        if self.pollster:
            self.pollster.unregister(self)

    def handle_read(self):
        receivedData = self.recv(8192)
        if not receivedData:
            self.close()
            return
        receivedData = self.data + receivedData
        while '\n' in receivedData:
            line, receivedData = receivedData.split('\n',1)
            self.handle_command(line)
        self.data = receivedData

    def handle_command(self, line):
        if line == 'switch_he_1 on':
            self.send('on')
            os.system("/root/switch 50 1")
        elif line == 'switch_he_1 off':
            self.send('off')
            os.system("/root/switch 50 0")
        elif line == 'switch_he_2 on':
            self.send('on')
            os.system("/root/switch 51 1")
        elif line == 'switch_he_2 off':
            self.send('off')
            os.system("/root/switch 51 0")
        elif line == 'xbmc_restart':
            self.send('restart')
            os.system("xbmc-send --host=localhost --port=9777 --action=RestartApp")
        elif line == 'xbmc_off':
            self.send('off')
            ausgabe='xbmc-send --host=localhost --port=9777 --action="PlayerControl(Stop)"'
            os.system(ausgabe)
        elif line == 'switch_sis_1 on':
            self.send('on')
            os.system("sispmctl -o 1")
        elif line == 'switch_sis_1 off':
            self.send('off')
            os.system("sispmctl -f 1")
        elif line == 'get status_switch_sis_1':
            output = subprocess.check_output(["sispmctl", "-qg", "1"]);
            if output.rstrip() == "on":
                self.send('on')
            else:
                self.send('off')
        elif line == 'switch_sis_2 on':
            self.send('on')
            os.system("sispmctl -o 2")
        elif line == 'switch_sis_2 off':
            self.send('off')
            os.system("sispmctl -f 2")
        elif line == 'get status_switch_sis_2':
            output = subprocess.check_output(["sispmctl", "-qg", "2"]);
            if output.rstrip() == "on":
                self.send('on')
            else:
                self.send('off')
        elif line == 'switch_sis_3 on':
            self.send('on')
            os.system("sispmctl -o 3")
        elif line == 'switch_sis_3 off':
            self.send('off')
            os.system("sispmctl -f 3")
        elif line == 'get status_switch_sis_3':
            output = subprocess.check_output(["sispmctl", "-qg", "3"]);
            if output.rstrip() == "on":
                self.send('on')
            else:
                self.send('off')
        elif line == 'switch_sis_4 on':
            self.send('on')
            os.system("sispmctl -o 4")
        elif line == 'switch_sis_4 off':
            self.send('off')
            os.system("sispmctl -f 4")
        elif line == 'get status_switch_sis_4':
            output = subprocess.check_output(["sispmctl", "-qg", "4"]);
            if output.rstrip() == "on":
                self.send('on')
            else:
                self.send('off')
        else:
            self.send('unknown command')

class Server(asyncore.dispatcher):
    def __init__(self, listen_to, pollster):
        asyncore.dispatcher.__init__(self)
        self.pollster = pollster
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.bind(listen_to)
        self.listen(5)

    def handle_accept(self):
        newSocket, address = self.accept()
        print "Connected from", address
        Client(newSocket,self.pollster)


def readwrite(obj, flags):
    try:
        if flags & select.EPOLLIN:
            obj.handle_read_event()
        if flags & select.EPOLLOUT:
            obj.handle_write_event()
        if flags & select.EPOLLPRI:
            obj.handle_expt_event()
        if flags & (select.EPOLLHUP | select.EPOLLERR | select.POLLNVAL):
            obj.handle_close()
    except socket.error, e:
        if e.args[0] not in asyncore._DISCONNECTED:
            obj.handle_error()
        else:
            obj.handle_close()
    except asyncore._reraised_exceptions:
        raise
    except:
        obj.handle_error()

class EPoll(object):
    def __init__(self):
        self.epoll = select.epoll()
        self.fdmap = {}

    def register(self, obj, flags):
        fd = obj.fileno()
        self.epoll.register(fd, flags)
        self.fdmap[fd] = obj

    def unregister(self, obj):
        fd = obj.fileno()
        del self.fdmap[fd]
        self.epoll.unregister(fd)

    def poll(self):
        evt = self.epoll.poll()
        for fd, flags in evt:
            yield self.fdmap[fd], flags

if __name__ == "__main__":
    pollster = EPoll()
    pollster.register(Server(("",54321),pollster), select.EPOLLIN)
    while True:
        evt = pollster.poll()
        for obj, flags in evt:
            readwrite(obj, flags)

     

    Ich habe das genutzt um auf Eingaben aus dem Internet zu reagieren.

    Das Script macht einen Server auf Port 54321 auf und reagiert dann auf verschiedene Befehle die aus dem Netz kommen.

    Das Ganze läuft ohne Schleife damit es auch wirklich schnell läuft.

     

    In einer anderen Version habe ich auch noch einen Schalter und eine LED an den Pi angeschlossen und konnte dann sowohl per Taste als auch per Internet dieLED steuern, das klappte nur über einen Socket Server.

     

    Ich denke mit etwas Arbeit kann man das auch für Tinkerforge umbasteln.

     

    Als Anregung hier mal mein aktuelles Tinkerforge Skript, allerdings noch ohne Socket Server

    #!/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()

    [Python] Wetterstation

    in Software, Programmierung und externe Tools

    Geschrieben

    Hallo,

     

    ich hatte mal das gleiche Problem mit dem Raspi und mir deshalb zusammen mit diversen Leuten aus dem python Forum(Danke) ein kleines Script geschrieben welches mit Events arbeitet.

    D.h. das Script ist in keiner Schleife "gefangen", sondert wartet auf vorher von mir bestimmte Events und führt dann die ensprechenden Befehle um.

     

    Ich werde das Script heute abend mal hier posten, im Moment sitze ich noch auf der Arbeit.

    [Umfrage] Standalone/OnDevice Lösung

    in Allgemeine Diskussionen

    Geschrieben

    @shield

     

    Ich dachte da an mehr als nur ne Montageplatte, ich sehe 2 x Möglichkeiten.

     

    1.

    Der Raspi-TF-Shield nutzt die GPIO-Pins anstatt USB und lässt sich entsprechend einfach aufstecken.

     

    und/oder

     

    2.

    Der Raspi-TF-Shield ersetzt einen MasterBrick und bietet vielleicht 6x oder 8x Bricklet Anschlüsse (mehr Platz müsste doch da sein wenn man sich etwas dem Pi anpasst beim Shield?).

     

     

    Obwohl eine passende Montageplatte, auch nicht so schlecht wäre.

    [Umfrage] Standalone/OnDevice Lösung

    in Allgemeine Diskussionen

    Geschrieben

    Es geht darum diejenigen anzusprechen, die keine Lust/Zeit/Nerven haben sich mit Linux etc. auseinander zu setzten. Es geht einfach darum ein Script in der Sprache meine Wahl zu schreiben und dieses soll dann einfach funktionieren.

    Es geht darum die Personen anzusprechen, die nicht wissen wollen wie es funktioniert sondern nur wollen das es funktioniert.

    Sie programmieren ihr Script schieben das per FTP/SSH etc. auf den RED-Brick drauf, drücken auf den Reset-Knopf und gut ist.

     

    Wenn es NUR darum gehen würde, dann wäre der RED aber auch komplett am Ziel vorbeigeschossen, dann würde es nen vorgefertigte Distribution für den Raspberry Pi auch tun. Einfach schon alles fertig eingerichtet als Distri zusammenstellen (Bindings für alle Sprachen installieren, brickd vorinstallieren, alles unnötige rauswerfen, ftp zugang einrichten und script laufen lassen das das ftp-Verzeichnis nach neuen files durchsucht), SD-Card rein, per SSH/FTP Script herüberschieben und los.

    Das würde dann nicht mehr als 10,- € + den Pi kosten - also denke ich, es kommt auch noch auf andere Dinge an.

     

    [Umfrage] Standalone/OnDevice Lösung

    in Allgemeine Diskussionen

    Geschrieben

    @Pluto

    Ich kann dich nicht ganz verstehen, du meckerst die ganze Zeit über den geplanten RED und erzählst hier einen von wegen nicht eigenständig wegen Linux ... alles Quatsch meiner Meinung nach.

     

    Erstens zwingt dich ja keiner den RED zu kaufen, nimm stattdessen einen Raspi und gut ist - warum solche Aufregung?

     

    Zweitens ist deine Logik irgendwie seltsam, warum sollte ein RED nicht eigenständig sein nur weil ein Linux drauf läuft? Irgendeine Art OS muss(!) darauf laufen, sonst wirds nix mit Eigenständigkeit .... keine Software = dummer Chip.

    Insofern ist die Entscheidung für eine debian-Linux nur richtig und gut.

     

    Drittens war der Vergleich von TF bezüglich Steckdose mit Raspi/WeMo richtig gut, anscheinend hast du ihn aber nicht verstanden.

     

    Viertens die Zielgruppe. Natürlich gibt es eine, auch wenn ich selbst nicht dazu gehöre (zu teuer), so hat der RED alleine schon wegen seine Größe und dem Stromverbauch einen echten Vorteil gegenüber den anderen Lösungen.

     

     

    @allgemeine Shields

    Ich lese immer mal wieder davon das der ein oder andere sich ein Ardunio/BeagleBone Shield wünscht.

    Das würde ich nicht machen, ich gehe stark davon aus das 75% der mit TF genutzten PC's Raspberry Pi's sind.

    Der Preis ist unschlagbar und die Community ist riesig, dazu kann ich mit einem Raspberry Pi als Anfänger wesentlich schneller zu Ergebnissen kommen, als mit einem Ardunio.

    Deswegen würde ich zu aller erst, noch vor dem RED-Brick und Shields für Ardunio/BeagleBone, eine Erweiterung für den Pi anbieten - gerade im Hinblick auf Schulen.

    Fragen zum Distance IR Bricklet im "Ruhezustand"

    in Anfängerfragen und FAQ

    Geschrieben

    verbesserter Code, jetzt mit Klassen  :D

     

    #!/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)
    IRDistance_bricklet.callbackSet(50)
    
    choice = input("Press key to exit\n")
    ipcon.disconnect()

    Fragen zum Distance IR Bricklet im "Ruhezustand"

    in Anfängerfragen und FAQ

    Geschrieben

    Ich wollte noch einmal kurz meinen Source-Code posten.

    Ich bin jetzt dazu übergegangen einen Mittelwert aus den letzten 3 x Messungen zu bilden und diesen dann zu runden.

    Damit steuere ich dann die Helligkeit der LED's.

     

    Kritik, Tips und Anregungen sind mir herzlich willkommen.

    #!/usr/bin/env python
# -*- coding: utf-8 -*-

# Module importieren
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

#
# 1. VARIABLEN
#

HOST_master = "192.168.127.81"                          # Master Brick IP
PORT_master = 4223                                      # Master Brick Port
UID_led = "jGU"                                         # LED Strip Bricklet
UID_dist = "ktd"                                        # IR Distance Bricklet
UID_motion = "jX1"                                      # Motion Detection Bricklet
UID_temp = ""                                           # Temperatur Bricklet
UID_ambi = ""                                           # Ambient Light Bricklet


var_led_RED = [0]*16                                    # LED RGB Farb Array
var_led_GREEN = [0]*16                                  # LED RGB Farb Array
var_led_BLUE = [0]*16                                   # LED RGB Farb Array

liste_led_helligkeit = [0]*70

var_distanceOld1 = 0.0                                  # cb_change_distance -> Variable für Mittelwert
var_distanceOld2 = 0.0                                  # cb_change_distance -> Variable für Mittelwert

def cb_change_distance(distanceNew):                    # Callback Funktion -> IR Distance Bricklet
    global var_distanceOld1                                                    
    global var_distanceOld2                                                     
    
    # in den beiden ersten Durchläufen mit geichen Werten füllen
    if var_distanceOld1 == 0:                       
        if var_distanceOld2 == 0:
            var_distanceOld2 = distanceNew
        var_distanceOld1 = var_distanceOld2

    mittelwert=round(((var_distanceOld1 + var_distanceOld2 + distanceNew)/30),0)    # Mittelwert bilden und runden

    # ###
    # DEBUG AUSGABE auf der Konsole
    print ('Distance: ' + str(distanceNew/10.0) + ' cm = gemittelt ' + str(mittelwert) + ' cm')
    # ###

    if mittelwert > 60 or mittelwert == 0:
        mittelwert = 60
    elif mittelwert < 10:
        mittelwert = 10
    led_leistung = liste_led_helligkeit[int(50 - (mittelwert - 10))]
    
    setFarbe(0,150,0,led_leistung)
    
    var_distanceOld1 = var_distanceOld2                                             # alten Wert vorrücken
    var_distanceOld2 = distanceNew                                                  # neuen Wert speichern

def setFarbe (vRED, vBLUE, vGREEN, helligkeit):                     # LED Funktion -> Farbwerte & Helligkeit setzen
    vRED=(vRED/100)*helligkeit
    vGREEN=(vGREEN/100)*helligkeit
    vBLUE=(vBLUE/100)*helligkeit
    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
    bricklet_led.set_rgb_values(0, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
    bricklet_led.set_rgb_values(15, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
    bricklet_led.set_rgb_values(30, 15, var_led_RED, var_led_BLUE, var_led_GREEN)
    bricklet_led.set_rgb_values(45, 15, var_led_RED, var_led_BLUE, var_led_GREEN)

def create_led_helligkeit():
    zahl = 10
    multiplikator = 0.0
    zaehler = 0
    while zahl < 100:
        multiplikator = zahl/21.5
        zahl = zahl + multiplikator
        liste_led_helligkeit[zaehler] = zahl
        zaehler = zaehler + 1
    liste_led_helligkeit[zaehler] = 100.0

if __name__ == "__main__":
    
    ipcon = IPConnection()                              # Verbindung zum Master-Brick vorbereiten
    bricklet_distance = DistanceIR(UID_dist, ipcon)     # verbinden zu IR-Bricklet
    bricklet_led = LEDStrip(UID_led, ipcon)             # verbinden zu LED Strip-Bricklet
    ipcon.connect(HOST_master, PORT_master)             # Verbindung zum Master-Brick vorbereiten

    create_led_helligkeit() 
    bricklet_distance.set_distance_callback_period(100)                                             # Abfragegeschwindigkeit des IR Bricklet in ms
    bricklet_distance.register_callback(bricklet_distance.CALLBACK_DISTANCE, cb_change_distance)    # Callback Funktion beim IR Bricklet registrieren
    
    choice = input("Press key to exit\n")
    ipcon.disconnect()

    Fragen zum Distance IR Bricklet im "Ruhezustand"

    in Anfängerfragen und FAQ

    Geschrieben

    So, ich wieder.

     

    Ich habe den Abstandssensor nun eingebaut und unter "realen" Bedingungen getestet.

    Jetzt habe ich entweder etwas falsch verstanden oder der Sensor funktioniert nicht, jedenfalls sind die Messergebnisse so eigentlich für mich nicht zu gebrauchen.

     

    Folgende Ergebnisse bekomme ich bei Tageslicht, Zollstock befindet sich zur Kontrolle ebenfalls dort (200ms Callback).

     

    Es steht nichts vor dem Sensor:

    Distance: 13.6 cm = 91.45 %
Distance: 13.0 cm = 92.875 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.0 cm = 92.875 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.6 cm = 91.45 %
Distance: 13.0 cm = 92.875 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.9 cm = 88.3625 %
Distance: 14.5 cm = 89.3125 %
Distance: 16.1 cm = 85.5125 %
Distance: 15.6 cm = 86.7 %
Distance: 14.9 cm = 88.3625 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 12.8 cm = 93.35 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.0 cm = 92.875 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.6 cm = 91.45 %
Distance: 13.0 cm = 92.875 %
Distance: 13.6 cm = 91.45 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.5 cm = 89.3125 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.5 cm = 89.3125 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 13.6 cm = 91.45 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.6 cm = 91.45 %
Distance: 14.2 cm = 90.025 %
Distance: 14.9 cm = 88.3625 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 16.1 cm = 85.5125 %
Distance: 15.6 cm = 86.7 %
Distance: 16.1 cm = 85.5125 %
Distance: 16.4 cm = 84.8 %
Distance: 14.9 cm = 88.3625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.5 cm = 89.3125 %
Distance: 13.0 cm = 92.875 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 13.9 cm = 90.7375 %
Distance: 14.1 cm = 90.2625 %
Distance: 14.2 cm = 90.025 %
Distance: 14.5 cm = 89.3125 %
Distance: 14.1 cm = 90.2625 %
Distance: 13.9 cm = 90.7375 %
Distance: 13.3 cm = 92.1625 %
Distance: 13.0 cm = 92.875 %
Distance: 14.1 cm = 90.2625 %

    Wie man sieht ist von 13.0 bis 16.4 cm alles dabei.

     

    Jetzt steht ein Buch vor dem Sensor, Abstand 20 cm:

    Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 17.9 cm = 81.2375 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 18.9 cm = 78.8625 %
Distance: 18.6 cm = 79.575 %
Distance: 17.9 cm = 81.2375 %

    Von 17.9 bis 18.9 cm - sind 1cm Toleranz wirklich normal?

     

    Jetzt steht das Buch 75cm weit weg:

    Press key to exit

    Hier bekomme ich keine Ausgabe mehr, anscheinend ist das schon zu weit weg?

     

    55cm:

    Press key to exit
Distance: 81.5 cm = -69.8125 %
Distance: 80.0 cm = -66.25 %
Distance: 81.5 cm = -69.8125 %
Distance: 80.0 cm = -66.25 %
Distance: 81.5 cm = -69.8125 %
Distance: 80.0 cm = -66.25 %
Distance: 81.5 cm = -69.8125 %
Distance: 80.0 cm = -66.25 %

    Also das verstehe ich jetzt gar nicht mehr ....

     

     

    Und abends sind die Werte dann nochmal komplett anders.

    Ist das jetzt das normale Verhalten? Wie soll man dann damit etwas anfangen können?

     

    Achja, habe die Variante "GP2Y0A21: 10cm - 80cm" und bereits das Bricklet neugeflasht.

    Fragen zum Distance IR Bricklet im "Ruhezustand"

    in Anfängerfragen und FAQ

    Geschrieben

    Hallo,

     

    ich habe die Tage unter anderem ein Distance IR Bricklet erhalten, die Variante mit einem Messbereich zwischen 20 und 80 cm.

     

    Schliesse ich das Bricklet an und starte den BrickViewer funktioniert im ersten Moment auch alles.

    Allerdings habe ich das Problem, das die Werte wie wild "springen" wenn das Bricklet keine Messung durchführen kann, sprich wenn sich innerhalb des Messbereichs nichts befindet.

     

    Das ganze äußert sich dann so, das das Bricklet mehrmals pro Sekunde die angeblich gemessene Entfernung ausgibt.

    Z.Bsp. kann es sein, das ich wie wild Werte zwischen 60 und 75cm geliefert bekomme obwohl sich vor dem Sensor nichts befindet.

    Beim nächsten mal sind es dann Werte zwischen 30 und 45 cm, oder, oder, oder ...

     

    Sowie sich irgendetwas in dem Messbereich vor dem Sensor befindet funktioniert der Sensor auch genau wie erwartet.

     

    Mein Problem ist, das ich nun nicht erkennen kann wenn sich nichts vor dem Sensor befindet.

     

    Ich wollte ein Programm schreiben, das abhängig davon wie nah jemand am Sensor ist, die Helligkeit von LED regelt.

    Und wenn niemand davor steht, dann sollen die LED's ausbleiben.

     

    Genau mit letzterem habe ich nun meine Probleme, den ich kann den Zustand wenn niemand davor steht nicht erkennen.

    Deswegen wollte ich euch fragen wie ich erkennen kann das niemand davor steht?

    LED-Bricklet und LED-Streifen

    in Anfängerfragen und FAQ

    Geschrieben

    Nabend,

     

    habe eben LED-Bricklet und passenden RGB-Streifen von Tinkerforge bekommen und auch schonmal ein Testaufbau durchgeführt.

     

    Jetzt will ich meine erste Anwendung programmieren und stehe auch direkt vor der ersten Frage:

     

    Wie kann ich die Helligkeit steuern?

    Einfach die RGB-Werte runterzählen?

    Bei weiß klappt das vielleicht noch aber z.Bsp. bei Grün? Wenn ich da die RGB-Werte runterlaufen lassen dann verändert sich doch auch die Farbe.

    Dachte über die Frequenz, aber wenn ich die im BrickViewer geändert habe, dann hatte das keine Auswirkung.

    Welches Netzteil für 2m RGB-LED's?

    in Anfängerfragen und FAQ

    Geschrieben

    Nabend,

     

    ich möchte eine Hintergrund-Beleuchtung basteln und dafür die hier angebotenen RGB-LED-Streifen nutzen.

    Insgesamt benötige 2m, pro Meter gibt es 32 LED's, und jede LED hat 62mA.

    Das macht dann rechnerisch so um die 3,6A für alle LED's.

     

    Jetzt habe ich die Wahl zwischen diesen beiden Netzteilen, welches sollte ich nehmen?

     

    5V 6A

    http://www.reichelt.de/Schaltnetzteile-fuer-Hut-Schiene/SNT-MW-MDR40-05/3/index.html?&ACTION=3&LA=2&ARTICLE=85237&GROUPID=4961&artnr=SNT+MW-MDR40-05

     

    5V 3A

    http://www.reichelt.de/Schaltnetzteile-fuer-Hut-Schiene/SNT-MW-MDR20-05/3/index.html?&ACTION=3&LA=2&ARTICLE=85234&GROUPID=4961&artnr=SNT+MW-MDR20-05

    Hausautomatisierung mit FHEM

    in Projektvorstellungen und Projektideen

    Geschrieben

    CometVisu geht in die richtige Richtung  :)

     

    Obwohl ich erklärter Apple-Gegner bin, muss ich zugeben das die Apple UI's ziemlich perfekt sind und in diese Richtung gehen auch meine Vorstellungen.

    Davon ist CometVisu noch entfernt, ich schaue es mir aber auf jeden Fall genauer an.

     

    Insgesamt bleibt aber mein Hauptkritikpunkt:

    Es gibt 3 x OpenSource Programme für die Heimautomation und im Prinzip machen alle genau das gleiche, ja, sie arbeiten sogar ähnlich.

    Das Ergebnis ist aber, das keins der Programme so richtig gut funktioniert, bzw. alles an Bindings unterstützt was der Markt so bietet. Man sieht den Projekten Ihren OpenSource Status an.

    Software von Nerds für Nerds eben  ;)

     

    Ich bin mir sicher, hätte man die gesamte Zeit die alle Programmierer und vor allem alle Binding-Programmierer für die 3 x Programme verbraucht haben auf ein einziges Stück Software konzentriert, dann wäre diese Software richtig gut.

     

     

    Hausautomatisierung mit FHEM

    in Projektvorstellungen und Projektideen

    Geschrieben

    Hallo,

     

    ich denke das Problem ist, das jeder Entwickler sein eigenes Süppchen kocht.

     

    Ich bin jetzt schon seit Wochen am überlegen welches System ich zur Hausautomation einsetze und komme zu keinem Ergebnis.

     

    Zuerst bin ich, wie du auch, bei FHEM gelandet - das hat Unterstützung für Heizkörper-Thermostate der Firma HomeMatic, dafür keine für Tinkerforge.

     

    Danach bin ich bei openhab (siehe Forum hier) gelandet - das hat Unterstützung für Teile von Tinkerforge, dafür wird hier nicht das Einstellen der einzelnen HeizkörperTemperaturen bei HomeMatic unterstüzt.

     

    Zu guter letzt gibt es auch noch openRemote, das habe ich mir aber aus Frust nicht mehr angeschaut.

     

    Nicht nur das die GUI bei beiden Programmen (FHEM + openhab) wirklich schrecklich häßlich und altmodisch ist (auf einem FullHD Tablet/Bildschirm sieht es z. Bsp. aus wie ne Prototype einer GUI), nein, hier arbeiten auch mehrere Leute an der fast gleichen Sache und machen damit vieles doppelt und dreifach.

     

    Was wäre das schön wenn zumindest FHEM und openhab zusammen gehen würden, was würden hier für Synergieeffekte auftreten, alleine die Plugin/Binding-Entwickler hätten schon riesen Vorteile wenn man sich zusammentun würde.

     

     

    Bausätze?

    in Hardware

    Geschrieben

    Na ich dachte auch daran die Platine extern fertigen zu lassen und das bestücken, hmm, gibt doch genug die SMD-Bauteile löten können - ansonsten gibt es auch Bestückungsservices (soweit ich weiß).

    Die eigentliche Idee dahinter ist es ein MasterBrick, ein WifiBrick, sowie 2-3 Bricklets auf möglichst wenig Platz unterzubringen (damit ich es z.Bsp. in einen Ventilator einbauen kann).

     

    Ich kann den Bedarf schlecht abschätzen, aber ich muss euch warnen - ich komme immer wieder auf verrückte Ideen ;)

    Raspberry Pi & Tinkerforge - Grundinstallation

    in Projektvorstellungen und Projektideen

    Geschrieben

    ich würde eher lighthttp anstatt den apache empfehlen... läuft sauberer auf dem Pi

    Daran dachte ich auch zuerst, allerdings kenne ich mich damit nicht aus.

    Ich weiß nicht welche Configs ich für lighthttp selbst anlegen muss und wie sich das ganze am besten installieren lässt.

    Würde ein einfaches

    apt-get install lighthttp php5

    genügen um lighthttp mit php Unterstützung zu installieren, aber ohne apache (und Abhängigkeiten)?

     

    der folgende befehl entfernt so ziemlich alles was mit x11 zu tun hat

    Den Befehl werde ich gleich aufnehmen, vielen Dank.

×
×
  • Neu erstellen...