Raspberry Pi Beveiligingscamera - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Dit is een stapsgewijze instructie over het maken van een IoT, door beweging geactiveerde beveiligingscamera met behulp van een Raspberry Pi. U leert hoe u een flask-webserver en -formulier kunt maken waarmee de gebruiker de gevoeligheid en opnametijd van de camera kan aanpassen, handmatig een opname kan starten/stoppen en/of een foto kan maken die lokaal wordt opgeslagen.

Benodigdheden

• Raspberry Pi 3
• Pi-camera
• PIR bewegingssensor
• SD-kaart
• Krachtbron

Stap 1: Monteer de hardware

Terwijl de Pi is uitgeschakeld, plaatst u de micro-SD-kaart in de Pi. Steek de lintkabel van de cameramodule in de cameramodulepoort op de Pi. Verbind vervolgens de 3 pinnen (met het label VCC, OUT en GND) van de PRI-bewegingsdetector met de GPIO-pinnen van de Pi. Sluit de VCC aan op 5,5 V stroom, de GND op aarde en de OUT op pin 11 op de Pi.

Stap 2: Zorg ervoor dat uw Pi is verbonden met internet

Schakel nu de Pi in door hem op een voedingsbron aan te sluiten en controleer of u verbonden bent met internet met behulp van de ping-opdracht. Als je niet weet hoe je je Pi met internet moet verbinden, klik dan hier.

sudo ping www.google.com

Als je succesvol bent, zou je moeten zien dat gegevens door Google worden ontvangen.

Bovendien kunt u ifconfig gebruiken om uw IP-adres te zien.

sudo ifconfig

Stap 3: Stel de camera in

Gebruik de volgende opdracht om de configuratie-interface te openen en schakel de camera in de "interface-opties" in.

sudo raspi-config

Na het opnieuw opstarten kunt u de status van uw camera weergeven om ervoor te zorgen dat deze correct is aangesloten.

vcgencmd get_camera

Installeer ten slotte de picamera-module.

pip installeer picamera

Stap 4: Installeer Flask

Installeer de kolf en kolf-rustgevende module voor Python:

sudo apt-get install python-dev python-pip

python -m pip install flask flask-rustig

Vervolgens zullen we een python-flesmodule installeren die wordt gebruikt voor het maken van formulieren.

pip install flask-wtf

Stap 5: Maak een formulierklasse

Maak een map met de naam iotProject om al uw bestanden in op te slaan.

sudo mkdir iotProject

Maak een python-bestand met de naam "camControl.py".

sudo nano camControl.py

In dit bestand zullen we onze formulierklasse maken, waarmee we een webformulier kunnen maken met tekstvakken en een vervolgkeuzemenu waarmee de gebruiker de camera-instellingen kan wijzigen, handmatig een opname kan starten/stoppen en video kan vastleggen.

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

klasse camFrame (FlaskForm):

videoDuration = IntegerField('Opnametijd (in seconden)')

gevoeligheid = IntegerField('Bewegingsgevoeligheid (bereik 2500-10000)\nHoe hoger het getal, hoe minder gevoelig de camera is', validators=[validators. NumberRange(min=2500, max=10000, message='Waarde buiten bereik')])

options = SelectField('Options', options=[('none', 'No action'), ('rec', 'Start Recording'), ('stop', 'Stop Recording'), ('foto', 'Foto maken')])

submit=SubmitField('Submit')

Stap 6: Maak een kolfsjabloon

Om de gebruikersinterface te maken, moet u een Flask-sjabloon ontwerpen die het formulier gebruikt dat u zojuist hebt gemaakt. Dit bestand wordt in html geschreven en opgeslagen in een map met de naam sjablonen, die zich in dezelfde map moet bevinden als uw formulier.

Maak in uw sjablonenmap een bestand met de naam index.html. Repliceer in dit bestand de hierboven getoonde code.

Stap 7: Render de sjabloon

Nu is het tijd om een bestand te maken dat de sjabloon weergeeft. Maak een bestand met de naam appCam.py (zorg ervoor dat u zich niet langer in de map met sjablonen bevindt). Alle dynamische inhoud die in de sjabloon wordt gebruikt, moet worden gebruikt als een benoemd argument in de aanroep van render_template().

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

app = Kolf(_naam_)

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

parser = reqparse. RequestParser()

parser.add_argument('dur', type=int, help='Duur van video wanneer beweging wordt gedetecteerd') parser.add_argument('sens', type=int, help='Niveau van beweging vereist om een opname te activeren') parser.add_argument('opt', type=str, help='Handmatig een video opnemen of een afbeelding vastleggen')

klasse Update (bron):

