Raspberry Pi -beveiligingskamera: 11 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Dit is 'n stap -vir -stap instruksie hoe u 'n IoT -bewegingskamera kan maak met 'n Raspberry Pi. U leer hoe om 'n kolfwebbediener en 'n vorm te skep waarmee die gebruiker die sensitiwiteit en opnametyd van die kamera kan aanpas, 'n opname met die hand kan begin/stop en/of 'n foto kan neem wat plaaslik gestoor sal word.

Voorrade

• Framboos Pi 3
• Pi kamera
• PIR bewegingsensor
• SD kaart
• Kragbron

Stap 1: Monteer die hardeware

Terwyl die Pi uitgeskakel is, plaas die mikro-SD-kaart in die Pi. Steek die lintkabel van die kameramodule in die poort van die kameramodule op die Pi. Koppel dan die 3 penne (gemerk VCC, OUT en GND) van die PRI -bewegingsmelder aan die Pi se GPIO -penne. Koppel die VCC aan 5.5V krag, die GND aan die aarde en die OUT aan pen 11 op die Pi.

Stap 2: Maak seker dat u Pi aan die internet gekoppel is

Skakel die Pi nou aan deur dit aan 'n kragbron te koppel en verifieer dat u met die internet gekoppel is met die ping -opdrag. As u nie weet hoe u u Pi aan die internet kan koppel nie, klik dan hier.

sudo ping www.google.com

As u suksesvol is, moet u sien dat data deur Google ontvang word.

Boonop kan u ifconfig gebruik om u IP -adres te sien.

sudo ifconfig

Stap 3: Stel die kamera op

Gebruik die volgende opdrag om die konfigurasie -koppelvlak oop te maak en aktiveer die kamera in die "koppelvlakopsies".

sudo raspi-config

Nadat u weer begin het, kan u die status van u kamera vertoon om te verseker dat dit behoorlik verbind is.

vcgencmd get_camera

Laastens, installeer die picamera -module.

pip installeer picamera

Stap 4: Installeer Flask

Installeer die fles en kolf-rustige module vir Python:

sudo apt-get installeer python-dev python-pip

python -m pip installeer flesfles -rustig

Vervolgens installeer ons 'n luislangflesmodule wat gebruik word om vorms te skep.

pip installeer flask-wtf

Stap 5: Skep 'n vormklas

Maak 'n gids genaamd iotProject om al u lêers in te stoor.

sudo mkdir iotProject

Skep 'n python -lêer met die naam "camControl.py".

sudo nano camControl.py

In hierdie lêer sal ons ons vormklas skep, waarmee ons 'n webvorm met teksblokkies en 'n keuselys kan skep sodat die gebruiker die kamera se instellings kan verander, 'n opname met die hand kan begin/stop en video kan opneem.

vanaf flask_wtf invoer FlaskFormvan wtforms.validators invoer DataVereis van wtforms invoer SubmitField van wtforms invoer validators, IntegerField, BooleanField, SelectField

klas camFrame (FlaskForm):

videoDuration = IntegerField ('Opname tyd (in sekondes)')

sensitiwiteit = IntegerField ('Bewegingsgevoeligheid (reeks 2500-10000) n Hoe hoër die getal, hoe minder sensitief is die kamera', validators = [validators. NumberRange (min = 2500, max = 10000, message = 'Waarde buite bereik')])

options = SelectField ('Options', options = [('none', 'No action'), ('rec', 'Start Recording'), ('stop', 'Stop Recording'), ('pic', 'Take Picture')])

submit = SubmitField ('Submit')

Stap 6: Skep 'n flessjabloon

Om die gebruikerskoppelvlak te skep, moet u 'n Flask -sjabloon ontwerp wat die vorm gebruik wat u pas geskep het. Hierdie lêer word in html geskryf en gestoor in 'n gids genaamd templates, wat in dieselfde gids as u vorm moet wees.

Skep 'n lêer genaamd index.html in u sjabloonmap. In hierdie lêer, herhaal die kode hierbo.

Stap 7: Gee die sjabloon weer

Dit is nou tyd om 'n lêer te skep wat die sjabloon weergee. Skep 'n lêer met die naam appCam.py (maak seker dat u nie meer in die sjabloonmap is nie). Enige dinamiese inhoud wat in die sjabloon gebruik word, moet as 'n genoemde argument in die oproep na render_template () gebruik word.

invoer camControl van fles invoer fles, render_template, versoek, reaksie van flask_restful invoerhulpbron, Api, reqparse

app = Fles (_ naam_)

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

parser = reqparse. RequestParser ()

