Caméra de sécurité Raspberry Pi : 11 étapes (avec photos)

2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-23 14:45

Il s'agit d'une instruction étape par étape sur la façon de créer une caméra de sécurité IoT activée par le mouvement à l'aide d'un Raspberry Pi. Vous apprendrez à créer un serveur Web et un formulaire de flacon qui permettent à l'utilisateur d'ajuster la sensibilité et la durée d'enregistrement de la caméra, de démarrer/arrêter manuellement un enregistrement et/ou de prendre une photo qui sera enregistrée localement.

Fournitures

• Framboise Pi 3
• Caméra Pi
• Détecteur de mouvement PIR
• carte SD
• Source d'énergie

Étape 1: Assembler le matériel

Lorsque le Pi est éteint, insérez la carte micro-SD dans le Pi. Insérez le câble plat du module de caméra dans le port du module de caméra sur le Pi. Ensuite, connectez les 3 broches (étiquetées VCC, OUT et GND) du détecteur de mouvement PRI aux broches GPIO du Pi. Connectez le VCC à 5,5 V d'alimentation, le GND à la terre et le OUT à la broche 11 du Pi.

Étape 2: Assurez-vous que votre Pi est connecté à Internet

Maintenant, allumez le Pi en le connectant à une source d'alimentation et vérifiez que vous êtes connecté à Internet à l'aide de la commande ping. Si vous ne savez pas comment connecter votre Pi à Internet, cliquez ici.

sudo ping www.google.com

Si vous réussissez, vous devriez voir que les données sont reçues par Google.

De plus, vous pouvez utiliser ifconfig pour voir votre adresse IP.

sudo ifconfig

Étape 3: Configurer la caméra

Utilisez la commande suivante pour ouvrir l'interface de configuration et activer la caméra dans les "options d'interfaçage".

sudo raspi-config

Après le redémarrage, vous pouvez afficher l'état de votre caméra pour vous assurer qu'elle est correctement connectée.

vcgencmd get_camera

Enfin, installez le module picamera.

pip installer picamera

Étape 4: Installer le flacon

Installez le flask et le module flask-restful pour Python:

sudo apt-get installer python-dev python-pip

python -m pip install flask flask-restful

Ensuite, nous allons installer un module python flask utilisé pour créer des formulaires.

pip installer flacon-wtf

Étape 5: créer une classe de formulaire

Créez un répertoire appelé iotProject pour stocker tous vos fichiers.

sudo mkdir iotProject

Créez un fichier python nommé "camControl.py".

sudo nano camControl.py

Dans ce fichier, nous allons créer notre classe de formulaire, qui nous permet de créer un formulaire Web avec des zones de texte et un menu déroulant permettant à l'utilisateur de modifier les paramètres de la caméra, de démarrer/arrêter manuellement un enregistrement et de capturer une vidéo.

de flask_wtf import FlaskFormfrom wtforms.validators import DataRequired de wtforms import SubmitField de wtforms import validators, IntegerField, BooleanField, SelectField

classe camFrame(FlaskForm):

