Raspberry Pi Überwachungskamera - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Dies ist eine Schritt für Schritt Anleitung zum Erstellen einer IoT, bewegungsaktivierten Überwachungskamera mit einem Raspberry Pi. Sie erfahren, wie Sie einen Kolben-Webserver und ein Formular erstellen, mit dem der Benutzer die Empfindlichkeit der Kamera und die Aufnahmezeit anpassen, eine Aufnahme manuell starten/stoppen und/oder ein Bild aufnehmen kann, das lokal gespeichert wird.

Lieferungen

• Raspberry Pi 3
• Pi-Kamera
• PIR-Bewegungssensor
• SD-Karte
• Energiequelle

Schritt 1: Montieren Sie die Hardware

Legen Sie bei ausgeschaltetem Pi die Micro-SD-Karte in den Pi ein. Stecken Sie das Flachbandkabel des Kameramoduls in den Kameramodulanschluss am Pi. Verbinden Sie dann die 3 Pins (beschriftet mit VCC, OUT und GND) des PRI-Bewegungsmelders mit den GPIO-Pins des Pi. Verbinden Sie den VCC mit 5,5 V Strom, den GND mit Masse und den OUT mit Pin 11 auf dem Pi.

Schritt 2: Stellen Sie sicher, dass Ihr Pi mit dem Internet verbunden ist

Schalten Sie nun den Pi ein, indem Sie ihn an eine Stromquelle anschließen und überprüfen Sie mit dem Ping-Befehl, ob Sie mit dem Internet verbunden sind. Wenn Sie nicht wissen, wie Sie Ihren Pi mit dem Internet verbinden, klicken Sie hier.

sudo ping www.google.com

Wenn Sie erfolgreich sind, sollten Sie sehen, dass Daten von Google empfangen werden.

Darüber hinaus können Sie ifconfig verwenden, um Ihre IP-Adresse anzuzeigen.

sudo ifconfig

Schritt 3: Einrichten der Kamera

Verwenden Sie den folgenden Befehl, um die Konfigurationsoberfläche zu öffnen und die Kamera in den "Schnittstellenoptionen" zu aktivieren.

sudo raspi-config

Nach dem Neustart können Sie den Status Ihrer Kamera anzeigen, um sicherzustellen, dass sie richtig verbunden ist.

vcgencmd get_camera

Installieren Sie zuletzt das Picamera-Modul.

pip installieren picamera

Schritt 4: Flask installieren

Installieren Sie das Modul Flask und Flask-restful für Python:

sudo apt-get install python-dev python-pip

python -m pip install Flask Flask-restful

Als nächstes installieren wir ein Python-Kolbenmodul zum Erstellen von Formularen.

pip install kolben-wtf

Schritt 5: Erstellen Sie eine Formularklasse

Erstellen Sie ein Verzeichnis namens iotProject, in dem alle Ihre Dateien gespeichert werden.

sudo mkdir iotProject

Erstellen Sie eine Python-Datei namens "camControl.py".

sudo nano camControl.py

In dieser Datei erstellen wir unsere Formularklasse, die es uns ermöglicht, ein Webformular mit Textfeldern und einem Dropdown-Menü zu erstellen, damit der Benutzer die Kameraeinstellungen ändern, eine Aufnahme manuell starten/stoppen und Videos aufnehmen kann.

from bottle_wtf import FlaskFormfrom wtforms.validators import DataRequired from wtforms import SubmitField from wtforms import validators, IntegerField, BooleanField, SelectField

Klasse camFrame (FlaskForm):

videoDuration = IntegerField('Aufnahmezeit (in Sekunden)')

Empfindlichkeit = IntegerField('Bewegungsempfindlichkeit (Bereich 2500-10000)\nJe höher die Zahl, desto weniger empfindlich ist die Kamera', validators=[validators. NumberRange(min=2500, max=10000, message='Wert außerhalb des Bereichs')])

options = SelectField('Options', choice=[('none', 'No action'), ('rec', 'Start Recording'), ('stop', 'Stop Recording'), ('Bild', 'Bild machen')])

übermitteln=SubmitField('Senden')

Schritt 6: Erstellen Sie eine Flask-Vorlage

Um die Benutzeroberfläche zu erstellen, müssen Sie eine Flask-Vorlage entwerfen, die das soeben erstellte Formular verwendet. Diese Datei wird in HTML geschrieben und in einem Ordner namens templates gespeichert, der sich im selben Verzeichnis wie Ihr Formular befinden sollte.

Erstellen Sie in Ihrem Vorlagenordner eine Datei namens index.html. Replizieren Sie in dieser Datei den oben gezeigten Code.

Schritt 7: Rendern Sie die Vorlage

Jetzt ist es an der Zeit, eine Datei zu erstellen, die die Vorlage rendert. Erstellen Sie eine Datei namens appCam.py (stellen Sie sicher, dass Sie sich nicht mehr im Vorlagenordner befinden). Jeder in der Vorlage verwendete dynamische Inhalt muss als benanntes Argument im Aufruf von render_template() verwendet werden.

import camControlfrom Flask import Flask, render_template, request, Response from Flask_restful import Resource, Api, reqparse

app = Flasche(_name_)

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

parser = reqparse. RequestParser()

parser.add_argument('dur', type=int, help='Dauer des Videos, wenn eine Bewegung erkannt wird') parser.add_argument('sens', type=int, help='Bewegungsstärke zum Auslösen einer Aufnahme') Parser.add_argument('opt', type=str, help='Video manuell aufnehmen oder Bild aufnehmen')

Klassenaktualisierung(Ressource):

#Zeug für wtforms def post(self): args = parser.parse_args() #rc.input(args['dur'], args['sens'], args['opt']) #in die Textdatei schreiben, die spricht mit der parallel laufenden Kamera cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.write(args['dur'] + '\n') #write dur 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('/', Methoden=['GET', 'POST'])