parser.add_argument ('dur', type = int, help = 'Duur van video wanneer beweging opgespoor word') parser.add_argument ('sens', type = int, help = 'Bewegingsvlak benodig om 'n opname te aktiveer') parser.add_argument ('opt', type = str, help = 'Neem 'n video handmatig op of maak 'n beeld')

klasopdatering (hulpbron):

#Stuff vir wtforms def post (self): args = parser.parse_args () #rc.input (args ['dur'], args ['sens'], args ['opt']) #skryf na die tekslêer wat praat met die kamera wat parallel loop 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 ('/', metodes = ['KRY', 'POST'])

def index (): "" "Controller home page" "" form = camControl.camFrame () #dit is 'n vorm as request.method == 'POST': print (request.form) args = [i vir i in aanvraag.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') #skryf tydens cameraSettingsFile.write (args [1] [1] + '\ n') #write sens cameraSettingsFile.write (args [2] [1] + '\ n') #write opt cameraSettingsFile.close () imageDictionary = {"lêernaam": "image.jpg"} gee render_template ('index.html', form = form, image = imageDictionary terug)

api.add_resource (opdatering, '/update/')

as _naam_ == '_hoof_':

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

Stap 8: Skep 'n kamera -operateursklas

Nou wil ons 'n lêer met die naam camOperator.py skep. Hierin maak ons 'n kameraklas met metodes om die kamera te gebruik, met behulp van die reeds beskikbare PiCamera -funksies. Ons sal in die volgende stap 'n voorbeeld van hierdie voorwerp gebruik, waar ons die funksionaliteit van die kamera en die bewegingsensor sal kombineer.

Die metodes wat in hierdie klas gedefinieer word, verander die "rekord" -instellings op die beveiligingskamera deur gebruik te maak van die sensitiwiteits- en tydsinsette wat die gebruiker verskaf, terwyl standaardwaardes vir hierdie veranderlikes vasgestel word as daar geen gebruikersinvoer is nie.

invoer RPi. GPIO as GPIOimport tyd invoer picamera vanaf datetime invoer datetime

GPIO.setmode (GPIO. BOARD)

GPIO.setup (11, GPIO. IN)

opspoor = 0

klas kamera Operateur:

def _init _ (self):

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

def -rekord (self, dur):

#Records vir die gegewe tydsduur wat deur die beheerder gestel word 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 operasie (self, dur, sens):

#Die hoofbediening van die kamera wat voortdurend kyk of 'n mens naby is, as 'n mens lank genoeg bly, begin ons opneem! globale opsporing i = GPIO.input (11) as i == 0: #As die uitset van die bewegingsensor LAAG is, detect = 0 time.sleep (0.1) elif i == 1: #Wanneer die uitset van die bewegingsensor HOGE druk is (" beweging opgespoor " +str (detect)) as detect> = sens*10: self.record (dur) print (" RECORDED ") detect = 0 time.sleep (0.1) detect += 1

Stap 9: Skep die rekordmodule

Die laaste program wat vir hierdie projek benodig word, sal in 'n lêer genaamd rec.py geskryf word. Hierdie lêer vertel die kamera wanneer om op te neem, hoe lank om op te neem en of/wanneer om 'n foto te neem. Dit word gedoen deur die gebruikersdata wat in stap 5 na die tekslêer geskryf is, voortdurend te kontroleer en te lees. As die lêer opgedateer is, pas dit die sensitiwiteits- en duurwaardes daarvolgens aan, en as dit 'n opname of 'n foto neem, word die inhoud gestoor die pi, óf in 'n.h264- as-j.webp

'' 'Loop parallel met die kolfbediener en lees kontrolevariabels wat deur die bedienervorme gestel word. Die bedienerbeheerveranderlikes word in 'n aparte lêer opgestel sodra die vorms ingedien is. Die opnamemodule lees hierdie veranderlikes en werk die kamera op grond daarvan op. '' 'invoer camOperator vanaf datatyd invoer datatyd invoer tyd

rc = camOperator.cameraOperator ()

cameraSettingsFile = open ("cameraSettings.txt", 'w') cameraSettingsFile.close () #hier, ons maak en sluit in die skryfmodus om die inhoud in die lêer te verwyder voordat die hooflus loop

#'N Deurlopende lus wat kyk of mense naby is. As hulle is, dan

#die kamera begin opneem. Hierdie funksie werk parallel met die fles #server wat hierdie kamera beheer. recordingInProcess = Onwaar terwyl dit waar is: #check/record if (recordingInProcess == False): rc.operation (rc.dur, rc.sens) #verander die instellings van die kamera op grond van die bediener cameraSettingsFile = open ("cameraSettings.txt", 'r') settingNum = 0 vir instelling in cameraSettingsFile.readlines (): as settingNum == 0: #Durasieverandering rc.dur = int (setting) elif settingNum == 1: #Gevoeligheidsverandering rc.sens = int (setting) elif settingNum == 2: #Action change rc.opt = setting settingNum += 1 cameraSettingsFile.close ()

#voer 'n aksie uit

# as rc.opt == "geen": # gaan voort as rc.opt == "rec / n" en recordingInProcess == Onwaar: druk ("Rekordopdrag vanaf beheerder uitvoer") # Genereer naam vir video gebaseer op huidige tyd videonaam = "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 ("Stop opname bevel van kontroleerder") rc.cam.stop_recording () recordingInProcess = Valse cameraSettingsFile = oop ("cameraSettings.txt", 'w') cameraSettingsFile.write (str (rc.dur)+'\ n') cameraSettingsFile.write (str (rc.sens)+'\ n') cameraSettingsFile. skryf ("none / n") rc.opt = "none / n" elif rc.opt == "pic / n" en recordingInProcess == Onwaar: druk ("Snap 'n opdrag van die beheerder") 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. skryf (str (rc.dur)+'\ n') cameraSettingsFile.write (str (rc.sens)+'\ n') cameraSettingsFile.write ("geen / n") rc.opt = "geen / n"

Stap 10: Begin die bediener

SSH in die pi en begin die bediener met behulp van die opdragreël hierbo.

Stap 11: PROBEER DIT

Toegang tot die webblad met behulp van die IP -adres, en u moet die kamera op afstand kan beheer!