Telecamera di sicurezza Raspberry Pi: 11 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Questa è una guida passo passo su come creare una telecamera di sicurezza IoT attivata dal movimento utilizzando un Raspberry Pi. Imparerai come creare un server Web flask e un modulo che consenta all'utente di regolare la sensibilità della videocamera e il tempo di registrazione, avviare/interrompere manualmente una registrazione e/o scattare una foto che verrà salvata in locale.

Forniture

• Raspberry Pi 3
• Fotocamera Pi
• Sensore di movimento PIR
• scheda SD
• Fonte di potere

Passaggio 1: assemblare l'hardware

Mentre il Pi è spento, inserisci la scheda micro-SD nel Pi. Inserire il cavo a nastro del modulo della fotocamera nella porta del modulo della fotocamera sul Pi. Quindi, collegare i 3 pin (etichettati VCC, OUT e GND) del rilevatore di movimento PRI ai pin GPIO del Pi. Collegare il VCC a 5,5 V di alimentazione, GND a massa e OUT al pin 11 sul Pi.

Passaggio 2: assicurati che il tuo Pi sia connesso a Internet

Ora accendi il Pi collegandolo a una fonte di alimentazione e verifica di essere connesso a Internet utilizzando il comando ping. Se non sai come connettere il tuo Pi a Internet, fai clic qui.

sudo ping www.google.com

Se hai successo, dovresti vedere che i dati vengono ricevuti da Google.

Inoltre, puoi usare ifconfig per vedere il tuo indirizzo IP.

sudo ifconfig

Passaggio 3: configura la fotocamera

Utilizzare il seguente comando per aprire l'interfaccia di configurazione e abilitare la telecamera nelle "opzioni di interfaccia".

sudo raspi-config

Dopo il riavvio, puoi visualizzare lo stato della videocamera per assicurarti che sia collegata correttamente.

vcgencmd get_camera

Infine, installa il modulo picamera.

pip installa picamera

Passaggio 4: installa Flask

Installa il modulo flask e flask-restful per Python:

sudo apt-get install python-dev python-pip

python -m pip install flask flask-restful

Successivamente, installeremo un modulo flask python utilizzato per creare moduli.

pip install flask-wtf

Passaggio 5: creare una classe modulo

Crea una directory chiamata iotProject in cui archiviare tutti i tuoi file.

sudo mkdir iotProject

Crea un file Python chiamato "camControl.py".

sudo nano camControl.py

In questo file creeremo la nostra classe modulo, che ci consente di creare un modulo web con caselle di testo e un menu a discesa per consentire all'utente di modificare le impostazioni della fotocamera, avviare/interrompere manualmente una registrazione e acquisire video.

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

classe camFrame (FlaskForm):

videoDuration = IntegerField('Tempo di registrazione (in secondi)')

sensitivity = IntegerField('Motion Sensitivity (range 2500-10000)\nPiù alto è il numero, meno sensibile è la telecamera', validators=[validators. NumberRange(min=2500, max=10000, message='Value Out of Range')])

options = SelectField('Opzioni', scelte=[('none', 'Nessuna azione'), ('rec', 'Avvia registrazione'), ('stop', 'Interrompi registrazione'), ('foto', 'Scatta foto')])

submit= SubmitField('Submit')

Passaggio 6: crea un modello di pallone

Per creare l'interfaccia utente, è necessario progettare un modello Flask che utilizzi il modulo appena creato. Questo file verrà scritto in html e archiviato in una cartella chiamata modelli, che dovrebbe trovarsi nella stessa directory del modulo.

All'interno della cartella dei modelli, crea un file chiamato index.html. All'interno di questo file, replica il codice mostrato sopra.

Passaggio 7: renderizzare il modello

Ora è il momento di creare un file che esegua il rendering del modello. Crea un file chiamato appCam.py (assicurati di non essere più nella cartella dei modelli). Qualsiasi contenuto dinamico utilizzato nel modello deve essere utilizzato come argomento denominato nella chiamata a render_template().

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

app = Flask(_name_)

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

parser = reqparse. RequestParser()

