Raspberry Pi უსაფრთხოების კამერა: 11 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:16

ეს არის ეტაპობრივი ინსტრუქცია, თუ როგორ უნდა შეიქმნას IoT, მოძრაობის გააქტიურებული უსაფრთხოების კამერა Raspberry Pi– ს გამოყენებით. თქვენ შეისწავლით თუ როგორ უნდა შექმნათ კოლბის ვებ სერვერი და ფორმა, რომელიც საშუალებას აძლევს მომხმარებელს დაარეგულიროს კამერის მგრძნობელობა და ჩაწერის დრო, ხელით დაიწყოს/შეაჩეროს ჩაწერა და/ან მიიღოს სურათი, რომელიც ადგილობრივად შეინახება.

მარაგები

• ჟოლო პი 3
• პი კამერა
• PIR მოძრაობის სენსორი
• SD ბარათი
• Კვების წყარო

ნაბიჯი 1: ააწყეთ აპარატურა

სანამ Pi გამორთულია, ჩადეთ მიკრო SD ბარათი Pi- ში. ჩადეთ კამერის მოდულის ლენტი კაბელი Pi- ს კამერის მოდულის პორტში. შემდეგ, დაუკავშირეთ PRI მოძრაობის დეტექტორის 3 ქინძისთავი (მარკირებული VCC, OUT და GND) Pi- ს GPIO ქინძისთავებს. შეაერთეთ VCC 5.5 ვ სიმძლავრისთან, GND მიწასთან და OUT მიამაგრეთ 11 Pi- ზე.

ნაბიჯი 2: დარწმუნდით, რომ თქვენი Pi დაკავშირებულია ინტერნეტთან

ახლა, ჩართეთ Pi ენერგიის წყაროსთან დაკავშირებით და დარწმუნდით, რომ ინტერნეტთან ხართ დაკავშირებული პინგის ბრძანების გამოყენებით. თუ არ იცით როგორ დაუკავშიროთ თქვენი Pi ინტერნეტს, დააწკაპუნეთ აქ.

sudo ping www.google.com

თუ წარმატებული ხართ, თქვენ უნდა ნახოთ, რომ მონაცემები მიიღება Google- ის მიერ.

გარდა ამისა, შეგიძლიათ გამოიყენოთ ifconfig თქვენი IP მისამართის სანახავად.

sudo ifconfig

ნაბიჯი 3: დააყენეთ კამერა

გამოიყენეთ შემდეგი ბრძანება კონფიგურაციის ინტერფეისის გასახსნელად და ჩართეთ კამერა "ინტერფეისის პარამეტრებში".

sudo raspi-config

გადატვირთვის შემდეგ, თქვენ შეგიძლიათ აჩვენოთ თქვენი კამერის სტატუსი, რათა დარწმუნდეთ, რომ ის სწორად არის დაკავშირებული.

vcgencmd get_camera

დაბოლოს, დააინსტალირეთ picamera მოდული.

პიპ ინსტალაცია picamera

ნაბიჯი 4: დააინსტალირეთ Flask

დააინსტალირეთ კოლბები და კოლბები დამამშვიდებელი მოდული პითონისთვის:

sudo apt-get დააინსტალირეთ python-dev python-pip

python -m pip install flask flask -restful

შემდეგი, ჩვენ დავაყენებთ პითონის ფლაკონის მოდულს, რომელიც გამოიყენება ფორმების შესაქმნელად.

pip დააინსტალირეთ flask-wtf

ნაბიჯი 5: შექმენით ფორმის კლასი

შექმენით დირექტორია, სახელწოდებით iotProject, რომ შეინახოთ თქვენი ყველა ფაილი.

sudo mkdir iot პროექტი

შექმენით პითონის ფაილი სახელწოდებით "camControl.py".

sudo nano camControl.py

ამ ფაილში ჩვენ შევქმნით ჩვენი ფორმის კლასს, რომელიც საშუალებას გვაძლევს შევქმნათ ვებ ფორმა ტექსტური ყუთებით და ჩამოსაშლელი მენიუ, რომ მომხმარებელს შეეძლოს შეცვალოს კამერის პარამეტრები, ხელით დაიწყოს/შეაჩეროს ჩანაწერი და გადაიღოს ვიდეო.

