Cámara de seguridad Raspberry Pi: 11 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

Este es un instructivo paso a paso sobre cómo crear una cámara de seguridad activada por movimiento de IoT usando una Raspberry Pi. Aprenderá a crear un servidor web de matraces y un formulario que le permita al usuario ajustar la sensibilidad de la cámara y el tiempo de grabación, iniciar / detener manualmente una grabación y / o tomar una foto que se guardará localmente.

Suministros

• Frambuesa pi 3
• Cámara pi
• Sensor de movimiento PIR
• tarjeta SD
• Fuente de alimentación

Paso 1: ensamble el hardware

Mientras el Pi está apagado, inserte la tarjeta micro-SD en el Pi. Inserte el cable plano del módulo de la cámara en el puerto del módulo de la cámara en el Pi. Luego, conecte los 3 pines (etiquetados VCC, OUT y GND) del detector de movimiento PRI a los pines GPIO de Pi. Conecte el VCC a 5.5V de potencia, el GND a tierra y el OUT al pin 11 en el Pi.

Paso 2: asegúrese de que su Pi esté conectado a Internet

Ahora, encienda el Pi conectándolo a una fuente de alimentación y verifique que está conectado a Internet usando el comando ping. Si no sabe cómo conectar su Pi a Internet, haga clic aquí.

sudo ping www.google.com

Si tiene éxito, debería ver que Google está recibiendo datos.

Además, puede usar ifconfig para ver su dirección IP.

sudo ifconfig

Paso 3: configura la cámara

Utilice el siguiente comando para abrir la interfaz de configuración y habilite la cámara en las "opciones de interfaz".

sudo raspi-config

Después de reiniciar, puede mostrar el estado de su cámara para asegurarse de que esté conectada correctamente.

vcgencmd get_camera

Por último, instale el módulo picamera.

pip instalar picamera

Paso 4: Instale Flask

Instale el módulo flask and flask-restful para Python:

sudo apt-get install python-dev python-pip

python -m pip instalar matraz matraz-restful

A continuación, instalaremos un módulo de matraz de Python utilizado para crear formularios.

pip instalar frasco-wtf

Paso 5: crear una clase de formulario

Cree un directorio llamado iotProject para almacenar todos sus archivos.

sudo mkdir iotProject

Cree un archivo de Python llamado "camControl.py".

sudo nano camControl.py

En este archivo crearemos nuestra clase de formulario, que nos permite crear un formulario web con cuadros de texto y un menú desplegable para que el usuario pueda cambiar la configuración de la cámara, iniciar / detener manualmente una grabación y capturar video.

desde flask_wtf importar FlaskForm desde wtforms.validators importar DataRequired desde wtforms importar SubmitField desde wtforms importar validadores, IntegerField, BooleanField, SelectField

clase camFrame (FlaskForm):

videoDuration = IntegerField ('Tiempo de grabación (en segundos)')

sensibilidad = IntegerField ('Sensibilidad al movimiento (rango 2500-10000) nCuanto mayor sea el número, menos sensible es la cámara', validators = [validators. NumberRange (min = 2500, max = 10000, message = 'Value Out of Range')])

opciones = SelectField ('Opciones', elecciones = [('ninguna', 'Sin acción'), ('rec', 'Iniciar grabación'), ('detener', 'Detener grabación'), ('foto', 'Tomar foto')])

submit = SubmitField ('Enviar')

Paso 6: Cree una plantilla de matraz

Para crear la interfaz de usuario, debe diseñar una plantilla de matraz que utilice el formulario que acaba de crear. Este archivo se escribirá en html y se almacenará en una carpeta llamada templates, que debe estar en el mismo directorio que su formulario.

Dentro de su carpeta de plantillas, cree un archivo llamado index.html. Dentro de este archivo, replique el código que se muestra arriba.

Paso 7: renderice la plantilla

Ahora es el momento de crear un archivo que represente la plantilla. Cree un archivo llamado appCam.py (asegúrese de que ya no está en la carpeta de plantillas). Cualquier contenido dinámico usado en la plantilla debe usarse como un argumento con nombre en la llamada a render_template ().

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

app = Frasco (_ nombre_)

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

analizador = reqparse. RequestParser ()

parser.add_argument ('dur', type = int, help = 'Duración del video cuando se detecta movimiento') parser.add_argument ('sens', type = int, help = 'Nivel de movimiento requerido para activar una grabación') analizador.add_argument ('opt', type = str, help = 'Grabar un video manualmente o capturar una imagen')

actualización de clase (recurso):

#Cosas para wtforms def post (self): args = parser.parse_args () # rc.input (args ['dur'], args ['sens'], args ['opt']) #escribe en el archivo de texto que habla con la cámara que se ejecuta en paralelo 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 ('/', métodos = ['OBTENER', 'PUBLICAR'])

