LotharGehlhaar - Teichbauforum

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

#-----------------------------#
# Author: Pfiffikus und Dennis#
#-----------------------------#
import time
import RPi.GPIO as GPIO
import sys
import string

#GPIO PINs deklariren
GPIOTrigger = int(sys.argv[1])
GPIOEcho    = int(sys.argv[2])

#Wie oft soll gemessen werden, Standard = 20 mal
length_input = len(sys.argv)
if length_input > 3:
    Counter = int(sys.argv[3])
else:
    Counter = 20

#Warnings ausschalten um fehlerhafte Logausgaben zu vermeiden
GPIO.setwarnings(False)

#set GPIO PINS
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIOTrigger, GPIO.OUT)
GPIO.setup(GPIOEcho, GPIO.IN)

#set trigger to false
GPIO.output(GPIOTrigger, False)

# Wait 100ms damit die erste Messung korrekt durchgefuehrt wird
time.sleep(0.1)

#--------------------------------------------#
#--------------Entfernung messen-------------#
#--------------------------------------------#
def MeasureDistance(GPIOTrigger, GPIOEcho):
    # set trigger to high
    GPIO.output(GPIOTrigger, True)

    # set trigger after 100msec to low, mit laengerer Wartezeit als 10mikrosec ist die Genauigkeit hoeher
    time.sleep(0.1)
    GPIO.output(GPIOTrigger, False)

    # store initial start time
    StartTime = time.time()
    # Endzeit festlegen
    EndTime = StartTime + 1

    # store start time
    while ((GPIO.input(GPIOEcho) == 0) & (StartTime < EndTime)):
        StartTime = time.time()

    # store stop time - aber vordefinieren
    StopTime = time.time()
    while ((GPIO.input(GPIOEcho) == 1) & (StartTime < EndTime)):
        StopTime = time.time()


    # Wenn keine Antwort vom Sensor empfangen wird, wird 0 mm  ausgegeben
    if StopTime - StartTime < 0.0001:
        StopTime =  StartTime

    # calculate distance
    TimeElapsed = StopTime - StartTime
    Distance = (TimeElapsed * 343000) / 2

    return Distance
#--------------------------------------------#
#----------Mittelwert ermitteln--------------#
#--------------------------------------------#
def GetAverage(lDistance):
    #Listenlaenge ermittteln
    lengthList = len(lDistance)
    #Wandle List of Strings in List of Ints um
    lDistance = map(int, lDistance)
    #Min und Max Werte der Liste ermitteln
    MIN = min(lDistance)
    MAX = max(lDistance) + 1 # Es muss einer addiert werden damit die Schleife noch einmal durchlaufen wird, wenn viele Werte gleich dem MAX Wert sind
    #Variablen deklarieren
    RANGE = 6           #In welchem Bereich soll gesucht werden Default=6mm, es muss eine gerade Zahl sein!!!!
    i = 0               #Schleifenwert
    average = 0         #Durchschnittswert
    treffer = 0         #aktuelle Treffer
    maxtreffer = 0      #bisherigen max Treffer
    maxSensor = 3000    #Der Sensor kann bis max 3000mm messen
    #Wenn der MAX Wert in der Liste groesser als die Reichweite ist, wird 3000mm als maximum angenommen
    if MAX > maxSensor:
        MAX = maxSensor
    if MIN != 0:
        i = MIN - 1
    #Alle Werte von MIN bis MAX pruefen
    while i < MAX:
        #Alle Werte der Liste durchlaufen und ueberpruefen, wenn Wert in dem Bereich von +- 3mm liegt wird gezaehlt
        a = 0           #Listenanfang muss wieder zu 0 gesetzt werden, da es erneut durchlaufen wird
        treffer = 0
        while a < lengthList:
            if (lDistance[a] > i-(RANGE/2)) and (lDistance[a] < i+(RANGE/2)):
                treffer=treffer+1
            a=a+1
        #Wenn die aktuell gezaehlten Werte groesser sind als die alten werden diese gespeichert
        if treffer > maxtreffer:
            maxtreffer = treffer
            average  = i
        #Wenn alle Werte innerhalb von 6mm liegen, wird die Schleife verlassen, sonst wird bis zum max Wert weiter geprueft
        if maxtreffer == lengthList:
            break
        i=i+1
    return average
#------------------------------------------------#
#-------------Start Program----------------------#
#------------------------------------------------#
#Leere Liste erschaffen
lDistance = []
#Schleife zum messen der Entfernung, wird so oft durchlaufen wie in Counter uebergeben wurde
while Counter > 0:

    #Entferung messen
    Millimeter = MeasureDistance(GPIOTrigger, GPIOEcho)

    #Entferung zur Liste addieren
    lDistance.append("%0.0f" % (Millimeter)) #ohne mm
    #lDistance.append("%0.0f mm" % (Millimeter))#mit mm

    #dekrementiere Zaehler
    Counter = Counter - 1

iDistance = GetAverage(lDistance)
#Mittelwert als Integer ausgeben on mm Angabex
#print iDistance
#Mittelwert als String ausgeben mit mm Angabe
print ("%0.0f mm" % (iDistance))
#Outputs wieder auf undefinierten Zustand setzen
GPIO.cleanup()

error_reporting(0);

<?php
/** *************************************************************************
*   Copyright (C) 2014 by Pfiffikus                                                                             *
*   pfiffikus@zahlengenie.de                                                                                            *

      Klasse zur Ansteuerung eines US-Sensors
      http://www.gtkdb.de/index_36_2272.html
      http://www.bytecreation.com/blog/2013/10/13/raspberry-pi-ultrasonic-sensor-hc-sr04
      http://forum.fhem.de/index.php?topic=19812.0


      http://www.dude2k.de/index.php/raspberry-pi/108-ultraschall-entfernungsmessung-mit-dem-hc-sr04

***************************************************************************/
include_once ("quellen/sensoren/cSensor.php");

class cUSchallSensor extends cSensor {
var $mySkript;

                /** ********************
                *       cUSchallSensor::Get
                Liefert die Entfernung des Sensors in mm
                **********************/
                function Get() {

                      error_reporting(1);
                      $Befehl           =       'sudo /var/www/steuerung/quellen/sensoren/echolot.py';
                      $resultat =       exec($Befehl, $retval);
                      error_reporting(1);

                      $res      =       (int)($resultat * 10);
                      return $res;
                 }

                 /** ********************
                 *      cUSchallSensor::GetGetGenau
                 Liest die Entfernung des Sensors 10 mal aus
                 **********************/
                 function GetGenau() {

                       $Befehl          =       'sudo /var/www/steuerung/quellen/sensoren/echolot.py';
                       error_reporting(1);
                       for($i=0;$i<10;$i++) {
                             $resultat  =       exec($Befehl, $retval);
                             $wert[$i]  =       $retval;
                             echo $wert[$i]." als $i<br>\n";
                       }
                       error_reporting(1);


                       $res     =       (int)($resultat * 10);
                       $res     =   99999;
                       return $res;
                 }

                 /** ********************
                 *      cUSchallSensor::cUSchallSensor
                 Konstruktor - Hier muss das richtige Skript genannt werden.
                 - Im Skript sind die zu nutzenden GPIOs eingetragen
                 **********************/
                 function cUSchallSensor($iSkript) {
                       $this->mySkript = $iSkript;
                 }
}
?>