საწყისი flask_wtf იმპორტი FlaskFormfrom wtforms.validators იმპორტი მონაცემები მოთხოვნილი wtforms იმპორტი SubmitField wtforms იმპორტი შემმოწმებლები, IntegerField, BooleanField, SelectField

კლასის camFrame (FlaskForm):

videoDuration = IntegerField ('ჩაწერის დრო (წამებში)')

მგრძნობელობა = IntegerField ('მოძრაობის მგრძნობელობა (დიაპაზონი 2500-10000) n რაც უფრო მაღალია რიცხვი, მით უფრო მგრძნობიარეა კამერა', შემფასებლები = [validators. NumberRange (min = 2500, max = 10000, შეტყობინება = 'მნიშვნელობა დიაპაზონის მიღმა')])

პარამეტრები = SelectField ("პარამეტრები", არჩევანი = [("არცერთი", "არანაირი მოქმედება"), ("rec", "ჩაწერის დაწყება"), ("შეჩერება", "ჩაწერის შეწყვეტა"), ("სურათი", "გადაიღე სურათი")])

წარდგენა = SubmitField ('გაგზავნა')

ნაბიჯი 6: შექმენით ბოთლის შაბლონი

მომხმარებლის ინტერფეისის შესაქმნელად, თქვენ უნდა შეიმუშაოთ Flask შაბლონი, რომელიც იყენებს თქვენს მიერ შექმნილ ფორმას. ეს ფაილი ჩაიწერება html– ით და ინახება საქაღალდეში სახელწოდებით შაბლონები, რომელიც უნდა იყოს იმავე დირექტორიაში, როგორც თქვენი ფორმა.

შაბლონების საქაღალდის შიგნით შექმენით ფაილი სახელწოდებით index.html. ამ ფაილის შიგნით, გაიმეორეთ ზემოთ ნაჩვენები კოდი.

ნაბიჯი 7: თარგის გადაცემა

ახლა დროა შევქმნათ ფაილი, რომელიც თარგს იძლევა. შექმენით ფაილი სახელწოდებით appCam.py (დარწმუნდით, რომ შაბლონების საქაღალდეში აღარ ხართ). შაბლონში გამოყენებული ნებისმიერი დინამიური შინაარსი უნდა იქნას გამოყენებული დასახელებული არგუმენტის სახით render_template ().

იმპორტის კამერა კონტროლი ბოთლიდან იმპორტი ბოთლი, რენდ_შაბლონი, მოთხოვნა, პასუხი flask_restful იმპორტის რესურსიდან, Api, reqparse

აპლიკაცია = ბოთლი (_ სახელი_)

app.config ['SECRET_KEY'] = '13542' api = Api (აპლიკაცია)

parser = reqparse. RequestParser ()

parser.add_argument ('dur', type = int, help = 'ვიდეოს ხანგრძლივობა მოძრაობის გამოვლენისას') parser.add_argument ('sens', type = int, help = 'მოძრაობის დონე საჭიროა ჩაწერის გასააქტიურებლად') parser.add_argument ('opt', type = str, help = 'ვიდეოს ხელით ჩაწერა ან სურათის გადაღება')

კლასის განახლება (რესურსი):

#მასალა wtforms def post (self): args = parser.parse_args () #rc.input (args ['dur'], args ['sens'], args ['opt']) #ჩაწერეთ ტექსტური ფაილი ესაუბრება პარალელურ კამერაზე გაშვებულ კამერას SettingFile = ღია ("cameraSettings.txt", 'w') cameraSettingsFile.write (args ['dur'] + '\ n') #ჩაწერა dur cameraSettingsFile.write (args ['sens'] + '\ n') #დაწერეთ sens cameraSettingsFile.write (args ['opt'] + '\ n') #ჩაწერეთ opt cameraSettingsFile.close () დაბრუნება {'dur': args ['dur'], 'sens': args ['გრძნობა'], 'opt': args ['opt']}

