Jump to content

Fragen zum Distance IR Bricklet im "Ruhezustand"


derAngler
 Share

Recommended Posts

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?

Link to comment
Share on other sites

Hi,

 

diese IR-Sensoren scheinen gerade bei Lichteinstrahlung ab und an solche Fehlwerte zu produzierten.

Ich habe mit dem IR-Sensor was ähnliches gemacht (LCD-Beleuchtung an, wenn jemand davor steht) und bin dann dazu übergegangen, zeitlich kurze Ausreißer (also nur in Richtung "außerhalb Messbereich" nach "in den Messbereich hinein") zu ignorieren. Normalerweise sind diese Fehlmessungen ja in der Art "80 80 80 80 65 80 80" (beim Benutzen eines Listeners hätte man natürlich nur "80 65 80"). Muss man sich halt die Zeit beim Eintreffen des Events merken. Wenn der nächste Event außerhalb des Meßbereichs ist und kurze Zeit später eintrifft, muss man den Peek halt ignorieren. Da, wenn man vor dem Sensor steht, eigentlich dauernd Events auftauchen, braucht man sich auch keine Sorgen zu machen, dass man bei so einer Prüfung dann einen übersieht und das Licht vielleicht nicht anmacht.

Wenn man das schön kapselt, merkt die benutzende Programmfunktion davon auch nichts.

Funktioniert soweit ganz gut.

 

Holger

Link to comment
Share on other sites

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.

Link to comment
Share on other sites

Hi,

 

ich würde von den Sensoren jetzt keine wirklich beeindruckende Genauigkeit (im Sinne von Millimetern oder so) erwarten. Gerade wenn das Objekt an den Rand des Messbereichs wandert, wird es schlechter (nicht umsonst hat der Sensor mit 150cm diese langen "Glubscher"). Liegt sicher an der Arbeitsweise, siehe auch

http://www.daedalus.ei.tum.de/index.php/de/dokumentation/material/sensoren/ir-abstandssensor

Helles Sonnenlicht (auch nicht unbedingt direktes) kann die Messungen auch irritieren.

 

Allerdings finde ich komisch, das der Sensor bei dir, wenn nichts davor steht, 13-16cm anzeigt. Und die Angaben bei 55cm finde ich auch komisch.

Die Genauigkeit bei deinem 20cm-Objekt finde ich dafür schon ganz gut.

 

Für exakte Abstandsmessungen muss man die Werte wohl doch etwas aufbereiten/filtern und/oder vielleicht noch eine eigene Kalibrierung machen (siehe auch die Doku zum IR-Bricklet)

 

Holger

 

Link to comment
Share on other sites

Danke für eure Hilfe ... ich habe den Fehler gefunden:

 

das Netzteil!

 

Hatte den RasPi direkt an einer Steckdosenleiste mit USB-Anschluss angeschlossen.

Jetzt habe ich mal eins der Netzteile aus dem Shop genommen und, siehe da, alles funktioniert.

Ich bekomme saubere Werte, die Werte ändern sich auch nicht alle paar Millisekunden - super.

Link to comment
Share on other sites

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()

Link to comment
Share on other sites

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()

Link to comment
Share on other sites

  • 2 months later...

Da habe ich mich wohl zu früh gefreut.

 

Nachdem ich das Projekt jetzt endlich mal wieder weiterführen wollte, musste ich feststellen das ich mit den Werten des DistanceIR immer noch nicht zurecht komme.

 

Selbst gerundet habe ich immer noch "Sprünge" und "Aussetzer" drin, dadurch wird das LED-Licht dann ganz plötzlich dunkler oder heller - das sieht einfach nur unschön aus.

 

Viel schlimmer ist aber wieder das Verhalten im "Ruhezustand".

Je nach Lichtsituation zeigt er konstant 80cm an (damit könnte ich noch gut leben) oder er sprint wie wild im 10/100 Sekunden Takt von 70 auf 35 auf 47 auf 53 auf 33 ....

Es ist dann unmöglich festzustellen ob überhaupt jemand davor steht.

Siehe auch das Bild weiter unten.

 

Ich versuche die ganze Zeit irgendeine Art von Filter zu programmieren:

a) um zu erkennen wenn jemand davor steht (d.h. die ganzen Sprünge aussortieren)

b) um eine schöne "runde" Kurve beim messen der Entfernung zu bekommen, sprich die Werte zu glätten (aus Treppe mache eine Kurve)

 

Nur klappen tut zur Zeit weder das eine noch das andere.

 

Welchen realistischen Zweck kann der DistranceIR haben wenn er so extrem empfindlich auf die Lichtsituation reagiert?

Distance.thumb.jpg.80fd9fd4ebc9b5b6bec8e16025ec1de8.jpg

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share

×
×
  • Create New...