Raspberry Pi - GPIO-Ereignisse in Python

Ich bin mit den GPIO-pins meines Raspberry Pi mit einem PIR-sensor zur Bewegungserkennung. Wenn der sensor Bewegung erkennt, will ich dann die software auf andere Funktionen.

Im moment, die Bewegung zu erfassen, ich habe mein Programm ständig läuft in einer Schleife, während er wartet für die Bewegung erkannt werden. Das funktioniert zwar im moment, für den Einsatz in der Zukunft wird dies unglaublich ineffizient und bin der Hoffnung, zu verbessern, indem die Zuordnung zu einem Ereignis.

Gibt es eine Möglichkeit, zu binden meine GPIO-Eingang auf ein Ereignis, das vom Programm erkannt, ohne manuelles ausführen einer Schleife.

Hier ist meine derzeitige Schleife für die Erkennung Bewegung:

var = 1
counter = 0
while var == 1:
    if GPIO.input(7):
        counter += 1
        time.sleep(0.5)
    else:
        counter = 0
        time.sleep(1)

    if counter >= 3:
        print "Movement!"
        captureImage()
        time.sleep(20)

Den Zähler und die Erkennung von Bewegung mehrere Male verwendet wird, reduzieren Sie die Anzahl der false positives, die der sensor aufnimmt.

InformationsquelleAutor der Frage Stefoth | 2013-04-22

Den RPi.GPIO Python-Bibliothek unterstützt jetzt Veranstaltungendie erklärt werden in der Interrupts und Kantenerkennung Absatz.

Also nach der Aktualisierung Ihres Raspberry Pi mit sudo rpi-update um die neueste version der Bibliothek, können Sie den code ändern zu:

from time import sleep
import RPi.GPIO as GPIO

var=1
counter = 0

GPIO.setmode(GPIO.BOARD)
GPIO.setup(7, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

def my_callback(channel):
    if var == 1:
        sleep(1.5)  # confirm the movement by waiting 1.5 sec 
        if GPIO.input(7): # and check again the input
            print("Movement!")
            captureImage()

            # stop detection for 20 sec
            GPIO.remove_event_detect(7)
            sleep(20)
            GPIO.add_event_detect(7, GPIO.RISING, callback=my_callback, bouncetime=300)

GPIO.add_event_detect(7, GPIO.RISING, callback=my_callback, bouncetime=300)

# you can continue doing other stuff here
while True:
    pass

Wählte ich die Gewinde-Rückrufe Methode, weil ich vermute, dass dein Programm macht andere Dinge parallel um den Wert zu ändern von var.

InformationsquelleAutor der Antwort kapcom01

3

Nun die RPi-GPIO-Bibliothek hat eingebaute interrupt-gesteuerten GPIO-Steuerung, die passieren können in einem separaten thread Ressourcen.
Möchten Sie vielleicht Lesen Sie die folgenden http://raspi.tv/2013/how-to-use-interrupts-with-python-on-the-raspberry-pi-and-rpi-gpio-part-3

InformationsquelleAutor der Antwort Nipun Batra
1

Könnten Sie wickeln die GPIO-code in einen eigenen thread und der rest von Ihrem Programm etwas anderes tun, während der GPIO auf eine Eingabe wartet. Überprüfen Sie heraus die threading-Modul

Zuerst würde ich wickeln Sie Ihren code in eine Funktion
```
def wait_input():
    var=1
    counter = 0
    while var == 1:
        if GPIO.input(7):
            counter += 1
        time.sleep(0.5)
        else:
            counter = 0
            time.sleep(1)
        if counter >= 3:
            print "Movement!"
            captureImage()
            time.sleep(20)
```
Und dann in deinem main-Programm könnten Sie so etwas wie dieses
```
input_thread = threading.Thread(target = wait_input)
input_thread.start()
# do something in the meanwhile
input_thread.join()
```
Gibt es viele Fragen auf, SO über python threading, so möchten Sie vielleicht, um Sie wieder auszugraben. Bitte beachten Sie, dass es gibt auch viele Dinge zu beachten bei der Verwendung von threads, vor allem in python hat eine Globale interpreter lock (GIL), das erlaubt nur einen Prozess gleichzeitig ausführen. Es kann auch klug sein, zu prüfen, den multiprocessing-Modulmit der man weiterleiten kann um die GIL.

InformationsquelleAutor der Antwort msvalkon

kapcom01 gibt einige gute Ideen, aber es ist besser zu machen, nicht machen eine Menge von Anweisungen, die in der einen interrupt.

In der Regel setzen Sie ein flag auf 1, wenn die callback-Anruf, und Sie machen die Verarbeitung in der main-Funktion. In ders Weise gibt es keine Gefahr von Frost das programm.

Jährigen so :

     from time import sleep
     import RPi.GPIO as GPIO



     def init():
         # make all your initialization here
         flag_callback = False
         # add an interrupt on pin number 7 on rising edge
         GPIO.add_event_detect(7, GPIO.RISING, callback=my_callback, bouncetime=300)


     def my_callback():
         # callback = function which call when a signal rising edge on pin 7
         flag_callback = True


     def process_callback():
         # TODO: make process here
         print('something')


     if __name__ == '__main__':
     # your main function here

     # 1- first call init function
     init()

     # 2- looping infinitely 
     while True:
         #3- test if a callback happen
         if flag_callback is True:
             #4- call a particular function
             process_callback()
             #5- reset flagfor next interrupt
             flag_callback = False
    pass

InformationsquelleAutor der Antwort Lemaitre Cedric

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.