Construisez des projets physiques avec Python sur le Raspberry Pi – Real Python

Présentation de la carte Raspberry Pi

Le Raspberry Pi est disponible dans une variété de facteurs de forme pour différents cas d'utilisation. Dans ce didacticiel, vous examinerez la version la plus récente, le Raspberry Pi 4.

Vous trouverez ci-dessous la disposition de la carte du Raspberry Pi 4. Bien que cette disposition soit légèrement différente des modèles précédents du Raspberry Pi, la plupart des connexions sont les mêmes. La configuration décrite dans la section suivante doit être la même pour un Raspberry Pi 3 et un Raspberry Pi 4:

La carte Raspberry Pi 4 contient les composants suivants:

• Broches d'entrée-sortie à usage général: Ces broches sont utilisées pour connecter le Raspberry Pi à des composants électroniques.

• Port Ethernet: Ce port connecte le Raspberry Pi à un réseau câblé. Le Raspberry Pi intègre également le WiFi et le Bluetooth pour les connexions sans fil.

• Deux ports USB 3.0 et deux ports USB 2.0: Ces ports USB sont utilisés pour connecter des périphériques comme un clavier ou une souris. Les deux ports noirs sont USB 2.0 et les deux ports bleus sont USB 3.0.

• Prise AV: Cette prise AV vous permet de connecter des haut-parleurs ou des écouteurs au Raspberry Pi.

• Port du module de caméra: Ce port est utilisé pour connecter le module de caméra Raspberry Pi officiel, qui permet au Raspberry Pi de capturer des images.

• Ports HDMI: Ces ports HDMI connectent le Raspberry Pi à des moniteurs externes. Le Raspberry Pi 4 dispose de deux ports micro HDMI, ce qui lui permet de piloter deux moniteurs distincts en même temps.

• Port d'alimentation USB: Ce port USB alimente le Raspberry Pi. Le Raspberry Pi 4 a un USB Type-C port, tandis que les anciennes versions du Pi ont un micro USB Port.

• Port d'affichage externe: Ce port est utilisé pour connecter l'écran tactile officiel Raspberry Pi de sept pouces pour une entrée tactile sur le Raspberry Pi.

• Emplacement pour carte microSD (sous la carte): Cet emplacement de carte est destiné à la carte microSD qui contient le système d'exploitation et les fichiers du Raspberry Pi.

Un peu plus loin dans ce didacticiel, vous utiliserez les composants ci-dessus pour configurer votre Raspberry Pi.

Raspberry Pi vs Arduino

Les gens se demandent souvent quelle est la différence entre un Raspberry Pi et un Arduino. L'Arduino est un autre appareil largement utilisé en informatique physique. Bien qu'il y ait un certain chevauchement dans les capacités de l'Arduino et du Raspberry Pi, il existe quelques différences distinctes.

La plate-forme Arduino fournit une interface matérielle et logicielle pour la programmation des microcontrôleurs. Un microcontrôleur est un circuit intégré qui vous permet de lire des entrées et d'envoyer des sorties vers des composants électroniques. Les cartes Arduino ont généralement une mémoire limitée, elles sont donc souvent utilisées pour exécuter à plusieurs reprises un seul programme qui interagit avec l'électronique.

Le Raspberry Pi est un ordinateur à usage général basé sur Linux. Il possède un système d'exploitation complet avec une interface graphique qui est capable d'exécuter de nombreux programmes différents en même temps.

Le Raspberry Pi est livré avec une variété de logiciels préinstallés, y compris un navigateur Web, une suite bureautique, un terminal et même Minecraft. Le Raspberry Pi dispose également de WiFi et Bluetooth intégrés pour se connecter à Internet et aux périphériques externes.

Pour exécuter Python, le Raspberry Pi est souvent le meilleur choix, car vous obtenez une installation Python à part entière sans aucune configuration.

Matériel requis

Le matériel suivant est requis pour la configuration initiale de votre Raspberry Pi. Si vous vous connectez à votre Raspberry Pi via SSH, que vous examinerez plus loin dans ce didacticiel, une partie du matériel ci-dessous ne sera pas nécessaire après la configuration initiale.

Matériel en option