@app.route ('/', მეთოდები = ['GET', 'POST'])

def index (): "" "კონტროლერის საწყისი გვერდი" "" ფორმა = camControl.camFrame () #ეს არის მოთხოვნის ფორმა. მეთოდი == 'POST': ამობეჭდვა (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') #წერ args [2] [1] + '\ n') #ჩაწერა opt cameraSettingsFile.close () imageDictionary = {"ფაილის სახელი": "image.jpg"} render_template დაბრუნება ('index.html', form = form, image = imageDictionary)

api.add_resource (განახლება, '/განახლება/')

თუ _name_ == '_ მთავარი_':

app.run (მასპინძელი = '0.0.0.0', პორტი = 80, გამართვა = ჭეშმარიტი, ძაფიანი = ჭეშმარიტი)

ნაბიჯი 8: შექმენით კამერის ოპერატორის კლასი

ახლა ჩვენ გვინდა შევქმნათ ფაილი სახელწოდებით camOperator.py. მასში ჩვენ გავაკეთებთ კამერის კლასს კამერის მუშაობის მეთოდებით, უკვე არსებული PiCamera ფუნქციების გამოყენებით. ჩვენ გამოვიყენებთ ამ ობიექტის მაგალითს მომდევნო ეტაპზე, სადაც ჩვენ გავაერთიანებთ კამერის ფუნქციონირებას და მოძრაობის სენსორს.

ამ კლასში განსაზღვრული მეთოდები ცვლის უსაფრთხოების კამერაზე "ჩანაწერის" პარამეტრებს მგრძნობელობისა და ხანგრძლივობის შეყვანის გამოყენებით, რასაც მომხმარებელი უზრუნველყოფს, ხოლო ამ ცვლადებისათვის ნაგულისხმევი მნიშვნელობების დადგენა, თუ მომხმარებლის შეყვანა არ არის.

იმპორტი RPi. GPIO როგორც GPIOimport დრო იმპორტი picamera საწყისი datetime იმპორტი datetime

GPIO.setmode (GPIO. BOARD)

GPIO.setup (11, GPIO. IN)

აღმოაჩინე = 0

კლასის კამერა ოპერატორი:

def _ დაწყება _ (საკუთარი თავი):

#constructor self.cam = picamera. PiCamera () self.data = self.dur = 10 self.sens = 2500 self.opt = "არცერთი"

def ჩანაწერი (self, dur):

#ჩანაწერები მოცემული ხანგრძლივობისთვის, რომელიც მითითებულია კონტროლერის მიერ 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 ოპერაცია (self, dur, sens):

#კამერის ძირითადი მოქმედება, რომელიც მუდმივად ამოწმებს, არის თუ არა ადამიანი ახლომახლო, თუ ადამიანი დიდხანს დარჩება გარშემო, ჩვენ ვიწყებთ ჩაწერას! გლობალური გამოვლენა i = GPIO.input (11) თუ i == 0: #როდესაც მოძრაობის სენსორიდან გამომავალი არის LOW გამოვლენა = 0 დრო. ძილი (0.1) elif i == 1: #როდესაც მოძრაობის სენსორიდან გამომავალი არის მაღალი ბეჭდვა (" მოძრაობა აღმოჩენილია " +str (გამოვლენა)) თუ გამოვლენილია> = sens*10: self.record (dur) print (" RECORDED ") detect = 0 time.sleep (0.1) detective += 1

ნაბიჯი 9: შექმენით ჩანაწერის მოდული

ამ პროექტისათვის საჭირო ბოლო პროგრამა ჩაწერილი იქნება ფაილში, სახელად rec.py. ეს ფაილი ეუბნება კამერას როდის ჩაწეროს, რამდენ ხანს ჩაიწეროს და თუ/როდის გადაიღოს სურათი. ის ამას აკეთებს მე –5 საფეხურიდან ტექსტური ფაილზე დაწერილი მომხმარებლის მონაცემების მუდმივი შემოწმებითა და წაკითხვით. თუ ფაილი განახლებულია, ის შესაბამისად აწესრიგებს მგრძნობელობისა და ხანგრძლივობის მნიშვნელობებს და შემდეგ, თუ ჩანაწერი ან სურათია გადაღებული, ის ინახავს შინაარსს pi,.h264 ან-j.webp