parser.add_argument('dur', type=int, help='Durata del video quando viene rilevato un movimento') parser.add_argument('sens', type=int, help='Livello di movimento richiesto per attivare una registrazione') parser.add_argument('opt', type=str, help='Registra manualmente un video o acquisisci un'immagine')

aggiornamento della classe (risorsa):

#Stuff for wtforms def post(self): args = parser.parse_args() #rc.input(args['dur'], args['sens'], args['opt']) #write to the text file that parla con la telecamera in esecuzione in parallelo 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('/', method=['GET', 'POST'])

def index(): """Home page del controller""" form = camControl.camFrame() #questo è un 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(Aggiorna, '/aggiorna/')

if _name_ == '_main_':

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

Passaggio 8: creare una classe di operatore di ripresa

Ora vogliamo creare un file chiamato camOperator.py. In esso creeremo una classe fotocamera con metodi per far funzionare la fotocamera, utilizzando le funzioni PiCamera già disponibili. Utilizzeremo un'istanza di questo oggetto nel passaggio successivo in cui combineremo la funzionalità della fotocamera e del sensore di movimento.

I metodi definiti in questa classe modificano le impostazioni di "registrazione" sulla telecamera di sicurezza utilizzando gli input di sensibilità e durata forniti dall'utente, stabilendo valori predefiniti per queste variabili se l'input dell'utente non è presente.

import RPi. GPIO as GPIOimport time import picamera from datetime import datetime

GPIO.setmode(GPIO. BOARD)

GPIO.setup(11, GPIO. IN)

rilevare = 0

camera di classe Operatore:

def _init_(self):

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

def record(self, dur):

#Record per la durata specificata impostata dal 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 operazione(self, dur, sens):

#Funzionamento principale della telecamera che controlla costantemente se un essere umano è nelle vicinanze, se un umano rimane abbastanza a lungo, iniziamo a registrare! global rileva i = GPIO.input(11) if i == 0: #Quando l'output del sensore di movimento è BASSO rileva=0 time.sleep(0.1) elif i == 1: #Quando l'output del sensore di movimento è ALTO print(" movimento rilevato "+str(detect)) if rileva >= sens*10: self.record(dur) print("RECORDED") rileva = 0 time.sleep(0.1) rileva += 1

Passaggio 9: creare il modulo di registrazione

L'ultimo programma necessario per questo progetto verrà scritto in un file chiamato rec.py. Questo file indica alla fotocamera quando registrare, per quanto tempo registrare e se/quando scattare una foto. Lo fa controllando e leggendo costantemente i dati utente scritti nel file di testo dal passaggio 5. Se il file è stato aggiornato, regola i valori di sensibilità e durata di conseguenza e quindi, se viene scattata una registrazione o una foto, salva il contenuto in il pi, in un formato di file.h264 o.jpg.

'''Funziona in parallelo con il server flask, leggendo le variabili di controllo impostate dai form del server. Le variabili di controllo del server vengono impostate in un file separato una volta inviati i moduli. Il modulo rec legge queste variabili e aggiorna la telecamera in base ad esse. ''' importa camOperator da datetime import datetime import time

rc = camOperator.cameraOperator()

cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.close() #qui, apriamo e chiudiamo in modalità di scrittura per eliminare i contenuti all'interno del file prima che venga eseguito il ciclo principale

#Un ciclo continuo che controlla se gli esseri umani sono nelle vicinanze. Se lo sono, allora

#la fotocamera inizia a registrare. Questa funzione viene eseguita in parallelo con il flask #server che controlla questa telecamera. recordingInProcess = False while True: #check/record if (recordingInProcess == False): rc.operation(rc.dur, rc.sens) #cambia le impostazioni della telecamera in base al server cameraSettingsFile = open("cameraSettings.txt", 'r') settingNum = 0 per l'impostazione in cameraSettingsFile.readlines(): if settingNum == 0: #Cambia durata rc.dur = int(impostazione) elif settingNum == 1: #Modifica sensibilità rc.sens = int(impostazione) elif settingNum == 2: #Action change rc.opt = setting settingNum += 1 cameraSettingsFile.close()

#esegui un'azione

# if rc.opt == "none": # continue if rc.opt == "rec\n" e recordingInProcess == False: print("Esecuzione del comando di registrazione dal controller") #Genera il nome del video in base all'ora corrente 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" e recordingInProcess == True: print("Stop al comando di registrazione dal controller") rc.cam.stop_recording() recordingInProcess = False 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" e recordingInProcess == 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"

Passaggio 10: avviare il server

SSH nel pi e avvia il server utilizzando la riga di comando mostrata sopra.

Passaggio 11: PROVALO

Accedi alla pagina web utilizzando l'indirizzo IP e dovresti essere in grado di controllare la telecamera da remoto!