Vous pouvez utiliser toute une gamme de matériel supplémentaire avec le Raspberry Pi pour étendre ses capacités. Les éléments matériels répertoriés ci-dessous ne sont pas nécessaires pour utiliser votre Raspberry Pi mais seraient utiles à avoir sous la main.

Logiciel

Le système d'exploitation du Raspberry Pi est stocké sur une carte microSD. Si votre carte ne provient pas d'un kit Raspberry Pi officiel, vous devrez alors y installer le système d'exploitation.

Il existe plusieurs façons de configurer le système d'exploitation sur votre Raspberry Pi. Vous pouvez en savoir plus sur les différentes options d'installation sur le site Web de Raspberry Pi.

Dans cette section, vous examinerez deux façons d'installer Raspbian, le système d'exploitation Raspberry Pi officiellement pris en charge, basé sur Debian Linux.

Configuration finale

Maintenant que vous avez la carte microSD et le matériel requis prêts, la dernière étape consiste à tout connecter ensemble et à configurer le système d'exploitation. Commençons par connecter tous les périphériques:

1. Insérez la carte microSD dans la fente pour carte au bas du Raspberry Pi.
2. Connectez le clavier et la souris à l'un des quatre ports USB.
3. Connectez un écran à l'un des ports HDMI à l'aide d'un câble HDMI spécifique à votre modèle Raspberry Pi.
4. Connectez une alimentation au port d'alimentation USB.

Avec les périphériques connectés, allez-y et allumez votre Raspberry Pi pour configurer le système d'exploitation. Si vous avez installé Raspbian avec l'imageur Raspberry Pi, vous n'avez rien d'autre à faire. Vous pouvez passer à la section suivante pour terminer la configuration.

Si vous avez installé NOOBS sur votre carte SD, vous devrez effectuer quelques étapes supplémentaires pour installer Raspbian sur la carte SD:

1. Tout d'abord, allumez le Raspberry Pi pour charger le NOOBS interface.
2. Cochez ensuite la case à côté de Raspbian dans la liste des logiciels à installer.
3. Enfin, cliquez sur le Installer dans le coin supérieur gauche de l'interface pour commencer l'installation de Raspbian sur la carte SD.

Une fois l'installation terminée, le Raspberry Pi redémarrera et vous serez démarré dans Raspbian pour terminer l'assistant de configuration.

Utilisation de l'éditeur Mu

Le système d'exploitation Raspbian est livré avec plusieurs IDE Python préinstallés que vous pouvez utiliser pour écrire vos programmes. L'un de ces IDE est Mu. Il se trouve dans le menu principal:

Icône Raspberry Pi → Programmation → Mu

Lorsque vous ouvrez Mu pour la première fois, vous aurez la possibilité de sélectionner le mode Python pour l'éditeur. Pour le code de ce didacticiel, vous pouvez sélectionner Python 3:

Il est possible que Mu ne soit pas préinstallé sur votre version de Raspbian. Si Mu n'est pas installé, vous pouvez toujours l'installer en vous rendant à l'emplacement du fichier suivant:

Icône Raspberry Pi → Préférences → Logiciel recommandé

Cela ouvrira une boîte de dialogue contenant les logiciels recommandés pour votre Raspberry Pi. Cochez la case à côté de Mu et cliquez sur D'accord pour l'installer:

Bien que Mu fournisse un excellent éditeur pour démarrer avec Python sur le Raspberry Pi, vous voudrez peut-être quelque chose de plus robuste. Dans la section suivante, vous vous connecterez à votre Raspberry Pi via SSH.

Modification à distance via SSH

Souvent, vous ne voudrez pas passer du temps à brancher un moniteur, un clavier et une souris pour écrire Python sur le Raspberry Pi. Heureusement, Raspbian vous permet de vous connecter à distance au Raspberry Pi via SSH. Dans cette section, vous apprendrez comment activer et utiliser SSH pour programmer Python sur le Raspberry Pi.

pi @ raspberrypi: ~ $ hostname -I

pi @ raspberrypi: ~ $ python3

>>> impression("Bonjour de votre Raspberry Pi!")
Bonjour de votre Raspberry Pi!

Créer un projets python Annuaire

Avant de commencer à créer des projets avec Python sur le Raspberry Pi, c'est une bonne idée de configurer un répertoire dédié pour votre code. Le Raspberry Pi possède un système de fichiers complet avec de nombreux répertoires différents. Avoir une place réservée pour votre code Python aidera à garder tout organisé et facile à trouver.

