LotharGehlhaar - Teichbauforum

Hallo Ihr beiden,

irgendwie bin ich verwirrt.

Soll ich jetzt die Bilder von Paul nehmen und das Script wird so umgeschrieben, dass es zum Schaltplan von Paul passt?

Gruß
Bernhard

_________________
______________________________________________________________________________________________________________________
Der wahrscheinlich weltweit einzige Koifutterhändler, der eigentlich gar kein Futter verkaufen will!
http://www.koifutterhandel.de
Lieferung ist tagesformabhängig, Paypalzahlung ist aber möglich.

OK der Einwand ist berechtigt. An Wasserbewegung hab ich eben gar nicht gedacht

Mit prellen meinte ich ich das direkte Schalter prellen.
Doch die Spannung hat etwas mit prellen zu tun. Bei 3 KV ist die Gefahr von Lichtbögen höher. Naja ich denke das ist hier nicht das Problem.

Was du meinst ist glaube ich das der Schalter mindestens 2 Sekunden überwacht werden soll. Nicht das der Schalter durch zu starke Strömung immer pendelt und genau zum Messzeitpunkt den falschen wert liefert.

Ich schau es mir mal morgen an. Ich geh jetzt erst mal feiern


Gesendet von meinem GT-I9305 mit Tapatalk 2

_________________
____________________
Viele Grüße
Dennis
____________________

Hallo zusammen,
ja Dennis ich würde bouncetime evtl. auch zweckentfremden!
Wobei ich erstmal gar nicht feststellen kann ob ein zu verwendender Schalter überhaupt prellt, ich denke mal das alle Schalter Prellen auf Grund ihre Mechanik.
Denk mal an Billige Tastaturen usw.
Das mit der 3,3KV war ein schlechter Vergleich aber ein gutes Beispiel, da würde bei entsprechender Last alles verbrennen, wenn es da nicht noch andere Möglichkeiten gäbe blabla.....
Es wäre es schön um nach einem update svn update /var/www/steuerung nicht wieder die aus der Erfahrung angepasste Zeit neu einzustellen, eine Variable zu berücksichtigen.


Ja auch eine Zusätzliche Möglichkeit über time.sleep(3), weis aber nicht ob dann gemessen wird.
Ich möchte das ganze auch nicht zuviel aufbauschen als nötig.


Ich Wünsch Dir einen schönen FEIER Abend


Servus Bernhard,
zum Testen kannst Du das Script wie im Schaltplan angegeben benutzen, wenn ihr andere Widerstände dort haben wollt dann ändere ich die gerne, ich benutzte das wie gezeigt schon ein par Monate.
Mit dem endgültigen Script würde ich gerne nochmal mit Dennis Rücksprache nehmen.

Kennt jemand eine Möglichkeit wie Wir zusammen sprechen können in Konferenzschaltung, Festnetz oder VoIP, kenne nur über Handy bei Prepaid aber nicht so günstig