def index (): "" "Página de inicio del controlador" "" form = camControl.camFrame () #esto es un formulario 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 (Actualización, '/ actualización /')

if _name_ == '_main_':

app.run (host = '0.0.0.0', puerto = 80, debug = True, subproceso = True)

Paso 8: crear una clase de operador de cámara

Ahora queremos crear un archivo llamado camOperator.py. En él crearemos una clase de cámara con métodos para operar la cámara, utilizando las funciones PiCamera ya disponibles. Usaremos una instancia de este objeto en el siguiente paso donde combinaremos la funcionalidad de la cámara y el sensor de movimiento.

Los métodos definidos en esta clase cambian la configuración de "grabación" en la cámara de seguridad utilizando las entradas de sensibilidad y duración que proporciona el usuario, al tiempo que establecen valores predeterminados para estas variables si la entrada del usuario no está presente.

importar RPi. GPIO como GPIOimportar tiempo importar picamera desde fecha y hora importar fecha y hora

GPIO.setmode (GPIO. BOARD)

Configuración de GPIO (11, GPIO. IN)

detectar = 0

class cameraOperator:

def _init _ (yo):

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

def record (self, dur):

#Registros para la duración determinada establecida por el controlador 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 ()

operación def (self, dur, sens):

# Operación principal de la cámara que comprueba constantemente si hay un humano cerca, si un humano permanece el tiempo suficiente, ¡comenzamos a grabar! global detect i = GPIO.input (11) if i == 0: #Cuando la salida del sensor de movimiento es BAJA detect = 0 time.sleep (0.1) elif i == 1: #Cuando la salida del sensor de movimiento es ALTA print (" movimiento detectado "+ str (detectar)) si detecta> = sens * 10: self.record (dur) print (" RECORDED ") detect = 0 time.sleep (0.1) detect + = 1

Paso 9: cree el módulo de registro

El último programa necesario para este proyecto se escribirá en un archivo llamado rec.py. Este archivo le dice a la cámara cuándo grabar, cuánto tiempo grabar y si / cuándo tomar una foto. Para ello, comprueba y lee constantemente los datos del usuario escritos en el archivo de texto desde el paso 5. Si el archivo se ha actualizado, ajusta los valores de sensibilidad y duración en consecuencia y luego, si se toma una grabación o una imagen, guarda el contenido en el pi, ya sea en formato de archivo.h264 o.jpg.

'' 'Se ejecuta en paralelo con el servidor del matraz, leyendo las variables de control establecidas por los formularios del servidor. Las variables de control del servidor se establecen en un archivo separado una vez que se envían los formularios. El módulo rec lee estas variables y actualiza la cámara basándose en ellas. '' 'importar camOperator desde fecha y hora importar fecha y hora importar hora

rc = camOperator.cameraOperator ()

cameraSettingsFile = open ("cameraSettings.txt", 'w') cameraSettingsFile.close () #aquí, abrimos y cerramos en modo de escritura para eliminar el contenido dentro del archivo antes de que se ejecute el bucle principal

#Un bucle continuo que observa para ver si hay humanos cerca. Si lo son, entonces

#la cámara comienza a grabar. Esta función se ejecuta en paralelo con el matraz #servidor que controla esta cámara. ordingInProcess = False mientras que True: # comprobar / grabar si (ordingInProcess == False): rc.operation (rc.dur, rc.sens) #cambiar la configuración de la cámara según el servidor cameraSettingsFile = open ("cameraSettings.txt", 'r') settingNum = 0 para configurar en cameraSettingsFile.readlines (): if settingNum == 0: #Duration change rc.dur = int (setting) elif settingNum == 1: #Sensitivity change rc.sens = int (setting) elif settingNum == 2: #Action change rc.opt = setting settingNum + = 1 cameraSettingsFile.close ()

# ejecutar una acción

# if rc.opt == "none": # continuar si rc.opt == "rec / n" yordingInProcess == False: print ("Ejecutando comando de grabación desde el controlador") #Generar el nombre del video basado en la hora actual videoName = "snappedVid _" + str (datetime.now ()) videoName = videoName.replace (':', ') videoName = videoName.replace ('. ',') rc.cam.start_recording ('/ home / pi / iotProject / videos / '+ videoName +'.h264 ')ordingInProcess = True elif rc.opt == "stop / n" yordingInProcess == True: print ("Deteniendo el comando de grabación desde el controlador") rc.cam.stop_recording ()ordingInProcess = Falso 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" yordingInProcess == False: print ("Tomar un comando de foto desde el controlador") 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"

Paso 10: Inicie el servidor

SSH en el pi e inicie el servidor usando la línea de comando que se muestra arriba.

Paso 11: ¡PRUEBA

Acceda a la página web utilizando la dirección IP y debería poder controlar la cámara de forma remota.