Créons un répertoire appelé projets python où vous pouvez stocker du code Python pour vos projets.

pi @ framboise: ~ $ pwd
/ accueil / pi

pi @ raspberry: ~ / Desktop $ CD / accueil / pi
pi @ framboise: ~ $ pwd
/ accueil / pi

pi @ framboise: ~ $ mkdir python-projects

pi @ framboise: ~ $ CD projets python
pi @ raspberry: ~ / python-projects $

Composants electroniques

Avant de programmer sur le Raspberry Pi, vous aurez besoin de quelques composants électroniques pour construire les projets dans les sections à venir. Vous devriez pouvoir trouver chacun des articles ci-dessous sur Amazon ou dans votre magasin d'électronique local.

Broches GPIO

Le Raspberry Pi dispose de quarante broches GPIO le long du bord supérieur de la carte. Vous pouvez utiliser ces broches GPIO pour connecter le Raspberry Pi à des composants externes.

La disposition des broches ci-dessous montre les différents types de broches et leurs emplacements. Cette disposition est basée sur une vue aérienne des broches avec les ports USB du Raspberry Pi face à vous:

Le Raspberry Pi propose cinq types de broches différents:

1. GPIO: Ce sont des broches à usage général qui peuvent être utilisées pour l'entrée ou la sortie.
2. 3V3: Ces broches fournissent une source d'alimentation de 3,3 V pour les composants. 3,3 V est également la tension interne fournie par toutes les broches GPIO.
3. 5V: Ces broches fournissent une source d'alimentation de 5 V, la même que l'entrée d'alimentation USB qui alimente le Raspberry Pi. Certains composants, tels que le capteur de mouvement infrarouge passif, nécessitent 5 V.
4. GND: Ces broches fournissent une connexion à la terre pour les circuits.
5. ADV: Ces broches spéciales sont avancées et ne sont pas traitées dans ce didacticiel.

Dans la section suivante, vous utiliserez ces différents types de broches pour configurer votre premier composant, un bouton tactile.

Bouton tactile

Pour votre premier circuit, vous allez connecter un bouton tactile au Raspberry Pi. Un bouton tactile est un interrupteur électronique qui, lorsqu'il est enfoncé, ferme un circuit. Lorsqu'un circuit est fermé, le Raspberry Pi enregistre un SUR signal. Vous pouvez utiliser ce signal ON pour déclencher différentes actions.

Dans ce projet, vous utiliserez un bouton tactile pour exécuter différentes fonctions Python en fonction de l'état du bouton. Commençons par câbler le bouton au Raspberry Pi:

1. Connectez un de femme à homme fil de connexion du Raspberry Pi GND épingler au rail négatif de la planche à pain.
2. Placez un bouton tactile sur la gouttière au milieu de la planche à pain.
3. Connectez un homme à homme fil de pontage rail négatif de la planche à pain à la ligne où le bouton jambe en bas à gauche est placé.
4. Connectez un de femme à homme fil de connexion du Raspberry Pi GPIO4 épingler à la ligne de la planche à pain où le bouton jambe en bas à droite est placé.

Vous pouvez confirmer votre câblage avec le schéma ci-dessous:

Maintenant que votre circuit est branché, écrivons le code Python pour lire l'entrée à partir du bouton.

À l'intérieur de projets python répertoire que vous avez créé précédemment, enregistrez un nouveau fichier appelé button.py. Si vous utilisez SSH pour accéder à votre Raspberry Pi, créez le fichier comme ceci:

pi @ raspberrypi: ~ / cd projets python
pi @ raspberrypi: ~ / python-projects $ touchez button.py

Si vous utilisez Mu, créez le fichier en procédant comme suit:

1. Clique le Nouveau élément du menu.
2. Cliquez sur sauver.
3. Accédez au / accueil / pi / projets-python annuaire.
4. Enregistrez le fichier sous button.py.

Une fois le fichier créé, vous êtes prêt à commencer le codage. Commencez par importer le Bouton classe du gpiozero module. Vous devrez également importer pause du signal module. Vous allez voir pourquoi vous avez besoin pause plus tard:

de gpiozero importation Bouton
de signal importation pause

