Détection GPIO du Raspberry Pi: détection de mouvement

Dans les didacticiels précédents, nous avons décrit les bases de l’informatique physique et du Raspberry Pi en activant les LED et les scripts à l’aide d’un simple circuit à un bouton. Si vous n’avez pas lu les didacticiels précédents, veuillez le faire, car ils incluent quelques points (tels que la programmation Python de base et la numérotation GPIO Board / BCM) qui seront ignorés dans ce didacticiel.

Dans ce didacticiel, nous développerons les leçons précédentes en transplantant un bouton avec un capteur PIR (pour détecter le mouvement). Ce didacticiel décrira comment assembler le circuit avec un capteur PIR et élaborera un script simple pour imprimer un message lorsque le capteur détecte un mouvement. Dans le prochain tutoriel, nous allons ajouter un buzzer et des LED à notre circuit de détection pour déclencher une alarme lorsqu’un intrus est détecté!

Capteurs PIR

Les capteurs PIR, souvent appelés capteurs «infrarouge passif» ou «mouvement IR», vous permettent de détecter le mouvement. Tout émet une petite quantité de rayonnement infrarouge, et plus quelque chose est chaud, plus le rayonnement est émis. Les capteurs PIR sont capables de détecter un changement dans les niveaux IR de leur zone de détection (par exemple quand un humain entre dans une pièce) et donc de détecter le mouvement.

Les capteurs PIR que nous utiliserons dans ce didacticiel ont trois broches: masse, sortie numérique et entrée 3-5VDC. Au ralenti, quand aucun mouvement n’a été détecté, la sortie numérique restera faible, mais lorsqu’un mouvement est détecté, le numérique out émettra une impulsion élevée (3,3 V) et nous utiliserons notre Raspberry Pi pour le détecter! Les capteurs PIR que nous utiliserons dans ce didacticiel ont une portée d’environ 7 mètres et une plage de détection de 110 ° x 70 °, ce qui est idéal pour surveiller une porte ou le coin d’une pièce.

Pour cet exercice, vous aurez besoin de:

• Planche à pain
• 6 x fils de cavalier mâle à femelle
• Capteur PIR

Assembler le circuit

Remarque. Nous pourrions accrocher le PIR directement aux broches GPIO du Pi (et cela fonctionnerait bien!) Cependant, comme nous allons ajouter des fonctionnalités supplémentaires plus tard, nous le construirons sur une planche à pain.

1. Branchez trois de vos cavaliers mâle à femelle dans les trois broches du capteur PIR. Les trois broches sont identifiées comme suit: Rouge; PIR-VCC (3-5VDC in), marron; PIR-OUT (sortie numérique) et noir; PIR-GND (masse).

2. Branchez PIR-VCC dans le rail positif de votre planche à pain, branchez PIR-GND dans votre rail négatif et branchez PIR-OUT dans tout autre rail vierge.

3. Utilisez un cavalier noir pour connecter GPIO GND [Pin 6] sur le Pi au rail négatif de votre planche à pain. Il s’agit du même rail que celui que nous avons ajouté au fil PIR-GND.

4. Utilisez un cavalier rouge pour connecter le GPIO 5V [Pin 2] sur le Pi au rail positif de votre planche à pain. Il s’agit du même rail que celui auquel nous avons ajouté notre PIR-VCC et qui alimentera notre capteur PIR.

5. Nous utiliserons GPIO 7 [Pin 26] comme entrée pour détecter quand notre PIR détecte un mouvement. Par conséquent, la dernière étape consiste à connecter GPIO 7 [Pin 26] au même rail que notre PIR-OUT.

Détection avec Python

Maintenant que nous avons connecté notre PIR à notre Pi, nous devons programmer un script Python pour s’enregistrer lorsque le PIR détecte un mouvement!

Dans notre didacticiel sur les commutateurs, nous avons dû lier notre entrée à un niveau élevé, puis demander à notre programme Python de définir la différence entre si l’entrée était élevée ou faible. Le PIR d’autre part restera toujours bas (0V) à moins qu’un mouvement ne soit détecté, auquel cas il sortira haut (3,3V). Nous pouvons donc simplement définir notre broche GPIR PIR-OUT comme entrée, et utiliser Python pour détecter tout changement de tension.

