Lorsque Déplacement du système d’exploitation Raspberry Pi d’être basé sur Debian Buster, à œil de boeuf, la transition n’a pas été des plus fluides. Pendant de nombreuses années, Raspberry Pi OS a utilisé trois outils pour accéder à la caméra officielle Raspberry Pi. Les deux premiers étaient raspistill / raspivid, qui offraient le contrôle et l’accès à la caméra via le terminal Linux.
C’était un moyen puissant et flexible de travailler avec l’appareil photo, les deux pouvaient produire des effets vidéo et diffuser de la vidéo sans travail supplémentaire. L’autre moyen était un projet créé par la communauté appelé PiCamera. Créé à l’origine par Dave Jones, Picamera est passé d’un projet communautaire à un outil essentiel. Picamera offrait un moyen purement Python d’interagir avec la caméra, et étant basé sur Python, cela signifiait également que nous pouvions mélanger la caméra dans nos projets.
Avec le passage à Bullseye, nous avons vu Picamera se casser tristement. Raspberry Pi LTD est même allé jusqu’à offrir un version « héritée » de Buster avec Picamera et les mises à jour de sécurité. Il s’agissait d’une mesure provisoire pendant que ses développeurs travaillaient sur Picamera2. Avec le Version de septembre 2022 de Raspberry Pi OS nous avons maintenant un module Picamera2 fonctionnel que nous pouvons utiliser dans nos projets.
Dans ce tutoriel, nous allons apprendre à utiliser L’API plutôt splendide de Picamera2 [pdf] pour capturer des images, enregistrer des vidéos et travailler avec le GPIO pour réagir à l’entrée comme moyen de capturer une image.
Pour les projets dont vous aurez besoin
Connexion de votre caméra Raspberry Pi
La caméra Raspberry Pi a fait partie de la meilleurs accessoires Raspberry Pi depuis presque aussi longtemps que le Pi est avec nous. Presque tous les modèles de Raspberry Pi ont un connecteur de caméra (CSI) (à l’exception du premier modèle de Raspberry Pi Zero), ce qui signifie que la caméra est rapidement devenue l’accessoire indispensable pour votre Pi. Il en est toujours de même, grâce au caméra officielle du QG offrant une bien meilleure qualité d’image et une série d’objectifs interchangeables.
Connecter n’importe quel appareil photo officiel au Raspberry Pi est facile à faire, suivez simplement ces étapes.
3. Insérez le câble avec la languette bleue face au port USB/Ethernet.
4. Faites glisser doucement les onglets vers le bas pour verrouiller le câble en place.
5. Sécuriser/monter la caméra afin qu’il ne bascule pas et ne touche pas le Pi ou son GPIO. Une méthode consiste à utiliser de la pâte à modeler / blu tack.
Installation du logiciel Picamera2
1. Démarrez le Pi.
2. Ouvrir une borne et mettre à jour le logiciel installé.
sudo apt update
sudo apt upgrade -y3. Installez le module Picamera2 Python3. Pour les dernières versions de Raspberry Pi OS (à partir de septembre 2022), il est préinstallé, mais cette commande mettra également à jour votre version vers la dernière version.
sudo apt install -y python3-picamera2Prendre une photo avec Picamera2
Prendre une photo avec Picamera2 est la tâche la plus élémentaire que vous puissiez effectuer avec le module. De par sa conception, il a été créé pour être simple à utiliser, mais sous la simplicité se cache un module complexe que nous pouvons modifier en fonction de nos besoins.
Dans ce projet, nous allons capturer une image, en utilisant un aperçu pour cadrer la prise de vue.
1. Ouvrez Thonny. Vous pouvez le trouver dans le menu principal.
2. Dans un nouveau fichier, importez le module Picamera2, ainsi que la classe de prévisualisation. Sur une nouvelle ligne, importez le module de temps. Le module Picamera2 nous fournira le contrôle de la caméra et le temps est utilisé pour contrôler combien de temps l’image de prévisualisation restera à l’écran.
from picamera2 import Picamera2, Preview
import time3. Créez un objet, picam2, qui sert à référencer le module Picamera2 et à contrôler la caméra.
picam2 = Picamera2()4. Créez un nouvel objet, camera_config et utilisez-le pour régler la résolution de l’image fixe (principale) sur 1920 x 1080. et une image « basse résolution » d’une taille de 640 x 480. Cette image basse résolution est utilisée comme image d’aperçu lors du cadrage d’une prise de vue.
camera_config = picam2.create_still_configuration(main="size": (1920, 1080), lores="size": (640, 480), display="lores")5. Chargez la configuration.
picam2.configure(camera_config)6. Démarrer la fenêtre d’aperçu et puis démarrez la caméra.
picam2.start_preview(Preview.QTGL)
picam2.start()sept. Mettez le code en pause pendant deux secondes.
time.sleep(2)8. Capturer une image et enregistrez-le sous test.jpg.
picam2.capture_file("test.jpg")9. Enregistrez le code sous camera-test.py et cliquez sur Exécuter pour démarrer. Une fenêtre de prévisualisation apparaîtra, utilisez-la pour cadrer votre photo. Si un délai de deux secondes est trop court, modifiez le délai en fonction de vos besoins.
dix. Ouvrez le gestionnaire de fichiers du système et double-cliquez sur test.jpg pour afficher l’image.
Liste complète des codes
from picamera2 import Picamera2, Preview
import time
picam2 = Picamera2()
camera_config = picam2.create_still_configuration(main="size": (1920, 1080), lores="size": (640, 480), display="lores")
picam2.configure(camera_config)
picam2.start_preview(Preview.QTGL)
picam2.start()
time.sleep(2)
picam2.capture_file("test.jpg")Enregistrer une vidéo avec Picamera2
L’enregistrement vidéo HD est quelque chose que nous tenons maintenant pour acquis. Il en va de même pour le Raspberry Pi grâce à de nombreux modèles de caméras officielles (et non officielles). Avec Picamera2, nous pouvons enregistrer des vidéos à différentes résolutions en utilisant différents encodeurs.
Dans ce projet, nous montrerons comment enregistrer un simple flux vidéo 1080P, tout en prévisualisant le flux dans une fenêtre de résolution inférieure.
1. Ouvrir Thonny et créer un nouveau fichier. Vous pouvez trouver Thonny dans le menu principal.
2. Importez l’encodeur H264 depuis le module Picamera2.
from picamera2.encoders import H264Encoder3. Importez le module Picamera2, ainsi que la classe de prévisualisation. Ensuite, importez le module de temps.
from picamera2 import Picamera2, Preview
import time4. Créez un objet, picam2, qui sert à référencer le module Picamera2 et à contrôler la caméra.
picam2 = Picamera2()5. Créez un nouvel objet, video_config et utilisez-le pour régler la résolution de l’image fixe (principale) sur 1920 x 1080. et une image « basse résolution » d’une taille de 640 x 480. Cette image basse résolution est utilisée comme image d’aperçu lors du cadrage d’une prise de vue.
video_config = picam2.create_video_configuration(main="size": (1920, 1080), lores="size": (640, 480), display="lores")6. Chargez la configuration.
picam2.configure(video_config)sept. Définissez le débit binaire de l’encodeur H264.
encoder = H264Encoder(bitrate=10000000)8. Définissez le fichier de sortie sur test.h264. Cela créera un fichier contenant la vidéo.
output = "test.h264"9. Démarrez la fenêtre de prévisualisation, puis démarrez l’enregistrement à l’aide des paramètres de l’encodeur et enregistrez la vidéo dans le fichier de sortie.
picam2.start_preview(Preview.QTGL)
picam2.start_recording(encoder, output)dix. Utilisez une mise en veille pour enregistrer dix secondes de vidéo. La commande d’enregistrement précédente n’est pas une ligne de code bloquante. En utilisant une commande de sommeil, nous empêchons l’enregistrement de s’arrêter après une fraction de seconde.
time.sleep(10)11. Arrêtez l’enregistrement de la caméra et fermez la fenêtre d’aperçu.
picam2.stop_recording()
picam2.stop_preview()12. Enregistrez le code sous video-test.py et cliquez sur Exécuter pour démarrer. La fenêtre de prévisualisation apparaîtra et vous aurez dix secondes pour enregistrer une vidéo.
13. Voir la vidéo.Vous pouvez y accéder dans le gestionnaire de fichiers en localisant test.h264. Et double-cliquez sur le fichier vidéo pour le lire dans VLC.
Liste complète des codes
from picamera2.encoders import H264Encoder
from picamera2 import Picamera2, Preview
import time
picam2 = Picamera2()
video_config = picam2.create_video_configuration(main="size": (1920, 1080), lores="size": (640, 480), display="lores")
picam2.configure(video_config)
encoder = H264Encoder(bitrate=10000000)
output = "test.h264"
picam2.start_preview(Preview.QTGL)
picam2.start_recording(encoder, output)
time.sleep(10)
picam2.stop_recording()
picam2.stop_preview()Utiliser un déclencheur pour prendre une photo sur Raspberry Pi
Les déclencheurs de caméra sont un projet Raspberry Pi classique. Ils sont utilisés pour capturer des images/vidéos d’animaux, d’intrus ou pour faire des blagues aux membres de la famille qui ne le veulent pas. Un déclencheur peut être un capteur tel qu’un capteur de mouvement à infrarouge passif (PIR), un capteur à ultrasons ou, dans notre cas, un simple bouton poussoir.
Dans ce projet, nous allons créer un simple piège à caméra activé par un déclencheur. Nous appuyons sur le bouton, cadrons la prise de vue à l’aide de la fenêtre d’aperçu, puis le fichier est automatiquement enregistré sur notre Pi en utilisant l’heure et la date actuelles comme nom de fichier.
Le câblage de ce projet est simple. Le bouton est connecté à GPIO17 et GND via une planche à pain et deux fils femelle à mâle.
1. Ouvrir Thonny et créer un nouveau fichier. Vous pouvez trouver Thonny dans le menu principal.
2. Importez le module Picamera2, ainsi que la classe de prévisualisation. Prochain importer le module de temps.
from picamera2 import Picamera2, Preview
import time3. Importez les modules datetime, GPIO Zero et Signal. Datetime est utilisé pour générer un horodatage pour nos noms de fichiers image. GPIO Zero est utilisé pour une interface de bouton simple. Le signal est utilisé pour empêcher le code Python de sortir.
from datetime import datetime
from gpiozero import Button
from signal import pause4. Créez un objet, picam2, qui sert à référencer le module Picamera2 et à contrôler la caméra.
picam2 = Picamera2()5. Créer un objet, un bouton, et utilisez l’objet pour stocker la broche GPIO à laquelle notre bouton est connecté.
button = Button(17)6. Créez un nouvel objet, camera_config et utilisez-le pour régler la résolution de l’image fixe (principale) sur 1920 x 1080. et une image « basse résolution » d’une taille de 640 x 480. Cette image basse résolution est utilisée comme image d’aperçu lors du cadrage d’une prise de vue.
camera_config = picam2.create_still_configuration(main="size": (1920, 1080), lores="size": (640, 480), display="lores")sept. Chargez la configuration.
picam2.configure(camera_config)8. Créer une fonction, capture(), pour stocker une série de commandes qui sera exécuté lorsque la gâchette sera enfoncée. Le code à l’intérieur de la fonction est automatiquement indenté pour montrer qu’il appartient à la fonction.
def capture():9. Démarrer une fenêtre d’aperçu. Cela nous permettra d’encadrer notre image.
picam2.start_preview(Preview.QTGL)dix. Créer un objet, un horodatage, et utilisez-le pour stocker l’heure et la date de l’événement déclencheur.
timestamp = datetime.now().isoformat()11. Démarrez l’appareil photo, puis faites une pause de deux secondes pour laisser le temps de cadrer l’image.
picam2.start()
time.sleep(2)12. Définissez le fichier de capture, en fin de compte le fichier image, pour utiliser l’horodatage actuel comme nom de fichier.
picam2.capture_file('/home/pi/%s.jpg' % timestamp)13. Enfin dans la fonction arrêter l’aperçu, et arrêter la caméra.
picam2.stop_preview()
picam2.stop()14. Utilisez la classe de boutons de GPIO Zero pour réagir à une pression sur un bouton en appelant notre fonction « capture ». Pour terminer utilisez pause() pour empêcher le code de se terminer.
button.when_pressed = capture
pause()15. Enregistrez le code sous trigger-test.py et cliquez sur Exécuter pour démarrer le code.
16. appuie sur le bouton pour démarrer l’appareil photo et prendre une image.
17. Ouvrez le gestionnaire de fichiers du système et double-cliquez sur l’image pour voir.
Liste complète des codes
from picamera2 import Picamera2, Preview
import time
from datetime import datetime
from gpiozero import Button
from signal import pause
picam2 = Picamera2()
button = Button(17)
camera_config = picam2.create_still_configuration(main="size": (1920, 1080), lores="size": (640, 480), display="lores")
picam2.configure(camera_config)
def capture():
picam2.start_preview(Preview.QTGL)
timestamp = datetime.now().isoformat()
picam2.start()
time.sleep(2)
picam2.capture_file('/home/pi/%s.jpg' % timestamp)
picam2.stop_preview()
picam2.stop()
button.when_pressed = capture
pause()