Créez une instance de la Bouton classe et passez le numéro de broche comme paramètre. Dans ce cas, vous utilisez le GPIO4 épingler, donc vous passerez 4 comme paramètre:

Ensuite, définissez les fonctions qui seront appelées pour les différents événements de bouton disponibles sur un Bouton exemple:

def button_pressed():
    impression("Le bouton a été enfoncé")

def button_held():
    impression("Le bouton était maintenu")

def button_released():
    impression("Le bouton est sorti")

le Bouton La classe a trois propriétés d'événement: .when_pressed, .when_held, et .when_released. Ces propriétés peuvent être utilisées pour connecter différentes fonctions d'événement.

Tandis que le .when_pressed et .when_released les propriétés sont explicites, .when_held nécessite une brève explication. Si une fonction est définie sur .when_held , elle ne sera appelée que si le bouton est maintenu enfoncé pendant un certain temps.

Le temps d'attente pour .when_held est déterminé par le .hold_time propriété sur le Bouton exemple. La valeur par défaut pour .hold_time est une seconde. Vous pouvez remplacer cela en passant un flotte valeur lors de la création d'un Bouton exemple:

bouton = Bouton(4, hold_time=2,5)
bouton.when_held = button_held

Cela créera un Bouton exemple qui attendra deux secondes et demie après avoir appuyé et maintenu le bouton avant d'appeler le button_held () une fonction.

Maintenant que vous connaissez les différentes propriétés d'événement sur Bouton, définissez chacun d'eux sur leurs fonctions respectives que vous avez définies précédemment:

bouton.quand_appuyé = button_pressed
bouton.when_held = button_held
bouton.when_released = button_released

Génial! Vous avez configuré les événements de votre bouton. La dernière chose que vous devez faire est d'appeler pause() à la fin du fichier. Appel pause() est nécessaire pour que le programme reste à l'écoute des différents événements. Si ce n'était pas le cas, le programme s'exécuterait une fois et se fermerait.

Votre programme final devrait ressembler à ceci:

de gpiozero importation Bouton
de signal importation pause

bouton = Bouton(4)

def button_pressed():
    impression("Le bouton a été enfoncé")

def button_held():
    impression("Le bouton était maintenu")

def button_released():
    impression("Le bouton est sorti")

bouton.quand_appuyé = button_pressed
bouton.when_held = button_held
bouton.when_released = button_released

pause()

Une fois le câblage terminé et le code configuré, vous êtes prêt à essayer votre premier circuit. À l'intérieur du projets python répertoire, exécutez le programme:

pi @ raspberrypi: ~ / python-projects $ python3 button.py

Si vous utilisez Mu, assurez-vous d'abord que le fichier est enregistré, puis cliquez sur Courir pour démarrer le programme.

Le programme est maintenant en cours d'exécution et écoute les événements. Appuyez sur le bouton et vous devriez voir ce qui suit dans la console:

Appuyez et maintenez le bouton pendant au moins une seconde, et vous devriez voir la sortie suivante:

Enfin, lorsque vous relâchez le bouton, vous devriez voir ce qui suit:

Impressionnant! Vous venez de câbler et de coder votre premier circuit en utilisant Python sur le Raspberry Pi.

Depuis que vous avez utilisé pause() dans votre code, vous devrez arrêter manuellement le programme. Si vous exécutez le programme dans Mu, vous pouvez cliquer sur Arrêtez pour quitter le programme. Si vous l'exécutez à partir de la ligne de commande, vous pouvez arrêter le programme avec Ctrl+C.

Avec ce premier circuit sous votre ceinture, vous êtes prêt à commencer à contrôler certains autres composants.

LED

Pour votre prochain circuit, vous utiliserez Python pour allumer et éteindre une LED chaque seconde. LED signifie diode électroluminescente, et ces composants produisent de la lumière lorsqu'un courant est appliqué. Vous constaterez qu’ils sont utilisés partout dans l’électronique.

Chaque LED a deux pattes. La jambe la plus longue est la jambe positive, ou anode. Le courant électrique pénètre dans la LED à travers cette jambe. La jambe la plus courte est la jambe négative, ou cathode). Le courant sort de la LED à travers cette jambe.

Le courant ne peut circuler que dans une direction à travers une LED, alors assurez-vous que vous connectez les cavaliers à la jambe appropriée de la LED.