Tout d’abord, importez la bibliothèque Python GPIO, importez notre bibliothèque de temps (nous faisons donc attendre notre Pi entre les étapes) et définissez notre numérotation des broches GPIO.

importer RPi.GPIO en tant que GPIO
temps d’importation

GPIO.setmode (GPIO.BCM)

Ensuite, nous devons donner un nom à notre broche d’entrée, afin que nous puissions y faire référence plus tard dans notre code Python. Le nommer «PIR_PIN» nous permettra de savoir si le PIR émet un signal (par exemple, un mouvement a été détecté). Vous pouvez nommer une variable d’épingle presque n’importe quoi, alors essayez de jouer pour voir avec quoi vous pouvez vous en sortir.

PIR_PIN = 7

Nous devons ensuite définir notre broche GPIO que nous venons de nommer PIR_PIN en entrée.

GPIO.setup (PIR_PIN, GPIO.IN)

L’étape suivante consiste à ajouter du texte sympa afin que nous sachions que nos programmes PIR, Pi et Python sont prêts à détecter les mouvements. Vous pouvez laisser cela de côté ou le changer en ce que vous voulez! Ce qui suit imprimera deux lignes de texte avec un écart de deux secondes entre elles.

imprimer « Test du module PIR (CTRL + C pour quitter) »
time.sleep (2)
imprimer «Prêt»

Pour vérifier l’état d’entrée de PIR_PI, nous allons utiliser une instruction True s’exécutant sur une boucle infinie.

tandis que True:
si GPIO.input (PIR_PIN):
imprimer « Motion Detected! »
time.sleep (1)

Le code vérifiera ensuite en continu l’entrée PIR_PIN et imprimera une ligne de texte si l’entrée est élevée. La limite de temps entre chaque boucle signifie que vous ne devriez avoir qu’une seule sortie lorsqu’un mouvement est détecté, car le PIR_PIN passera à l’état bas une fois le mouvement stabilisé.

C’est ça! Nous pouvons envelopper notre programme dans un court morceau de code de nettoyage pour nous assurer qu’il se termine proprement. Ce n’est pas obligatoire, mais c’est une bonne pratique.

importer RPi.GPIO en tant que GPIO
temps d’importation

GPIO.setmode (GPIO.BCM)
PIR_PIN = 7
GPIO.setup (PIR_PIN, GPIO.IN)

essayer:
imprimer « Test du module PIR (CTRL + C pour quitter) »
time.sleep (2)
imprimer «Prêt»
tandis que True:
si GPIO.input (PIR_PIN):
imprimer « Motion Detected! »
time.sleep (1)
sauf KeyboardInterrupt:
imprimer «Quitter»
GPIO.cleanup ()

Voilà, une méthode très simple pour connecter et coder un capteur de mouvement à faible coût avec le Raspberry Pi.

Si votre message continue de boucler et de boucler, la sensibilité de votre PIR pourrait être trop élevée. Nos PIR ont à bord des potentiomètres qui peuvent régler cela. Dans le sens horaire augmente la sensibilité, alors travaillez en arrière jusqu’à ce que vous obteniez la sensibilité dont vous avez besoin!

Détection pilotée par interruption

Le code ci-dessus utilise le «polling» GPIO pour détecter l’état de la broche. L’interrogation consiste en une boucle infinie, qui vérifie continuellement l’état de la broche jusqu’à ce que nous voyions le signal haut. L’interrogation utilise malheureusement beaucoup de puissance CPU, et vous verrez très probablement un certain ralentissement du système lors de l’exécution d’autres tâches.

L’ajout de la ligne «time.sleep» dans notre code signifie que notre Pi vérifie la broche moins fréquemment, ce qui devrait réduire les problèmes de performances. Le problème avec l’utilisation d’une pause dans votre code est que vous pourriez manquer un événement de broche (pendant le cycle de sommeil), donc ce n’est pas idéal, et nous bouclons toujours la fonction rapidement! Il y a une autre manière. . .