def index(): """Controller-Homepage""" form = camControl.camFrame() #Dies ist ein Formular if request.method == 'POST': print(request.form) args = [i für 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 dur 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(Update, '/update/')

if _name_ == '_main_':

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

Schritt 8: Erstellen Sie eine Kameraführerklasse

Nun wollen wir eine Datei namens camOperator.py erstellen. Darin werden wir eine Kameraklasse mit Methoden zum Betrieb der Kamera erstellen, wobei die bereits verfügbaren PiCamera-Funktionen verwendet werden. Wir werden im nächsten Schritt eine Instanz dieses Objekts verwenden, in der wir die Funktionalität der Kamera und des Bewegungssensors kombinieren.

Die in dieser Klasse definierten Methoden ändern die "Aufzeichnungs"-Einstellungen der Überwachungskamera unter Verwendung der vom Benutzer bereitgestellten Empfindlichkeits- und Dauereingaben, während Standardwerte für diese Variablen festgelegt werden, wenn keine Benutzereingaben vorhanden sind.

RPi. GPIO als GPIO importieren Zeit importieren Picamera von Datum/Uhrzeit importieren Datum/Uhrzeit importieren

GPIO.setmode(GPIO. BOARD)

GPIO.setup(11, GPIO. IN)

erkennen = 0

Klasse KameraBetreiber:

def _init_(selbst):

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

def record(self, dur):

#Aufnahmen für die vom Controller vorgegebene Dauer 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):

#Hauptfunktion der Kamera, die ständig überprüft, ob ein Mensch in der Nähe ist, wenn ein Mensch lange genug in der Nähe bleibt, beginnen wir mit der Aufnahme! global erkennen i = GPIO.input(11) if i == 0: #Wenn die Ausgabe des Bewegungssensors LOW ist, erkennen=0 time.sleep(0.1) elif i == 1: #Wenn die Ausgabe des Bewegungssensors HIGH ist print(" Bewegung erkannt "+str(detect)) if Detect >= sens*10: self.record(dur) print("RECORDED") Detect = 0 time.sleep(0.1) Detect += 1

Schritt 9: Erstellen Sie das Aufnahmemodul

Das letzte für dieses Projekt benötigte Programm wird in eine Datei namens rec.py geschrieben. Diese Datei teilt der Kamera mit, wann sie aufnehmen soll, wie lange sie aufnehmen soll und ob/wann sie ein Bild aufnehmen soll. Dies geschieht durch ständiges Überprüfen und Lesen der Benutzerdaten, die ab Schritt 5 in die Textdatei geschrieben wurden. Wenn die Datei aktualisiert wurde, passt sie die Empfindlichkeits- und Dauerwerte entsprechend an und speichert dann, wenn eine Aufnahme oder ein Bild aufgenommen wird, den Inhalt unter das pi, entweder im.h264- oder.jpg-Dateiformat.

'''Wird parallel mit dem Kolbenserver ausgeführt und liest die von den Serverformularen gesetzten Steuervariablen. Die Serversteuervariablen werden nach dem Absenden der Formulare in einer separaten Datei festgelegt. Das rec-Modul liest diese Variablen und aktualisiert die Kamera basierend darauf. ''' camOperator aus Datum/Uhrzeit importieren Datum/Uhrzeit importieren Uhrzeit importieren

rc = camOperator.cameraOperator()

cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.close() #hier öffnen und schließen wir im Schreibmodus, um den Inhalt der Datei zu löschen, bevor die Hauptschleife läuft

#Eine Endlosschleife, die überwacht, ob sich Menschen in der Nähe befinden. Wenn sie es sind, dann

#die Kamera beginnt mit der Aufnahme. Diese Funktion läuft parallel mit dem Kolben #Server, der diese Kamera steuert. recordInProcess = False while True: #check/record if (recordingInProcess == False): rc.operation(rc.dur, rc.sens) #Ändere die Einstellungen der Kamera basierend auf dem Server cameraSettingsFile = open("cameraSettings.txt", 'r') settingNum = 0 für die Einstellung in cameraSettingsFile.readlines(): if settingNum == 0: #Daueränderung rc.dur = int(setting) elif settingNum == 1: #Empfindlichkeitsänderung rc.sens = int(setting) elif settingNum == 2: #Aktionsänderung rc.opt = Einstellung settingNum += 1 cameraSettingsFile.close()

#eine Aktion ausführen

# if rc.opt == "none": # fortfahren if rc.opt == "rec\n" andrecordingInProcess == False: print("Running record command from controller") #Namen für Video basierend auf der aktuellen Zeit generieren videoName = "snappedVid_"+str(datetime.now()) videoName = videoName.replace(':', ') videoName = videoName.replace('.', ') rc.cam.start_recording('/home/pi/iotProject /videos/'+ videoName + '.h264')recordingInProcess = True elif rc.opt == "stop\n" undrecordingInProcess == True: print("Aufzeichnungsbefehl vom Controller stoppen") rc.cam.stop_recording()recordingInProcess = Falsch cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.write(str(rc.dur)+'\n') cameraSettingsFile.write(str(rc.sens)+'\n') cameraSettingsFile. write("none\n") rc.opt = "none\n" elif rc.opt == "pic\n" andrecordingInProcess == 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("none\n") rc.opt = "none\n"

Schritt 10: Starten Sie den Server

SSH in das pi und starten Sie den Server mit der oben gezeigten Befehlszeile.

Schritt 11: PROBIEREN SIE ES AUS

Greifen Sie über die IP-Adresse auf die Webseite zu und Sie sollten in der Lage sein, die Kamera aus der Ferne zu steuern!