Voici les étapes à suivre pour câbler ce circuit:

1. Connectez un de femme à homme fil de connexion du Raspberry Pi GND épingler au rail négatif de la planche à pain.

2. Placer un LED dans deux trous sur la planche à pain qui sont côte à côte mais pas dans la même rangée.

3. Placer le jambe plus longue et positive de la LED dans le trou sur le côté droit.

4. Placer le jambe plus courte et négative de la LED dans le trou sur le côté gauche.

5. Placer une extrémité d'un Résistance 330 Ω dans un trou dans la même rangée de planche à pain que le jambe négative de la LED.

6. Placez l'autre extrémité de la résistance dans le rail négatif de la planche à pain

7. Connectez un de femme à homme fil de connexion du Raspberry Pi GPIO4 épingler à un trou dans la même rangée de planche à pain que le jambe positive de la LED.

Vous pouvez confirmer votre câblage avec le schéma ci-dessous:

Si le câblage semble bon, alors vous êtes prêt à écrire du Python pour faire clignoter la LED. Commencez par créer un fichier pour ce circuit à l'intérieur du projets python annuaire. Appeler ce fichier led.py:

pi @ raspberrypi: ~ / python-projects $ toucher led.py

Dans ce code, vous allez créer une instance de la LED classe et appeler son .cligner() pour allumer et éteindre la LED. le .cligner() La méthode a un délai d'expiration par défaut d'une seconde. La LED continue de clignoter chaque seconde jusqu'à ce que le programme soit quitté.

Commencez par importer LED du gpiozero module et pause du signal module:

de gpiozero importation LED
de signal importation pause

Ensuite, créez une instance de LED appelé LED. Définissez la broche GPIO sur 4:

Appeler le .cligner() méthode sur LED:

Enfin, ajoutez un appel à pause() pour vous assurer que le programme ne se ferme pas:

Votre programme complet devrait ressembler à ceci:

de gpiozero importation Avertisseur sonore
de signal importation pause

LED = LED(4)
LED.cligner()

pause()

Enregistrez le fichier et exécutez-le pour voir le voyant clignoter:

pi @ raspberrypi: ~ / python-projects $ python3 led.py

La LED devrait maintenant clignoter toutes les secondes. Lorsque vous avez fini d'admirer votre code Python en action, arrêtez le programme avec Ctrl+C ou Arrêtez à Mu.

Vous savez maintenant comment contrôler une LED avec Python sur le Raspberry Pi. Pour le prochain circuit, vous utiliserez Python pour produire du son à partir du Raspberry Pi.

Avertisseur sonore

Dans ce circuit, vous allez câbler un ronfleur piézo actif au Raspberry Pi. Un buzzer piézo émet une tonalité lorsque le courant est appliqué. En utilisant ce composant, votre Raspberry Pi pourra générer du son.

Like LEDs, a buzzer has a positive and negative leg. The positive leg of the buzzer will either be longer than the negative leg or there will be a positive sign (+) on the top of the buzzer showing which leg is the positive leg.

Let’s go ahead and wire up the buzzer:

1. Place a buzzer on the breadboard, noting the placement of the buzzer’s positive leg.

2. Connect a female-to-male jumper wire from the Raspberry Pi’s GND pin to a hole in the same breadboard row as the negative leg of the buzzer.

3. Connect a female-to-male jumper wire from the Raspberry Pi’s GPIO4 pin to a hole in the same breadboard row as the positive leg of the buzzer.

Confirm your wiring against the diagram below:

With the wiring set up, let’s move on to the code. Create a file for this circuit inside the python-projects annuaire. Call this file buzzer.py:

pi@raspberrypi:~/python-projects $ touch buzzer.py

In this code, you’ll create an instance of the Buzzer class and call it’s .beep() method to make the buzzer beep on and off. le .beep() method’s first two parameters are on_time et off_time. These parameters take a float value to set how long the buzzer should beep on and off. The default value for both is one second.

Start by importing Buzzer du gpiozero module and pause du signal module:

de gpiozero importation Buzzer
de signal importation pause

Next, create an instance of Buzzer called buzzer. Set the GPIO pin to 4:

Call the .beep() method on buzzer. Set the on_time et off_time parameters to 0.5. This will make the buzzer beep every half second:

Finally, add a call to pause() to make sure the program doesn’t exit:

Your complete program should look like this:

de gpiozero importation LED
de signal importation pause

buzzer = Buzzer(4)
buzzer.beep(0.5, 0.5)

pause()

Save the file and run it to hear the buzzer beep on and off every half second:

pi@raspberrypi:~/python-projects $ python3 buzzer.py

You should hear the buzzer sound on and off until you stop the program with Ctrl+C ou Stop in Mu.

Great! So far you’ve learned how to control three different types of electronic components with Python on the Raspberry Pi. For the next circuit, let’s take a look at a slightly more complex component.

Motion Sensor

In this circuit, you’ll be connecting a passive infrared (PIR) motion sensor to the Raspberry Pi. A passive infrared motion sensor detects any motion in its field of vision and sends a signal back to the Raspberry Pi.

pi@raspberrypi:~/python-projects $ touch pir.py

de gpiozero importation MotionSensor
de signal importation pause

motion_sensor = MotionSensor(4)

def motion():
    impression("Motion detected")

def no_motion():
    impression("Motion stopped")

impression("Readying sensor...")
motion_sensor.wait_for_no_motion()
impression("Sensor ready")

motion_sensor.when_motion = motion
motion_sensor.when_no_motion = no_motion

pause()

pir = MotionSensor(4, threshold=0.2)

pi@raspberrypi:~/python-projects $ python3 pir.py
Readying sensor...
Sensor ready

Wiring

Here are the steps to complete the wiring:

1. Relier female-to-male jumper wires from the Raspberry Pi’s 5V et GND pins to the positive et negative rails on the side of the breadboard.

2. Place an LED on the breadboard and connect the Raspberry Pi’s GPIO14 pin to the LED with a female-to-male jumper wire.

3. Connectez le LED’s negative leg to the breadboard’s negative rail through a 330 Ω resistor.

4. Place a buzzer on the breadboard and connect the Raspberry Pi’s GPIO15 pin to the buzzer with a female-to-male jumper wire.

5. Connectez le buzzer’s negative leg to the breadboard’s negative rail avec un male-to-male jumper wire.

6. Connect a female-to-male jumper wire from the breadboard’s positive rail to the sensor’s VCC pin.

7. Connect a female-to-female jumper wire from the Raspberry Pi’s GPIO4 pin to the sensor’s EN DEHORS pin.

8. Connect a female-to-male jumper wire from the breadboard’s negative rail to the sensor’s GND pin.

Confirm the wiring against the diagram below:

Okay, now that you have the circuit wired up, let’s dig into the Python code to set up your motion-activated alarm system.

Code

As usual, start by creating a file for this project inside the python-projects annuaire. For this project, call this file motion_detector.py:

pi@raspberrypi:~/python-projects $ touch motion_detector.py

The first thing you want to do is import the csv module so you can save a timestamp when motion is detected. Also, import Chemin du pathlib module so you can reference your CSV file:

importation csv
de pathlib importation Chemin

Next, import datetime du datetime module so you can create a timestamp of the motion event:

de datetime importation datetime

Finally, import the required component classes from gpiozero as well as pause du signal module:

de gpiozero importation LED, Buzzer, MotionSensor
de signal importation pause

With the imports ready, you can set up the three electronic components you’ll be using. Create instances of the LED, Buzzer, et MotionSensor classes. For each of these, pass in their pin numbers as parameters:

led = LED(14)
buzzer = Buzzer(15)
motion_sensor = MotionSensor(4)

Next, define the location of a CSV file that will store a timestamp each time motion is detected. You’ll call it detected_motion.csv. Create a dictionary to hold the timestamp values that will be written to the CSV:

output_csv_path = Chemin("detected_motion.csv")
motion = 
    "start_time": Aucun,
    "end_time": Aucun,

Create a method that saves the timestamp data to a CSV file. When the file is first created, a header row is added:

def write_to_csv():
    first_write = ne pas output_csv_path.is_file()

    avec ouvert(output_csv_path, "a") comme file:
        field_names = motion.clés()
        writer = csv.DictWriter(file, field_names)
        si first_write:
            writer.writeheader()
        writer.writerow(motion)

Define a start_motion() une fonction. This function will have several behaviors:

• Start blinking the led on and off every half second
• Make the buzzer beep
• Save the start_time timestamp to the motion dictionary