Les interruptions GPIO permettent à un programme d’attendre les événements GPIO. Au lieu de vérifier plusieurs fois une broche, le code attend le déclenchement d’une broche, en utilisant essentiellement une puissance CPU nulle. Les interruptions sont appelées «détection de bord»; un bord définissant la transition du haut vers le bas « front descendant » ou du bas vers le haut « front montant ». Un changement d’état, ou une transition entre bas et haut, est connu comme un «événement».

Les interruptions sont des fonctions d’événement unique, nous avons donc besoin d’un moyen de le boucler. De toute évidence, boucler notre code d’interruption irait à l’encontre du point de l’utiliser, par exemple nous «interrogerions» la fonction d’interruption au lieu de la broche GPIO. Nous allons donc boucler un peu de code de ressources à la place, et lier notre interruption à une fonction de « rappel ». Les rappels sont des fonctions qui ne démarrent que lorsqu’un événement se produit.

Si vous envisagez d’attendre une lettre: le scrutin est le fait que vous attendiez à la maison toute la journée, en tenant la boîte aux lettres ouverte et en scrutant en attendant l’arrivée du facteur. Une interruption dans ce scénario serait une caméra qui surveille la rue pour le facteur. Lorsqu’il espionne le facteur, il appelle votre téléphone portable (le rappel) pour vous informer que le facteur est à 10 minutes de votre porte. Cela vous libérerait, vous permettant de continuer d’autres choses et même de quitter la maison!

NOTEZ S’IL VOUS PLAÎT. RPi.GPIO version 0.5.1 (ou supérieure) est requis pour que ce code fonctionne. «Sudo apt-get update» et «sudo apt-get dist-upgrade» met à jour tout!

La première étape consiste à définir (def) notre fonction de rappel. Nous allons nommer notre rappel « MOTION » et le lier à notre PIR_PIN. Comme précédemment, nous voulons que cette fonction imprime du texte lorsque nous détectons un mouvement.

def MOTION (PIR_PIN):
imprimer « Motion Detected! »

L’ajout de la ligne suivante active les interruptions sur la broche et indique au code d’attendre qu’un événement se produise, par exemple lorsque notre PIR_PIN détecte un signal. La broche peut être configurée pour se réveiller lors du passage de bas en haut (GPIO.RISING), de haut en bas (GPIO.FALLING) ou l’un ou l’autre (GPIO.BOTH). Nous lui indiquons ensuite quel rappel utiliser!

GPIO.add_event_detect (PIR_PIN, GPIO.RISING, callback = MOTION)

Comme mentionné précédemment, nous devons ajouter une fonction de boucle simple et non intensive pour garantir que notre détection d’événements reste active. On peut donc boucler une fonction sommeil! Nous pourrions utiliser ici la fonction «while True»; cependant, en raison de la possibilité de redéfinir «True» à une valeur différente, il augmente légèrement la charge de code (pendant qu’il recherche la variable). L’utilisation d’un entier «tandis que 1» saute cette vérification de variable.

tandis que 1:
time.sleep (100)

C’est ça! Nous avons codé un programme à faibles ressources avec fonction d’interruption et de rappel intégrée qui détecte la sortie d’un détecteur de mouvement!

Code final

importer RPi.GPIO en tant que GPIO
temps d’importation

GPIO.setmode (GPIO.BCM)
PIR_PIN = 7
GPIO.setup (PIR_PIN, GPIO.IN)

def MOTION (PIR_PIN):
imprimer « Motion Detected! »

imprimer « Test du module PIR (CTRL + C pour quitter) »
time.sleep (2)
imprimer «Prêt»

essayer:
GPIO.add_event_detect (PIR_PIN, GPIO.RISING, callback = MOTION)
tandis que 1:
time.sleep (100)
sauf KeyboardInterrupt:
imprimer «Quitter»
GPIO.cleanup ()