Wenn jemand sein Trommler oder Band überwachen möchte (Dient auch zur Rückmeldung ob die Steckdose richtig schaltet) hier ein Beispiel, mit GPIO 12 Schaltplan wie oben 10KOhm.
[codeAnfang:

#!/usr/bin/python2.7
# -*- coding: utf-8 -*-
import time
import RPi.GPIO as GPIO

# SoC als Pinreferenz waehlen
GPIO.setmode(GPIO.BCM)

mess_file1='/xxxxxx/Drehzahlmessung.txt'
mess_file2='/xxxxxxx/Drehzahlsifi.txt'

GPIO.setup(12, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

def Drehzahlmessung(channel):
global Impulse
Impulse=Impulse+1

# Hier ist das Hauptprogramm FALLING, RISING, BOTH oder beides #
GPIO.add_event_detect(12, GPIO.RISING, callback=Drehzahlmessung, bouncetime=300)
Impulse=0
while True:
StartTime=time.time()
time.sleep(300)
StopTime=time.time()
Dauer=round((StopTime-StartTime)/60)
jetzt=time.strftime("%d.%m.%Y - %H:%M:%S Uhr")
Dauer1=(Dauer/5)
Drehzahl=round(Impulse/Dauer1)
file_config=open(mess_file1,"w")
file_config.write("# Messergebnisse der Sifi Drehzahlmessung\n")
file_config.write("# Erstellt am " + jetzt + "\n")
file_config.write(str(Impulse) + " Impulse, " + str(Dauer) + " min. Messdauer, " + str(Drehzahl) + " U/min. Soll = 6-30U/min.")
file_config.close()
file_config=open(mess_file2,"w")
file_config.write(str(Drehzahl))
file_config.close()
Impulse=0

[/code]

Es werden zwei Dateien angelegt, anstatt der xxx den dateipfad angeben.
mess_file1='/xxxxxx/Drehzahlmessung.txt'
mess_file2='/xxxxxxx/Drehzahlsifi.txt'

Hallo Dennis,
habe mal noch ein bisschen rum experimentiert.
Mit time.sleep(...) versucht es zu lösen, aber wie der Name es sagt geht das Programm dann immer schlafen.
In deinem Fall sicher nicht tragisch, aber bei Abfrage des Einganges kein Erfolg.

Eine Lösung wäre, dass bei 0 oder 1 am Eingang einen Zeitstempel erstellt wird und wenn nach einer Zeit x (2s) der Pegel immer noch gleich der ersten Messung ist, wird dieser für gültig erklärt.
Ansonsten wird die Messung wiederholt bis zwei gültige Werte erreicht worden sind.

Kannst Du mir dabei helfen Dennis ?

#================================================================================================================================================
#Title : Pegelschalter an GPIO auslesen
#Author : Gemeinschaftsarbeit Dennis / Paul Fischkopf
#Datum : 04.05.2015
#Version : 03
#Anwendung :Starte Script mit z.b pi@raspberrypi1 /var/www/schaltkontakt/quellen/sensoren/schaltkontakt.py $ sudo ./schaltkontakt.py 16
#Notizen :Um einen GPIO zu exportieren muessen wir jedoch Root sein (was ein bisschen nervt). Entweder wechselt man vorher zum Root-Benutzer,
# oder benutzt sudo
#================================================================================================================================================
import RPi.GPIO as GPIO
import sys
import time

#GPIO PINs deklariren
GPIOin = int(sys.argv[1])
bounce_time = int(sys.argv[2])

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

#set GPIO PINS
GPIO.setmode(GPIO.BCM)

GPIO.setup(GPIOin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

# Hier Flankensteuerung FALLING, RISING, BOTH oder beides #
GPIO.add_event_detect(GPIOin, GPIO.RISING, bouncetime=bounce_time)

def Measure(GPIOin):
#Read input Pin
Status = GPIO.input(GPIOin)
return Status

ab hier
if(GPIO.input(GPIOin) <> 1):
if now - startzeit > 2


Status = Measure(GPIOin)
print Status
GPIO.cleanup()



Ich habe mal die bouncetime=bounce_time mit eingebunden und bis auf max 900000000ms (sudo ./schaltkontakt.py 16 900000000) erhöht.
Da hätte eigentlich eine art Verzögerung von 900000000ms zustande kommen müssen, aber da tat sich nichts!!!
Die bouncetime ist so glaube ich auch anders zu verstehen, ab wie viel ms Spannungsänderung der eventhandler anspringen soll.

Hallo Paul,

sorry ich wollte mir das egentlich schon gestern anschauen. Naja hatte ein wenig Kopfweh

Hab mal eben in der Mittagspause drauf geschaut.

Ich konnte erst mal auch bei den Entwicklern der Lib nichts zu der Bouncetime finden. Hab aber auch nicht gründlich gesucht, zwecks Zeitmangel



Ich habe den Vorschalg gerade aufgegriffen und mal ein wenig abgeändert. Ich denke einen Zeitstempel brauchen wir dort nicht. Habe es jetzt so realisiert, dass 5 Messungen in Folge den gleichen Wert haben müssen damit dieser Wert dann ausgegeben wird. Kritisch wird es nur wenn nie 5 Werte in Folge den gleichen Wert erreichen sollten. Dann würde das Programm festhängen.

Ich denke aber das das in der Praxis nicht vorkommen sollte. Ich könnte aber eine EXIT mit einbauen, die das abfangen würde. Müsst ihr entscheiden ob das benötigt wird.

Hier mal ein Python skript, habe ich eben in der schnelle geschrieben und nicht getestet, da ich ja noch auf Arbeit bin

Vielleicht bist du noch mal so gut und testest es für mich.



EDIT: import time hinzugefügt

_________________
____________________
Viele Grüße
Dennis
____________________

Hallo Dennis,
es kommen leider noch Fehler, einige habe ich schon geändert, sind rot makiert.

Aber die define für START und counter fehlt noch.
Desweiteren bin ich mir nicht sicher über den Befehl time.sleep(2) der wird auf jeden Fall in sec. nicht msec. geschrieben.
Ist time.sleep(2)nicht dasselbe wie sleep(2)

"time.sleep(secs)
Suspend execution of the current thread for the given number of seconds. The argument may be a floating point number to indicate a more precise sleep time. The actual suspension time may be less than that requested because any caught signal will terminate the sleep() following execution of that signal’s catching routine. Also, the suspension time may be longer than requested by an arbitrary amount because of the scheduling of other activity in the system."

#!/usr/bin/python2.7
# -*- coding: utf-8 -*-

#-----------------------------#
#Author: Dennis
#Date: 04/05/2015
#Module: Lib to detect a normal switch
#-----------------------------#

#import required libraries
import RPi.GPIO as GPIO
import sys
import time

#define GPIO PINs
GPIOin = int(sys.argv[1])
bounce_time = int(sys.argv[2])

#disable failure outputs to avoid unexpected log outputs
GPIO.setwarnings(False)

#set GPIO PINS
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIOin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

# Hier Flankensteuerung FALLING, RISING, BOTH oder beides #
GPIO.add_event_detect(GPIOin, GPIO.RISING, bouncetime=bounce_time)

def Measure(IN):
#Read input Pin
Status = GPIO.input(IN)
return Status


#------------Start measurement with X retries------------
#define variables guard condition of the while loop and how many equal values in a row must be detected
retries = 5
guard = 1

counter = ?
START = ?


#Start main loop
while guard:
#2sec time for contact
time.sleep(2) ???????
#if counter == 0 than start to measure initial state of input pin
if counter == 0:
START = Measure(GPIOin)

#check how many successful retries detected
if counter < retries:
#if not all retries are done, perform one more measurement
CYCLE = Measure(GPIOin)
#check if START value and CYCLE value are equal, if YES counter will be increase, if NOT the measurement will start with counter 0 and new cycle
if START == CYCLE:
counter = counter + 1
else:
counter = 0
else:
guard = 0
#If all value are equal loop will be exit and Measurement will be returned
print START

GPIO.cleanup()

Neuer Tag neues Glück.

Habe nochmal Hand angelegt, mit Deutscher Übersetzung:

#!/usr/bin/python2.7
# -*- coding: utf-8 -*-

#Import der erforderlichen Bibliotheken
import RPi.GPIO as GPIO
import sys
import time

#definieren der GPIO PINs
GPIOin = int(sys.argv[1])
bounce_time = int(sys.argv[2])

#deaktivieren Ausfall Ausgänge zu unerwarteten Log-Ausgaben zu vermeiden
GPIO.setwarnings(False)

#set GPIO PINS
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIOin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

# Hier Flankensteuerung FALLING, RISING, BOTH oder beides #
GPIO.add_event_detect(GPIOin, GPIO.RISING, bouncetime=bounce_time)

def Measure(IN):
#Read input Pin
Status = GPIO.input(IN)
return Status


#------------Start Messung mit X Wiederholungen------------
#definieren Variablen Schutzzustand der Schleife und wie viele gleiche Werte in einer Reihe nachgewiesen werden
retries = 5
guard = 1
START = Measure(GPIOin)

def counter():
global counter
counter = counter+1

#Start Hauptschleife
while guard:
#4sec Messzeit
time.sleep(4)
#wenn Zähler == 0 beginnen, als Ausgangszustand des Eingangs-Pin zu messen
if counter == 0:
START

#prüfen, wie viele erfolgreiche Wiederholungen erkannt werden
if counter < retries:
#wenn nicht alle Wiederholungsversuche durchgeführt werden, führe eine weitere Messung durch
CYCLE = Measure(GPIOin)
#überprüfe ob Startwert und Zykluswert gleich sind, wenn JA Zähler erhöhen, wenn nicht die Messung mit Zähler 0 und neuen Zyklus zu beginnen
if START == CYCLE:
counter = counter + 1
else:
counter = 0
else:
guard = 0
#Wenn alle Werte in der Schleife gleich sind Messung zurückgegeben
print START

GPIO.cleanup()

Bei der Definition des counters bin ich mir nicht so sicher.
def counter():
global counter
counter = counter+1

Es kommt zwar keine Fehlermeldung aber er gibt so scheint es mir auch bei 5 verschiedenen Werten ein Ergebnis aus.



Evtl. kann der Dennis nochmal drüber schauen?

Anzeige:

_________________
Wenn du einen Monat lang ein werbefreies Forum willst, klicke hier und überweise mir 100 Taler!
Wenn du mich im Koi-Schnack etwas fragen möchtest, klicke hier!

Hallo Paul,

danke für die Korrekturen. In der Eile habe ich da wohl etwas vergessen



Dann mal los

Ich habe auch ein Teil der Beschreibung angepasst zu deinem angepassten Programm
while guard:
#100msec Wartezeit zwischen den Messungen
time.sleep(0.1)
#wenn Zähler == 0 beginnen, als Ausgangszustand des Eingangs-Pin zu messen
if counter == 0:
START

=============================================================
# Hier Flankensteuerung FALLING, RISING, BOTH oder beides #
GPIO.add_event_detect(GPIOin, GPIO.RISING, bouncetime=bounce_time)

Was möchtest du denn hier mit erreichen? Du führst es ja nur aus, verarbeitest es aber nicht in den weiteren Ausführung
Das müsste dann in etwa so aussehen. Während der Messung müsste dieser Code eingefügt werden, dass falls eine steigende Flanke detectiert wird, die Schleife verlassen wird und eine "1" ausgegeben wird

if GPIO.event_detected(GPIOin):
print "1"

So müsste das dann in unserem Code aussehen:
#Start Hauptschleife
while guard:
#100msec Wartezeit zwischen den Messungen
time.sleep(0.1)
#wenn Zähler == 0 beginnen, als Ausgangszustand des Eingangs-Pin zu messen
if counter == 0:
START

#prüfen, wie viele erfolgreiche Wiederholungen erkannt werden
if counter < retries:
#wenn nicht alle Wiederholungsversuche durchgeführt werden, führe eine weitere Messung durch
CYCLE = Measure(GPIOin)
#wenn zwischenzeitlich eine steigende Flanke am Eingang erkannt wurde wird eine "1" ausgegeben und das Programm vorzeitig beendet
if GPIO.event_detected(GPIOin):
print "1"
break
#überprüfe ob Startwert und Zykluswert gleich sind, wenn JA Zähler erhöhen, wenn nicht die Messung mit Zähler 0 und neuen Zyklus zu beginnen
if START == CYCLE:
counter = counter + 1
else:
counter = 0
else:
guard = 0
#Wenn alle Werte in der Schleife gleich sind Messung zurückgegeben
print START

Hier noch mal der ganze Code:

_________________
____________________
Viele Grüße
Dennis
____________________

Upps gerade gesehen, du hast ja noch mehr geändert

Dies wird so leider nicht funktionieren



Wenn Du genau in dem Moment nach der oder in der Messung den Schalter drücken würdest, hättst du dir eine Endless Loop geschaffen (Ohne meine hinzugefügte break Schleife)

Weil bei der definition START == 0 wäre und er dann immer CYCLE ==1 messen würde. Damit könnte die Schleife nicht mehr verlassen werden.

Ist eher schlecht geeignet.



Auch das für den Counter eine eigene Funktion zu schreiben ist unnötig aus meiner Sicht und führt zur Verwirrung.


Hier noch einmal der Komplette Code:


Irgendwie wird bei mir das einrücken nicht korrekt dargestellt, deshalb nochmal ein Bild dazu:

_________________
____________________
Viele Grüße
Dennis
____________________

Hallo Dennis,
das mit der Zähl-schleife war eine gute Idee von Dir.

Auch mit der Flankensteuerung und der bounce hat sich erübrigt, das habe ich ganz weggelassen.
# Hier Flankensteuerung FALLING, RISING, BOTH oder beides #
GPIO.add_event_detect(GPIOin, GPIO.RISING, bouncetime=bounce_time)

Um gegebenenfalls die Wartezeit anzupassen habe ich so genutzt:
#Wartezeit zwischen den Messungen
Wartezeit = int(sys.argv[2])

Für Testzweck habe ich das zwischen gesetzt Zeile 66- 70 kann dann wenn es implementiert wird gelöscht werden.
# Nur zum Testen Ausgabe Zähler und GPIOin Status
print "Zaehler " + str(counter)
Status = Measure(GPIOin)
print "Eingang ist " + str(Status)

Hier der Code:
#!/usr/bin/python2.7
# -*- coding: utf-8 -*-
#============================================================================================================================================
#Title : Pegelschalter an GPIO auslesen
#Author : Gemeinschaftsarbeit Dennis schnuffi / Paul Fischkopf
#Datum : 05.05.2015
#Version : 08
# GPIO Wartezeit
# ^ ^
#Anwendung :Starte Script mit z.b pi@raspberrypi $ sudo ./schaltkontakt.py 16 1
#Notizen :Um einen GPIO zu exportieren muessen wir jedoch Root sein. Entweder wechselt man vorher zum Root-Benutzer, oder benutzt sudo.
# Es muessen fünf gleiche Eingangssignale innerhalb der frei wählbaren Wartezeit zwischen den Messwerten erreicht werden,
# um dann die Ausgabe zu erhalten.
#===========================================================================================================================================

#Import der erforderlichen Bibliotheken
import RPi.GPIO as GPIO
import sys
import time

#definieren der GPIO PINs
GPIOin = int(sys.argv[1])

#Wartezeit zwischen den Messungen
Wartezeit = int(sys.argv[2])

#deaktivieren Ausfall Ausgänge um unerwarteten Log-Ausgaben zu vermeiden
GPIO.setwarnings(False)

#set GPIO PINS
GPIO.setmode(GPIO.BCM)
GPIO.setup(GPIOin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)


def Measure(IN):
#Read input Pin
Status = GPIO.input(IN)
return Status


#------------Start Messung mit X Wiederholungen------------
#definieren Variablen Schutzzustand der Schleife und wie viele gleiche Werte in einer Reihe nachgewiesen werden
retries = 5
guard = 1
counter = 0
#Da der counter bei betreten der Schleife eh 0 ist wird eine Messung erzwungen, so kann START einfach mit 0 deklariert werden
START = 0


#Start Hauptschleife
while guard:
#Wartezeit zwischen den Messungen
time.sleep(Wartezeit)
#wenn Zähler == 0 beginnen, als Ausgangszustand des Eingangs-Pin zu messen
if counter == 0:
START = Measure(GPIOin)

#prüfen, wie viele erfolgreiche Wiederholungen erkannt werden
if counter < retries:
#wenn nicht alle Wiederholungsversuche durchgeführt werden, führe eine weitere Messung durch
CYCLE = Measure(GPIOin)
#überprüfe ob Startwert und Zykluswert gleich sind, wenn JA Zähler erhöhen, wenn nicht die Messung mit Zähler 0 und neuen Zyklus zu beginnen
if START == CYCLE:
counter = counter + 1

# Nur zum Testen Ausgabe Zähler und GPIOin Status
#print "Zaehler " + str(counter)
#Status = Measure(GPIOin)
#print "Eingang ist " + str(Status)

else:
counter = 0
else:
guard = 0
#Wenn alle Werte in der Schleife gleich sind Messung zurückgegeben
print START

GPIO.cleanup()

Ende



Ansonsten Funktioniert das Skript siehe hier: zum Testen Ausgabe mit Zähler und GPIOin Status


Skript kann eigentlich in die Teich-Software eingebaut werden Gunter