Add a call to print() so you can watch the events occur while the program is running:

def start_motion():
    led.blink(0.5, 0.5)
    buzzer.beep(0.5, 0.5)
    motion[[[["start_time"] = datetime.now()
    impression("motion detected")

Then define an end_motion() function that will have the following behaviors:

• Turn off the led et buzzer
• Save the end_time horodatage
• Appel write_to_csv() to save the motion data to the CSV file
• Reset the motion dictionary

You’ll also check that a motion["start_time"] value exists before running any of the other code. You only want to write to the CSV if a start_time timestamp was recorded:

def end_motion():
    si motion[[[["start_time"]:
        led.de()
        buzzer.de()
        motion[[[["end_time"] = datetime.now()
        write_to_csv()
        motion[[[["start_time"] = Aucun
        motion[[[["end_time"] = Aucun
    impression("motion ended")

Add a call to .wait_for_no_motion() so that any initial motion is ignored:

impression("Readying sensor...")
motion_sensor.wait_for_no_motion()
impression("Sensor ready")

Set the .when_motion et .when_no_motion properties on the MotionSensor exemple:

motion_sensor.when_motion = start_motion
motion_sensor.when_no_motion = end_motion

Finally, end the code with a call to pause() to keep the program running. The full Python code should look like this:

importation csv
de pathlib importation Chemin
de datetime importation datetime
de gpiozero importation LED, Buzzer, MotionSensor
de signal importation pause

led = LED(14)
buzzer = Buzzer(15)
motion_sensor = MotionSensor(4)

output_csv_path = Chemin("detected_motion.csv")
motion = 
    "start_time": Aucun,
    "end_time": Aucun,


def write_to_csv():
    first_write = ne pas output_csv_path.is_file()

    avec ouvert(output_csv_path, "a") comme file:
        field_names = motion.clés()
        writer = csv.DictWriter(file, field_names)
        si first_write:
            writer.writeheader()
        writer.writerow(motion)

def start_motion():
    led.blink(0.5, 0.5)
    buzzer.beep(0.5, 0.5)
    motion[[[["start_time"] = datetime.now()
    impression("motion detected")

def end_motion():
    si motion[[[["start_time"]:
        led.de()
        buzzer.de()
        motion[[[["end_time"] = datetime.now()
        write_to_csv()
        motion[[[["start_time"] = Aucun
        motion[[[["end_time"] = Aucun
    impression("motion ended")

impression("Readying sensor...")
motion_sensor.wait_for_no_motion()
impression("Sensor ready")

motion_sensor.when_motion = start_motion
motion_sensor.when_no_motion = end_motion

pause()

Save the file and run it to test out your new motion detector alarm:

pi@raspberrypi:~/python-projects $ python3 motion_detector.py
Readying sensor...
Sensor ready

Now if you wave your hand in front of the motion detector, then the buzzer should start beeping and the LED should flash. If you stop moving for a few seconds, then the alarm should stop. In the console you should see the following:

pi@raspberrypi:~/python-projects $ python3 motion_detector.py
Readying sensor...
Sensor ready
motion detected
motion ended
motion detected
motion ended
...

Go ahead and stop the program with Stop in Mu or Ctrl+C. Let’s check out the CSV file that was generated:

pi@raspberrypi:~/python-projects $ cat detected_motion.csv
start_time,end_time
2020-04-21 10:53:07.052609,2020-04-21 10:53:13.966061
2020-04-21 10:56:56.477952,2020-04-21 10:57:03.490855
2020-04-21 10:57:04.693970,2020-04-21 10:57:12.007095

As you can see, the timestamps for the motion’s start_time et end_time have been added to the CSV file.

Toutes nos félicitations! You’ve created a non-trivial electronics project with Python on the Raspberry Pi.

Next Steps

You don’t have to stop here. There are many ways you could improve this project by leveraging the capabilities of Python on the Raspberry Pi.

Here are some ways to level up this project:

• Connect the Raspberry Pi Camera Module and have it take a photo whenever motion is detected.

• Connect a speaker to the Raspberry Pi and use PyGame to play a sound file to intimidate an intruder.

• Add a button to the circuit to allow a user to manually toggle motion detection on or off.

There are many ways to upgrade this project. Let us know what you come up with!