'' 'მუშაობს კოლბების სერვერის პარალელურად, კითხულობს კონტროლის ცვლადებს სერვერის ფორმებით. სერვერის კონტროლის ცვლადები მითითებულია ცალკე ფაილში ფორმების წარდგენის შემდეგ. Rec მოდული კითხულობს ამ ცვლადებს და მათზე დაყრდნობით განაახლებს კამერას. '' 'იმპორტი camOperator საწყისი datetime იმპორტი datetime იმპორტი დრო

rc = camOperator.cameraOperator ()

cameraSettingsFile = ღია ("cameraSettings.txt", 'w') cameraSettingsFile.close () #აი, ჩვენ ვხსნით და ვხურავთ ჩაწერის რეჟიმში, რათა წაშალოთ ფაილი შიგნით არსებული ძირითადი მარყუჟის დაწყებამდე

#უწყვეტი მარყუჟი, რომელიც უყურებს თუ არა ადამიანები ახლოს. თუ ისინი არიან, მაშინ

#კამერა იწყებს ჩაწერას. ეს ფუნქცია მუშაობს პარალელურად კოლბის #სერვერთან ერთად, რომელიც აკონტროლებს ამ კამერას. recordingInProcess = False while True: #შეამოწმეთ/ჩაწერეთ თუ (recordingInProcess == False): rc.operation (rc.dur, rc.sens) #შეცვალეთ კამერის პარამეტრები სერვერზე cameraSettingsFile = ღია ("cameraSettings.txt", 'r') settingNum = 0 კამერაში SettingFile.readlines (): if settingNum == 0: #ხანგრძლივობა ცვლის rc.dur = int (პარამეტრი) elif settingNum == 1: #მგრძნობელობის შეცვლა rc.sens = int (პარამეტრი) elif settingNum == 2: #ქმედების შეცვლა rc.opt = პარამეტრის პარამეტრი Num += 1 კამერა SettingFile.close ()

#შეასრულე მოქმედება

# if rc.opt == "არცერთი": # გაგრძელება თუ rc.opt == "rec / n" და recordingInProcess == ყალბი: ბეჭდვა ("ჩამწერი ბრძანების გაშვება კონტროლერისგან") # ვიდეოს სახელის გენერირება მიმდინარე დროის ვიდეოს სახელით = "snappedVid _"+str (datetime.now ()) videoName = videoName.replace (':', ') videoName = videoName.replace ('. ',') rc.cam.start_recording ('/home/pi/iotProject /videos/' + videoName +'.h264 ') recordingInProcess = ჭეშმარიტი elif rc.opt == "stop / n" and recordingInProcess == True: print ("record control command from controller") rc.cam.stop_recording () recordingInProcess = ყალბი cameraSettingsFile = ღია ("cameraSettings.txt", 'w') cameraSettingsFile.write (str (rc.dur)+'\ n') cameraSettingsFile.write (str (rc.sens)+'\ n') cameraSettingsFile ჩაწერა ("არცერთი / n") rc.opt = "არცერთი / n" elif rc.opt == "სურათი / n" და ჩაწერა InProcess == ყალბი: ამობეჭდვა ("სურათის გადაღება კონტროლერისგან") 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. ჩაწერა (str (rc.dur)+'\ n') cameraSettingsFile.write (str (rc.sens)+'\ n') cameraSettingsFile.write ("none / n") rc.opt = "none / n"

ნაბიჯი 10: ჩართეთ სერვერი

SSH pi- ში და ჩართეთ სერვერი ზემოთ ნაჩვენები ბრძანების ხაზის გამოყენებით.

ნაბიჯი 11: გამოსცადეთ

შედით ვებგვერდზე IP მისამართის გამოყენებით და თქვენ უნდა შეგეძლოთ აკონტროლოთ კამერა დისტანციურად!