GPIO als Eingang zu empindlich....

Heute ist Stammtischzeit:
Jeden Donnerstag 20:30 Uhr hier im Chat.
Wer Lust hat, kann sich gerne beteiligen. ;)
  • Tach Leute,

    ich bin auf der Suche nach einer Lösung und vielleicht könnt Ihr mir behilflich dabei sein.
    Ich hab einen PI zu hause am laufen, der einige Dinge steuert. Die neueste Steuerung ist gestern dazugekommen und funktioniert nicht so richtig.

    Also, Funktion Kurz beschrieben:

    Mein PI macht u.a. das Gartentor auf und zu. Getriggert wird das über ein Webinterface und einer Fernbediehnung.
    Nun möchte ich ohne großen Aufwand das Tor auch von außen aufmachen können für z.B. für Leute die keine FB und Kein Smartphone haben. Meine Idee, den Klingelknopf zu "missbrauchen". Klappt auch ganz gut NUR.... ich bekomme ständig Störungen die dann die Klingel ungewollt auslösen. Da reicht schon ein Relais oder sowas.... Ich hab den GPIO.input mit nem 10KOhm R gegen Masse versehen. Außerdem ist der Eingang im python-code auch mit nem PullDown versehen.

    Hier mein Code:

    Hat jemand ne Idee oder ähnliches Problem schon einmal gelöst????

    Dankke und Gruß

    Christian

  • Hallo Christian,

    ohne Schaltung wird da wohl kein guter Rat möglich sein.

    Deine Fehlerbeschreibung hat Ähnlichkeit mit Schaltungen, in denen ein Draht in einen GPIO-Eingang gesteckt wird. Der GPIO fängt alle möglichen Störsignale auf, die mit dem Zustand eines Tasters / Schalters so gar nicht in einem ursächlichen Zusammenhang stehen.

    Schau Dir mal in diesem Forum einige Schaltungen an, in denen Taster abgefragt werden. Wenn Du da prinzipielle Änderungen zu Deiner Schaltung feststellst, dann hast Du den Fehler gefunden und einen Lösungsvorschlag.

    Das Stichwort heißt Pullup- oder Pulldown-Widerstand, abhängig davon, in welcher Reihenfolge bei Dir der Widerstand verbaut ist:
    - Zwischen 3V3 und Taster: Pullup
    - Zwischen Taster und GND: Pulldown

    Hier einer von vielen Taster-Abfragen:

    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

    2 Mal editiert, zuletzt von Andreas (12. Oktober 2017 um 00:53)

  • Wie lang ist denn das Kabel zu dem Schalter?
    Wenn es ein langes Kabel ist, dann kann es auch als Antenne wirken, was dir allerlei Störungen einbringt.
    Da könnte man ein abgeschirmtes Kabel versuchen.

    Was noch sein könnte ist das der Schalter prellt, da gibt es auch viele Lösungen zu, einfach mal nach prellen bzw entprellen suchen.

    Nebenbei, wenn du extern schon ein Pulldown machst, dann sollte man den Internen nicht auch noch schalten. Bzw wenn den Intern machst brauchst du den externen nicht. Je nachdem wie ob es gleiche oder unterschiedliche Wiederstands-Werte sind kann da ja auch schon ein Stromfluss durch entstehen. Also auch ein Lösungsansatz mal versuchen nur extern oder nur intern zu nutzen.

  • Hallo RyuKajiya,

    das Kabel ist in der Tat ziemlich lang aber CAT6, also wenigstens etwas geschirmt.
    der Schalter prellt bestimmt, das wollte ich aber im script mit wait_for_edge(GPIO.RISING) und dem time.sleep(1) etwas entschärfen. Funktioniert auch denke ich. Was in der Schaltung passiert ist ein sporadisches Auslösen durch was auch immer ohne das jemand auch nur in der Nähe des Tasters ist.

    Was ich auch grade bemerkt habe ist, beim Trennen des Taser-Kabels von PI (mit Platine und Schraubklemme)ist, dass der input schon ausgelöst wird wenn ich nur mit nem schraubendreher an die klemme komme. das sollte doch mit dem internen PullDown nicht passieren oder?????

    Gruß

    Christian

  • Es gibt 2 Möglichkeiten die im Prinzip das selbe bewirken:

    - Hardware: einen 100uF Kondensator parallel zum Klingeltaster anbringen
    - Software: via Interrupt (add_event_detect) den Parameter 'bouncetime' verwenden.

    Beides sorgt für eine sog. Entprellung. (Forumsuche nach: prellen).


    Allgemein würde ich dir aber auch dazu raten Interrupts zu nutzen, aber nicht wait_for_edge. Wobei ich bei deinem Script auch noch 2-3 andere Dinge bemängeln würde :fies:
    - setz den Hauptteil des Scripts zwischen "try:" und "except" um Fehler abzufangen.
    - ans ende füngst du ab besten dann auch noch ein "except (KeyboardInterrupt, SystemExit):" ein und da drunter ein "GPIO.cleanup()" um sicher zu gehen das beim beenden des Scripts die GPIOs resettet werden.
    - die for Schleife macht für mich irgendwie kein Sinn :s
    - nach dem "#print i" hast du ein Schreibfehler, da fehlt ein ( vor 22. Die if Schleife wird so wie es da zZt steht nicht funktionieren..
    - welcher GPIO ist für was zuständig? :s


    Ansonsten wäre es hilfreich auch einen Schaltplan zu sehen/kennen , also wie du was und wo angeschlossen hast..

  • ersteinmal vielen Dank für die schnelle Hilfe und die Tips.
    Der ElKo war es (vorhanden aber eine Seite nicht gelötet).
    Dennoch möchte ich die for-schleife kurz erklären und bin für jede Anregung dankbar.

    Wie schon im Eingang erwähnt, möchte ich mit dem Klingelknopf auch das Gartentor öffnen.
    Dazu hab ich die Schleife gebaut um zu erreichen, dass das Tor erst nach min. 5 Sekunden drücken aufgeht.
    GPIO 22 ist der Klingeltaster
    GPIO 10 macht das Tor zu
    GPIO 11 macht das tor auf
    GPIO 24 klingelt

    Ich bin kein Programmierer. für den Anfang hat es erstmal funktioniert.
    Wäre aber wie schon gesagt sehr dankbar für Verbesserungsvorschläge.
    Das script läuft die ganze zeit auf dem PI. Mit Wait_for_edge wartet das script halt auf ne aktion ohne die CPU zu sehr zu belasten denke ich....

    Gruß

    Christian

    Einmal editiert, zuletzt von DackS (19. Februar 2015 um 13:44)

  • Hi Christian,

    was läuft denn sonst noch so auf dem RPi?

    Wenn nur das Skript läuft, kannst du eigentlich auf Interrupts verzichten.

    Grundsätzlich würde ich auch eher Pull-Ups statt Pull-Downs verwenden.

    Ich bin mir nicht sicher, aber ich glaube "GPIO.wait_for_edge" ist ein blockierender
    Zugriff. Ich würde eher jeweils den Zustand non-blocking einlesen und dann 0.1 Sekunden warten. Mit Hilfe einer Variablen kannst du dann auf Zustandswechsel reagieren (Falling-Edge). Das Ganze würde man auch so hinbekommen, dass die Taste mind. 5 Sekunden
    gedrückt werden muss.

    hdo

  • Mit Wait_for_edge wartet das script halt auf ne aktion ohne die CPU zu sehr zu belasten denke ich....

    Ja das ist richtig und auch gut so. :thumbs1:
    So wird kein Tastendrücken verpasst - also Interrupt ist in jedem Fall besser als irgendwelche while Schleifen.


    Aber wie gesagt, das funktioniert nicht: if GPIO.input22) == GPIO.HIGH:
    müsste stattdessen so aussehen: if GPIO.input(22) == GPIO.HIGH:

    Aber bist du sicher das der Rest funktioniert?

    Denn du machst ja grob:

    Code
    GPIO.setup(22, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
      GPIO.wait_for_edge(22, GPIO.RISING)
      for i in range(6):
        if GPIO.input(22) == GPIO.LOW:

    Ein edge ist eine Änderung zwischen
    LOW auf HIGH -> Rising edge
    oder von
    HIGH auf LOW -> Falling edge

    Demzufolge kann die erste if Abfrage nie zutreffen da das Programm ja nur dann weiter macht wenn sich der Zustand von LOW auf HIGH geändert hat. GPIO.input(22) ist dann also HIGH aber nicht LOW -> Rising Edge

    :denker:

    //EDIT:


    Wenn nur das Skript läuft, kannst du eigentlich auf Interrupts verzichten.

    Grundsätzlich würde ich auch eher Pull-Ups statt Pull-Downs verwenden.

    Dem muss ich widersprechen. Pull-Down ist schon gut weil dann GND auf den GPIO geschaltet wird, nicht 3V3.

    Ich bin mir nicht sicher, aber ich glaube "GPIO.wait_for_edge" ist ein blockierender Zugriff. Ich würde eher jeweils den Zustand non-blocking einlesen und dann 0.1 Sekunden warten.

    Ehm, wenn man mithilfe time.sleep wartet wird das Script auch blockiert. Das was du schreibst widerspricht sich also etwas, vorallem aber weil in der Zeit wo das Script durch time.sleep blockiert wird auf kein Tastendruck reagiert werden kann - im Gegensatz zum GPIO.wait_for_edge denn das lässt das Programm weiter laufen sobald ein Tastendruck erkannt wurde.
    Also GPIO.wait_for_edge ist imho besser als die leichter zu verstehende " while 1: time.sleep " Sache.

    Les dir dazu mal das durch: http://sourceforge.net/p/raspberry-gpio-python/wiki/Inputs/

  • Hi hdo26,

    ....es laufen noch zwei drei andere kleine scripts und ´n Apache auf dem RPi.
    Ich glaub ich muß mich noch tiefer in die Python-materie einlesen um ne ordentliche Programmierung hin zu bekommen... :)

    :danke_ATDE:

  • Ah ok. Apache ist allerdings alles andere als light-weight :)

    Wenn du Polling statt Interrupts verwendest, solltest du irgendwo
    ein 'sleep' einbauen, sonst hast du 100% CPU Auslastung.



    Hi hdo26,

    ....es laufen noch zwei drei andere kleine scripts und ´n Apache auf dem RPi.
    Ich glaub ich muß mich noch tiefer in die Python-materie einlesen um ne ordentliche Programmierung hin zu bekommen... :)

    :danke_ATDE:

    Zitat

    Dem muss ich widersprechen. Pull-Down ist schon gut weil dann GND auf den GPIO geschaltet wird, nicht 3V3.

    Sorry, das verstehe ich nicht ???

    Zitat

    Ehm, wenn man mithilfe time.sleep wartet wird das Script auch blockiert. Das was du schreibst widerspricht sich also etwas, vorallem aber weil in der Zeit wo das Script durch time.sleep blockiert wird auf kein Tastendruck reagiert werden kann - im Gegensatz zum GPIO.wait_for_edge denn das lässt das Programm weiter laufen sobald ein Tastendruck erkannt wurde.
    Also GPIO.wait_for_edge ist imho besser als die allgemein übliche " while 1: time.sleep " Sache.

    Les dir dazu mal das durch: http://sourceforge.net/p/raspberry-gpio-python/wiki/Inputs/

    Nah, es kommt ganz darauf an, was man machen will. Bei 'GPIO.wait_for_edge' muss
    man mit Treads arbeiten, wenn man im Hintergrund andere Sachen machen will.
    Grundsätzlich gebe ich dir aber recht was Interrupts betrifft.
    Mit Polling kriegt man keine 'Echt-Zeit' Button-Events hin. Für eine Garagentor-Steuerung
    sehe ich das aber nicht als kritisch.

    In meinem Jukebox Projekt benutze ich auch nur 'Polling' und es läuft wunderbar:

    https://github.com/hdo/jukebox4kids/blob/master/pyjukebox.py
    https://github.com/hdo/lpcx1343_c…s_ui/src/main.c

    Einmal editiert, zuletzt von hdo26 (19. Februar 2015 um 14:40)

  • @ meigrafd,

    Zitat

    Demzufolge kann die erste if Abfrage nie zutreffen da ja das Programm ja nur dann weiter macht wenn sich der Zustand von LOW auf HIGH geändert hat. GPIO.input(22) ist dann also HIGH aber nicht LOW -> Rising Edge

    Ich hatte mir das so gedacht:

    das script wartet auf ne ansteigende Flanke an GPIO.22

    wenn die kommt wird die for-schleife ausgeführt und wenn wärend der for-schleife die taste losgelassen wird (GPIO.22 == LOW), dann soll Klingel klingeln.

    Wenn nicht, soll nach fünf Durchläufen das Tor geöffnet bzw. geschlossen werden.


    Funktioniert auch so....mehr oder weniger.....
    Hatte gerade bei einem Test, dass die Klingel klingelte obwohl das Tor auf ging.
    Muß ich wohl noch mal rann....

    hmmmm :denker:

    Gruß

    Christian

  • Du willst also nur mit einer Taste sowohl Klingeln als auch das Tor aufmachen?

    Taste < 5 Sekunden = klingeln
    Taste >= 5 Sekunden = Tor aufmachen

    Ist das nicht etwas riskant? (Sicherheit etc.)

    hdo



  • Wenn du Polling statt Interrupts verwendest, solltest du irgendwo
    ein 'sleep' einbauen, sonst hast du 100% CPU Auslastung.

    Da er das aber nicht tut brauch er das auch nicht - und davon würde ich wie gesagt auch abraten.

    Ein 'sleep' blockiert das Script wahrhaftig und sorgt dafür das in der Zeit tatsächlich kein Tastendruck erkannt wird, eben weil das 'sleep' quasi auf Pause drückt.

    Das von DackS verwendete ist weitaus besser:

    Zitat

    The wait_for_edge() function is designed to block execution of your program until an edge is detected.

    Sobald also ein EDGE erkannt wurde wird der Programmcode weiter ausgeführt, die Pause gelöst, nichts mehr blockiert. Solange also der nachfolgende Code schnell genug ausgeführt aber auch nicht unnötig aufgehalten wird, wird auch kein Tastendruck verpasst. Wenn letzteres wichtig ist nutzt man stattdessen event_detected()


    Sorry, das verstehe ich nicht ???

    Wieso rätst du dann das andere wenn du den Unterschied aber nicht verstehst? :(

    Pull-DOWN -> GND runter auf GPIO
    Pull-UP -> 3V3 rauf auf GPIO

    GND zu schalten ist immer besser/schonender für die Hardware.

    Nah, es kommt ganz darauf an, was man machen will.

    Wir sind hier nicht in einem Thread zur Grundsatz-Diskussion. Wir müssen hier also auch nicht alle Variationen durchkauen die für jeweils unterschiedliche Vorhaben angemessen wären..

    Für das Vorhaben des TE's ist der von ihm gewählte Weg der bessere

    Bei 'GPIO.wait_for_edge' muss man mit Treads arbeiten, wenn man im Hintergrund andere Sachen machen will.

    Ehm - und mit sleep's muss man das nicht oder wie? :s
    Wenn man mit der von dir vorgeschlagenen Methode arbeiten würde und parallel etwas ausführen will muss man ebenfalls mit Threads arbeiten. Also bitte den Kontext, meine Antwort auf Dein zuvor geschriebenes, beachten.

    Er muss für sein Vorhaben nicht mit Threads arbeiten, denn Er möchte parallel ja auch nichts ausführen.

    Mit Polling kriegt man keine 'Echt-Zeit' Button-Events hin. Für eine Garagentor-Steuerung sehe ich das aber nicht als kritisch.

    Da er aber nicht 6 Sekunden anstatt eigentlich nur 5 Sekunden den Klingeltaster gedrückt halten will um das Garagentor zu öffnen, empfiehlt es sich eine möglichst genaue Methode zu verwenden und das wäre besagte Interrupts Geschichte. Mit deinem "Polling" wird das ganze ungenauer und wäre letztlich nicht mehr die gewollten 5 Sekunden sondern 5,5 Sekunden o.ä....

    In meinem Jukebox Projekt benutze ich auch nur 'Polling' und es läuft wunderbar:

    https://github.com/hdo/jukebox4kids/blob/master/pyjukebox.py
    https://github.com/hdo/lpcx1343_c…s_ui/src/main.c

    Ich hab nichts davon gesagt dass das NICHT funktionieren würde ...


    Aber wie gesagt - wir driften ab - das ist hier Offtopic.


    PS: Bitte gewöhn dir ab die Posts die genau da drüber stehen vollständig zu quoten.

  • Zitat


    Wieso rätst du dann das andere wenn du den Unterschied aber nicht verstehst? Icon_nosmile

    Pull-DOWN -> GND runter auf GPIO
    Pull-UP -> 3V3 rauf auf GPIO

    GND zu schalten ist immer besser/schonender für die Hardware.

    Ähm, genau das habe ich gemeint. Ich schalte grundsätzlich nach GND,
    deswegen verwende ich Pull-Ups (IO mit R nach VCC).
    Mit Pull-Up schaltet der Taster IO nach GND und mit Pull-Down schaltet der Taster
    IO nach VCC. Christian verwendet Pull-Downs. In der Praxis wird halt
    oft Pull-Ups verwendet (TTL UART, i2c, SPI, etc.).
    Den Unterschied kenne ich schon.

    Wie dem auch sei, jeder das Seine. Weiter gehts ...

    Einmal editiert, zuletzt von hdo26 (19. Februar 2015 um 15:10)

  • Spoiler anzeigen

    ..Dann verwendest du Hardware pull_up_down... Das ist aber ein Unterschied zu dem hier verwendeten Softwarelösung, bzw wird durch die Software der für jeden GPIO vorhandene RPI-Eigene pull_up_down dann verwendet... Das kannst du auch auf der von mir bereits erwähnten Seite nachlesen: http://sourceforge.net/p/raspberry-gpio-python/wiki/Inputs/

    Zitat

    It is possible to have pull up/down resistors in hardware and using software. In hardware, a 10K resistor between the input channel and 3.3V (pull-up) or 0V (pull-down) is commonly used. The RPi.GPIO module allows you to configure the Broadcom SOC to do this in software


    Um sich zu merken wie lange ein Taster bereits gedrückt wurde, habe ich erst kürzlich hier im Forum ein Script umgeschrieben und 2 Beiträge drunter auch erklärt: >> hier <<

    Da sollte auch ein Taster mit 2 verschiedenen Funktionen nutzbar gemacht werden, was hier ja auch der Fall ist.
    Das Script reagiert auf beides: Drücken und loslassen des Tasters. Beim drücken wird eine Zeit gespeichert und beim los lassen dann festgestellt wie lange der Taster gedrückt wurde. War es länger als zB 1ne Sekunde wird die 'special' Geschichte ausgeführt, ansonsten die 'normal'

    Und dann haste ja grad auch ein Problem erwähnt das die Klingel klingelt obwohl das Tor gerade auffährt... Da würde dann halt das setzen einer Variable, ob das Tor auf oder Zu ist, helfen ;)
    Wobei hier vielleicht 2 Endschalter nicht schlecht wäre um den Tatsächlichen Zustand auch reell feststellen zu können.


    Vorschlag:

    [code=php]
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    #
    # v0.1 by meigrafd
    #
    import sys
    from time import sleep, time
    import RPi.GPIO as GPIO
    import signal
    #------------------------------------------------------------------------

    #GPIO pins
    Taster = 22
    Klingel = 24
    TorZu = 10
    TorAuf = 11

    #special function time (in sec) for Taster pin to open Door without Bell.
    SpecialTime = 5

    # only one of following:
    PULL = GPIO.PUD_DOWN #GPIO -> GND
    #PULL = GPIO.PUD_UP #GPIO -> 3V3

    # to use RaspberryPi gpio numbers
    GPIO.setmode(GPIO.BCM)

    #------------------------------------------------------------------------

    # set up GPIO channels
    GPIO.setup(Taster, GPIO.IN, pull_up_down = PULL)
    GPIO.setup(TorAuf, GPIO.OUT)
    GPIO.setup(TorZu, GPIO.OUT)
    GPIO.setup(Klingel, GPIO.OUT)

    #------------------------------------------------------------------------

    def DingDong():
    if not torStatus == "auf":
    GPIO.output(Klingel, GPIO.HIGH)
    sleep(0.1)
    GPIO.output(Klingel, GPIO.LOW)


    def Tor():
    global torStatus
    if torStatus == "zu":
    GPIO.output(TorAuf, GPIO.HIGH)
    sleep(0.1)
    GPIO.output(TorAuf, GPIO.LOW)
    print "Tor geht auf!"
    torStatus = "auf"
    elif torStatus == "auf":
    GPIO.output(TorZu, GPIO.HIGH)
    sleep(0.1)
    GPIO.output(TorZu, GPIO.LOW)
    print "Tor geht zu!"
    torStatus = "zu"


    def Interrupt_event(pin):
    global timeTrigger

    # only for debug:
    if GPIO.input(pin) == GPIO.HIGH:
    print "rising edge on %s" % pin
    elif GPIO.input(pin) == GPIO.LOW:
    print "falling edge on %s" % pin

    if pin == Taster:
    if GPIO.input(Taster) == GPIO.HIGH:
    timeTrigger = time()
    elif GPIO.input(Taster) == GPIO.LOW:
    timeTrigger = time() - timeTrigger
    if timeTrigger >= SpecialTime:
    timeTrigger = 0
    #special function
    print "special Taster"
    Tor()
    else:
    timeTrigger = 0
    print "normal Taster"
    DingDong()

    else:
    print "ERROR! Unknown GPIO pin triggered: %s" % pin

    #------------------------------------------------------------------------

    try:
    GPIO.add_event_detect(Taster, GPIO.BOTH, callback=Interrupt_event, bouncetime=150)
    timeTrigger = 0
    torStatus = "zu"
    #keep script running
    signal.pause()
    except (KeyboardInterrupt, SystemExit):
    GPIO.cleanup()
    print "\nQuit\n"
    [/php]

    Es klingelt halt erst dann wenn man den Taster los lässt ... Oder stört dich das? :fies:

  • @ meigrafd,

    Oh je, oh je,

    viel mehr code als bei mir.... da muss ich erstmal durchsteigen!

    Ich sehe grad, du hast dir ja die mühe gemacht und alles schon auf meine Bedürfnisse umgeschrieben....

    Kommt wohl aus dem Handgelenk wenn man schon ne weile programmiert.

    Bezüglich der Endschalter hab ich mir auch schon meine Gedanken gemacht. Muss halt was Wetterfestes sein....
    Dann geh´n wirklich die GPIOs bald zur neige.... :)


    Kann man eigentlich eine Variable in Python auch aus einem anderen script setzten????
    Also script "A" setzt z.b. i = 0, kann dann script "B" diese Variable auf 1 setzen???


    Vielen Dank für Deine Mühe

    Gruß

    Christian

    Einmal editiert, zuletzt von DackS (19. Februar 2015 um 17:12)

  • Sieht nur nach mehr aus weil ich mehr Variablen gesetzt hab.. Finde ich besser da man dann nur den Wert der Variable ändern muss aber nicht mehrere Zeilen im Code.

    Unterschied ist auch das ich sowas wie die Klingel oder das öffnen/schließen des Tor's in eine eigene Funktion gepackt habe.

    Auch ist ein Unterschied das ich event_detect() mit einer Callback nutze - was den Vorteil hat das dieser Callback in einem eigenen Thread läuft, also unabhängig vom Rest, kann also nicht geblockt werden, so geht kein Tastendruck verloren.

    Zu dieser "Funktion" Schreibweise muss man halt wissen das die Variablen die innerhalb einer Funktion gesetzt werden, auch nur dort verfügbar/abrufbar sind - also 'local' sind. Variablen die ausserhalb Funktionen gesetzt wurden sind 'global' und in allen Funktionen verfügbar, aber innerhalb solcher nicht veränderbar. Damit letzteres funktioniert hat man 2 Möglichkeiten wobei ich die eher unschönere genommen habe damit es nicht zu kompliziert wird..


    Aufs nötigte gekürzt und ohne zu viel Variablen sieht der Code halt so aus:

    Spoiler anzeigen

    [code=php]
    from time import sleep, time
    import RPi.GPIO as GPIO
    import signal, sys
    #------------------------------------------------------------------------
    #special function time (in sec) for Taster pin to open Door without Bell.
    SpecialTime = 5
    #------------------------------------------------------------------------

    # to use RaspberryPi gpio numbers
    GPIO.setmode(GPIO.BCM)
    # set up GPIO channels
    GPIO.setup(22, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(11, GPIO.OUT)
    GPIO.setup(10, GPIO.OUT)
    GPIO.setup(24, GPIO.OUT)

    def DingDong():
    if not torStatus == "auf":
    GPIO.output(24, GPIO.HIGH)
    sleep(0.1)
    GPIO.output(24, GPIO.LOW)

    def Tor():
    global torStatus
    if torStatus == "zu":
    GPIO.output(11, GPIO.HIGH)
    sleep(0.1)
    GPIO.output(11, GPIO.LOW)
    print "Tor geht auf!"
    torStatus = "auf"
    elif torStatus == "auf":
    GPIO.output(10, GPIO.HIGH)
    sleep(0.1)
    GPIO.output(10, GPIO.LOW)
    print "Tor geht zu!"
    torStatus = "zu"

    def Interrupt_event(pin):
    global timeTrigger
    if GPIO.input(22) == GPIO.HIGH:
    timeTrigger = time()
    elif GPIO.input(22) == GPIO.LOW:
    timeTrigger = time() - timeTrigger
    if timeTrigger >= SpecialTime:
    timeTrigger = 0
    print "special Taster"
    Tor()
    else:
    timeTrigger = 0
    print "normal Taster"
    DingDong()

    #------------------------------------------------------------------------

    try:
    GPIO.add_event_detect(22, GPIO.BOTH, callback=Interrupt_event, bouncetime=150)
    timeTrigger = 0
    torStatus = "zu"
    #keep script running
    signal.pause()
    except (KeyboardInterrupt, SystemExit):
    GPIO.cleanup()
    print "\nQuit\n"
    [/php]


    Kann man eigentlich eine Variable in Python auch aus einem anderen script setzten????
    Also script "A" setzt z.b. i = 0, kann dann script "B" diese Variable auf 1 setzen???

    Jein. Nur indem man zB einen fifo nutzen würde, oder temporäre Dateien. Aber eigentlich kann man das andere Script importieren und die Funktionen dann in deinem einen Script nutzen, das wäre besser.

    Weshalb fragst du?

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!