videoDuration = IntegerField('Durée d'enregistrement (en secondes)')

sensibilité = IntegerField('Sensibilité au mouvement (plage 2500-10000)\nPlus le nombre est élevé, moins la caméra est sensible', validators=[validators. NumberRange(min=2500, max=10000, message='Valeur hors limites')])

options = SelectField('Options', choice=[('none', 'Aucune action'), ('rec', 'Start Recording'), ('stop', 'Stop Recording'), ("Photo", "Prendre une photo")])

soumettre=SoumettreChamp('Soumettre')

Étape 6: créer un modèle de flacon

Pour créer l'interface utilisateur, vous devez concevoir un modèle Flask qui utilise le formulaire que vous venez de créer. Ce fichier sera écrit en html et stocké dans un dossier appelé templates, qui doit se trouver dans le même répertoire que votre formulaire.

Dans votre dossier de modèles, créez un fichier appelé index.html. Dans ce fichier, répliquez le code ci-dessus.

Étape 7: Rendu du modèle

Il est maintenant temps de créer un fichier qui rend le modèle. Créez un fichier nommé appCam.py (assurez-vous que vous n'êtes plus dans le dossier des modèles). Tout contenu dynamique utilisé dans le modèle doit être utilisé comme argument nommé dans l'appel à render_template().

import camControlfrom flask import Flask, render_template, request, Response from flask_restful import Resource, Api, reqparse

app = Flacon (_nom_)

app.config['SECRET_KEY'] = '13542' api = Api(app)

parser = reqparse. RequestParser()

parser.add_argument('dur', type=int, help='Durée de la vidéo lorsqu'un mouvement est détecté') parser.add_argument('sens', type=int, help='Niveau de mouvement requis pour déclencher un enregistrement') analyseur.add_argument('opt', type=str, help='Enregistrer manuellement une vidéo ou capturer une image')

Mise à jour de classe (ressource):

#Trucs pour wtforms def post(self): args = parser.parse_args() #rc.input(args['dur'], args['sens'], args['opt']) #écrire dans le fichier texte qui parle à la caméra fonctionnant en parallèle cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.write(args['dur'] + '\n') #write pendant cameraSettingsFile.write(args['sens'] + '\n') #write sens cameraSettingsFile.write(args['opt'] + '\n') #write opt cameraSettingsFile.close() return {'dur': args['dur'], 'sens': args['sense'], 'opt':args['opt']}

@app.route('/', methodes=['GET', 'POST'])

def index(): """Page d'accueil du contrôleur""" form = camControl.camFrame() #ceci est un formulaire if request.method == 'POST': print(request.form) args = [i for i in request.form.items()] #rc.input(int(args[0][1]), int(args[1][1]), args[2][1]) cameraSettingsFile = open("cameraSettings.txt ", 'w') cameraSettingsFile.write(args[0][1] + '\n') #write pendant cameraSettingsFile.write(args[1][1] + '\n') #write sens cameraSettingsFile.write(args[2][1] + '\n') #write opt cameraSettingsFile.close() imageDictionary = {"filename":"image.jpg"} return render_template('index.html', form=form, image = imageDictionary)

api.add_resource(Mise à jour, '/mise à jour/')

if _name_ == '_main_':

app.run(host='0.0.0.0', port =80, debug=True, threaded=True)

Étape 8: créer une classe d'opérateur de caméra

Maintenant, nous voulons créer un fichier appelé camOperator.py. Nous y créerons une classe de caméra avec des méthodes pour faire fonctionner la caméra, en utilisant les fonctions PiCamera déjà disponibles. Nous utiliserons une instance de cet objet dans l'étape suivante où nous combinerons les fonctionnalités de la caméra et du capteur de mouvement.

Les méthodes définies dans cette classe modifient les paramètres « enregistrement » sur la caméra de sécurité en utilisant les entrées de sensibilité et de durée que l'utilisateur fournit, tout en établissant des valeurs par défaut pour ces variables si l'entrée de l'utilisateur n'est pas présente.

importer RPi. GPIO en tant que GPIOimport time import picamera from datetime import datetime

GPIO.setmode(GPIO. BOARD)

GPIO.setup(11, GPIO. IN)

détecter = 0

caméra de classeOpérateur:

def _init_(self):

#constructeur self.cam = picamera. PiCamera() self.data = self.dur=10 self.sens=2500 self.opt="none"

def record(self, dur):

#Enregistrements pour la durée donnée définie par le contrôleur videoName = str(datetime.now()) videoName = videoName.replace(':', ') videoName = videoName.replace('.', ') self.cam.start_recording('/home/pi/iotProject/videos/'+ videoName + '.h264') time.sleep(dur) self.cam.stop_recording()

def operation(self, dur, sens):

#Fonctionnement principal de la caméra qui vérifie en permanence si un humain est à proximité, si un humain reste assez longtemps dans les parages, nous commençons à enregistrer ! global detect i = GPIO.input (11) if i == 0: #Lorsque la sortie du capteur de mouvement est FAIBLE detect=0 time.sleep(0.1) elif i == 1: #Lorsque la sortie du capteur de mouvement est HIGH print(" mouvement détecté "+str(detect)) if detect >= sens*10: self.record(dur) print("RECORDED") detect = 0 time.sleep(0.1) detect += 1

Étape 9: Créer le module d'enregistrement

Le dernier programme nécessaire à ce projet sera écrit dans un fichier nommé rec.py. Ce fichier indique à l'appareil photo quand enregistrer, combien de temps enregistrer et si/quand prendre une photo. Pour ce faire, il vérifie et lit constamment les données utilisateur écrites dans le fichier texte à partir de l'étape 5. Si le fichier a été mis à jour, il ajuste les valeurs de sensibilité et de durée en conséquence, puis, si un enregistrement ou une photo est pris, il enregistre le contenu dans le pi, soit dans un format de fichier.h264 ou.jpg.

'''S'exécute en parallèle avec le serveur de flacons, en lisant les variables de contrôle définies par les formulaires du serveur. Les variables de contrôle du serveur sont définies dans un fichier séparé une fois les formulaires soumis. Le module rec lit ces variables et met à jour la caméra en fonction d'elles. ''' import camOperator à partir de datetime import datetime import time

rc = CamOperator.cameraOperator()

cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.close() #ici, nous ouvrons et fermons en mode écriture afin de supprimer le contenu du fichier avant l'exécution de la boucle principale

#Une boucle continue qui surveille si des humains sont à proximité. S'ils le sont, alors

#la caméra commence à enregistrer. Cette fonction s'exécute en parallèle avec le flask #server qui contrôle cette caméra. RecordingInProcess = False while True: #check/record if (recordingInProcess == False): rc.operation(rc.dur, rc.sens) #modifier les paramètres de la caméra en fonction du serveur cameraSettingsFile = open("cameraSettings.txt", 'r') settingNum = 0 pour le réglage dans cameraSettingsFile.readlines(): if settingNum == 0: #Duration change rc.dur = int(setting) elif settingNum == 1: #Sensitivity change rc.sens = int(setting) elif settingNum == 2: #Action change rc.opt = setting settingNum += 1 cameraSettingsFile.close()

#exécuter une action

# if rc.opt == "none": # continue if rc.opt == "rec\n" and recordingInProcess == False: print("Exécuter la commande d'enregistrement du contrôleur") #Générer le nom de la vidéo en fonction de l'heure actuelle videoName = "snappedVid_"+str(datetime.now()) videoName = videoName.replace(':', ') videoName = videoName.replace('.', ') rc.cam.start_recording('/home/pi/iotProject /videos/'+ videoName + '.h264') enregistrementInProcess = True elif rc.opt == "stop\n" and recordingInProcess == True: print("Arrêter la commande d'enregistrement du contrôleur") rc.cam.stop_recording() enregistrementInProcess = False cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.write(str(rc.dur)+'\n') cameraSettingsFile.write(str(rc.sens)+'\n') cameraSettingsFile. write("aucun\n") rc.opt = "aucun\n" elif rc.opt == "pic\n" et enregistrementInProcess == False: print("Snap a pic command from the controller") pictureName = "snappedPic_ "+str(datetime.now()) pictureName = pictureName.replace(':', ') pictureName = pictureName.replace('.', ') rc.cam.st art_preview() time.sleep(5) rc.cam.capture('pictures/' + pictureName + '.jpg') rc.cam.stop_preview() cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile. write(str(rc.dur)+'\n') cameraSettingsFile.write(str(rc.sens)+'\n') cameraSettingsFile.write("aucun\n") rc.opt = "aucun\n"

Étape 10: Démarrer le serveur

SSH dans le pi et démarrez le serveur à l'aide de la ligne de commande indiquée ci-dessus.

Étape 11: ESSAYEZ-LE

Accédez à la page Web en utilisant l'adresse IP et vous devriez pouvoir contrôler la caméra à distance !