#Stuff for wtforms def post(self): args = parser.parse_args() #rc.input(args['dur'], args['sens'], args['opt']) #schrijf naar het tekstbestand dat praat met de camera die parallel loopt 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(): """Startpagina van de controller""" form = camControl.camFrame() #this is a form 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 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', poort =80, debug=True, threaded=True)

Stap 8: maak een camera-operatorklasse aan

Nu willen we een bestand maken met de naam camOperator.py. Daarin zullen we een cameraklasse maken met methoden om de camera te bedienen, gebruikmakend van de reeds beschikbare PiCamera-functies. We zullen een exemplaar van dit object gebruiken in de volgende stap, waar we de functionaliteit van de camera en de bewegingssensor zullen combineren.

De methoden die in deze klasse zijn gedefinieerd, wijzigen de "opname"-instellingen op de beveiligingscamera met behulp van de gevoeligheids- en duurinvoer die de gebruiker levert, terwijl standaardwaarden voor deze variabelen worden ingesteld als gebruikersinvoer niet aanwezig is.

importeer RPi. GPIO als GPIO importeer tijd importeer picamera van datetime importeer datetime

GPIO.setmode(GPIO. BOARD)

GPIO.setup (11, GPIO. IN)

detecteren = 0

klasse cameraOperator:

def _init_(zelf):

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

def record(zelf, dur):

#Records voor de opgegeven duur ingesteld door de controller 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 operatie (zelf, dur, sens):

#Hoofdbediening van de camera die constant controleert of er een mens in de buurt is, als een mens lang genoeg in de buurt blijft, beginnen we met opnemen! global detect i = GPIO.input (11) if i == 0: #When output van bewegingssensor is LAAG detect=0 time.sleep(0.1) elif i == 1: #When output van bewegingssensor is HOOG print(" beweging gedetecteerd "+str(detect)) indien detecteren >= sens*10: self.record(dur) print("RECORDED") detect = 0 time.sleep(0.1) detect += 1

Stap 9: Maak de recordmodule

Het laatste programma dat nodig is voor dit project wordt geschreven in een bestand met de naam rec.py. Dit bestand vertelt de camera wanneer hij moet opnemen, hoe lang hij moet opnemen en of/wanneer hij een foto moet maken. Het doet dit door constant de gebruikersgegevens te controleren en te lezen die vanaf stap 5 naar het tekstbestand zijn geschreven. Als het bestand is bijgewerkt, past het de gevoeligheid en duur dienovereenkomstig aan en als er een opname of foto wordt gemaakt, slaat het de inhoud op in de pi, hetzij in een.h264- of.jpg-bestandsindeling.

'''Loopt parallel met de kolfserver en leest de controlevariabelen die zijn ingesteld door de serverformulieren. De servercontrolevariabelen worden in een apart bestand gezet zodra de formulieren zijn ingediend. De opnamemodule leest deze variabelen en werkt de camera op basis daarvan bij. ''' import camOperator van datetime import datetime import time

rc = camOperator.cameraOperator()

cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.close() #hier openen en sluiten we in de schrijfmodus om de inhoud in het bestand te verwijderen voordat de hoofdlus wordt uitgevoerd

#Een continue lus die kijkt of er mensen in de buurt zijn. Als ze dat zijn, dan

#de camera begint met opnemen. Deze functie loopt parallel met de flask #server die deze camera bestuurt. recordingInProcess = False terwijl True: #check/record if (recordingInProcess == False): rc.operation(rc.dur, rc.sens) #wijzig de instellingen van de camera op basis van de server cameraSettingsFile = open("cameraSettings.txt", 'r') settingNum = 0 voor instelling in cameraSettingsFile.readlines(): if settingNum == 0: #Duurwijziging rc.dur = int(instelling) elif settingNum == 1: #Gevoeligheidswijziging rc.sens = int(instelling) elif settingNum == 2: #Action change rc.opt = setting settingNum += 1 cameraSettingsFile.close()

#een actie uitvoeren

# if rc.opt == "none": # continue if rc.opt == "rec\n" and recordingInProcess == False: print("Opnameopdracht uitvoeren vanaf controller") #Genereer naam voor video op basis van huidige tijd 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" en recordingInProcess == True: print("Opnamecommando van controller stoppen") rc.cam.stop_recording() recordingInProcess = Valse 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" and recordingInProcess == False: print("Maak een foto-opdracht van de controller") pictureName = "snappedPic_ "+str(datetime.now()) afbeeldingNaam = afbeeldingNaam.replace(':', ') afbeeldingNaam = afbeeldingNaam.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"

Stap 10: Start de server

SSH in de pi en start de server met behulp van de hierboven getoonde opdrachtregel.

Stap 11: PROBEER HET UIT

Ga naar de webpagina met het IP-adres en je zou de camera op afstand moeten kunnen bedienen!