Câmera de segurança Raspberry Pi: 11 etapas (com fotos)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Este é um passo a passo instrutivo sobre como criar uma IoT, câmera de segurança ativada por movimento usando um Raspberry Pi. Você aprenderá a criar um servidor web de frasco e um formulário que permite ao usuário ajustar a sensibilidade da câmera e o tempo de gravação, iniciar / parar manualmente uma gravação e / ou tirar uma foto que será salva localmente.

Suprimentos

• Raspberry Pi 3
• Câmera pi
• Sensor de movimento PIR
• cartão SD
• Fonte de energia

Etapa 1: montar o hardware

Enquanto o Pi está desligado, insira o cartão micro-SD no Pi. Insira o cabo de fita do módulo da câmera na porta do módulo da câmera no Pi. Em seguida, conecte os 3 pinos (identificados como VCC, OUT e GND) do detector de movimento PRI aos pinos GPIO do Pi. Conecte o VCC a 5,5 V de alimentação, o GND ao aterramento e o OUT ao pino 11 no Pi.

Etapa 2: certifique-se de que seu Pi esteja conectado à Internet

Agora, ligue o Pi conectando-o a uma fonte de alimentação e verifique se você está conectado à internet usando o comando ping. Se você não sabe como conectar seu Pi à internet, clique aqui.

sudo ping www.google.com

Se você for bem-sucedido, verá que os dados estão sendo recebidos pelo google.

Além disso, você pode usar ifconfig para ver seu endereço IP.

sudo ifconfig

Etapa 3: configurar a câmera

Use o seguinte comando para abrir a interface de configuração e habilitar a câmera nas "opções de interface".

sudo raspi-config

Após a reinicialização, você pode exibir o status da câmera para garantir que ela esteja conectada corretamente.

vcgencmd get_camera

Por último, instale o módulo picamera.

pip install picamera

Etapa 4: Instale o Flask

Instale o módulo flask e flask-restful para Python:

sudo apt-get install python-dev python-pip

python -m pip install flask flask-restful

A seguir, instalaremos um módulo python flask usado para criar formulários.

pip install flask-wtf

Etapa 5: Criar uma classe de formulário

Faça um diretório chamado iotProject para armazenar todos os seus arquivos.

sudo mkdir iotProject

Crie um arquivo python chamado "camControl.py".

sudo nano camControl.py

Neste arquivo criaremos nossa classe de formulário, que nos permite criar um formulário web com caixas de texto e um menu suspenso para que o usuário possa alterar as configurações da câmera, iniciar / parar manualmente uma gravação e capturar vídeo.

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

classe camFrame (FlaskForm):

videoDuration = IntegerField ('Tempo de gravação (em segundos)')

sensibilidade = IntegerField ('Sensibilidade de movimento (intervalo 2500-10000) n Quanto maior o número, menos sensível é a câmera', validadores = [validators. NumberRange (min = 2500, max = 10000, mensagem = 'Valor fora do intervalo')])

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

submit = SubmitField ('Enviar')

Etapa 6: crie um modelo de frasco

Para criar a interface do usuário, você deve projetar um modelo do Flask que use o formulário que você acabou de criar. Este arquivo será escrito em html e armazenado em uma pasta chamada templates, que deve estar no mesmo diretório do seu formulário.

Dentro da pasta de modelos, crie um arquivo chamado index.html. Dentro desse arquivo, replique o código mostrado acima.

Etapa 7: renderizar o modelo

Agora é hora de criar um arquivo que renderiza o modelo. Crie um arquivo chamado appCam.py (certifique-se de não estar mais na pasta de modelos). Qualquer conteúdo dinâmico usado no modelo deve ser usado como um argumento nomeado na chamada para 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 = 'Duração do vídeo quando o movimento é detectado') parser.add_argument ('sens', type = int, help = 'Nível de movimento necessário para acionar uma gravação') parser.add_argument ('opt', type = str, help = 'Gravar manualmente um vídeo ou capturar uma imagem')

classe Update (Recurso):

#Stuff for wtforms def post (self): args = parser.parse_args () # rc.input (args ['dur'], args ['sens'], args ['opt']) # grava no arquivo de texto que fala com a câmera em execução paralela 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 ['sentido'], 'opt': args ['opt']}

@ app.route ('/', methods = ['GET', 'POST'])

def index (): "" "Página inicial do controlador" "" form = camControl.camFrame () # este é um formulário 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', porta = 80, debug = True, threaded = True)

Etapa 8: Criar uma classe de operador de câmera

Agora queremos criar um arquivo chamado camOperator.py. Nele faremos uma classe de câmeras com métodos para operar a câmera, utilizando as funções do PiCamera já disponíveis. Usaremos uma instância desse objeto na próxima etapa, onde combinaremos a funcionalidade da câmera e do sensor de movimento.

Os métodos definidos nesta classe alteram as configurações de "registro" na câmera de segurança usando as entradas de sensibilidade e duração que o usuário fornece, enquanto estabelecem valores padrão para essas variáveis se a entrada do usuário não estiver presente.

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

GPIO.setmode (GPIO. BOARD)

GPIO.setup (11, GPIO. IN)

detect = 0

classe cameraOperator:

def _init _ (self):

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

registro def (self, dur):

#Records para a duração fornecida definida pelo 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 ()

operação def (self, dur, sens):

# Operação principal da câmera que verifica constantemente se um humano está por perto, se um humano ficar por perto por tempo suficiente, começamos a gravar! detecção global i = GPIO.input (11) se i == 0: #Quando a saída do sensor de movimento é BAIXA detectar = 0 time.sleep (0,1) elif i == 1: #Quando a saída do sensor de movimento é HIGH print (" movimento detectado "+ str (detectar)) se detectar> = sens * 10: self.record (dur) print (" RECORDED ") detectar = 0 tempo.sono (0,1) detectar + = 1

Etapa 9: Criar o Módulo de Registro

O último programa necessário para este projeto será escrito em um arquivo denominado rec.py. Este arquivo informa à câmera quando gravar, por quanto tempo gravar e se / quando tirar uma foto. Ele faz isso verificando e lendo constantemente os dados do usuário gravados no arquivo de texto a partir da etapa 5. Se o arquivo foi atualizado, ele ajusta os valores de sensibilidade e duração de acordo e, em seguida, se uma gravação ou foto for tirada, ele salva o conteúdo em o pi, em um formato de arquivo.h264 ou.jpg.

'' 'Roda em paralelo com o servidor do flask, lendo as variáveis de controle definidas pelos formulários do servidor. As variáveis de controle do servidor são definidas em um arquivo separado assim que os formulários são enviados. O módulo rec lê essas variáveis e atualiza a câmera com base nelas. '' 'import camOperator from datetime import datetime import time

rc = camOperator.cameraOperator ()

cameraSettingsFile = open ("cameraSettings.txt", 'w') cameraSettingsFile.close () #aqui, abrimos e fechamos no modo de gravação para excluir o conteúdo do arquivo antes que o loop principal seja executado

#Um ciclo contínuo que observa para ver se há humanos por perto. Se forem, então

#a câmera começa a gravar. Esta função é executada em paralelo com o frasco #server que controla esta câmera. ordingInProcess = False enquanto True: # check / record if (recordingInProcess == False): rc.operation (rc.dur, rc.sens) #change as configurações da câmera com base no servidor cameraSettingsFile = open ("cameraSettings.txt", 'r') settingNum = 0 para configuração em cameraSettingsFile.readlines (): if settingNum == 0: #Alteração de duração rc.dur = int (configuração) elif settingNum == 1: #Alteração de sensibilidade rc.sens = int (configuração) elif settingNum == 2: #Action change rc.opt = setting settingNum + = 1 cameraSettingsFile.close ()

#execute uma ação

# if rc.opt == "none": # continue if rc.opt == "rec / n" and recordingInProcess == False: print ("Executando o comando de gravação do controlador") #Gere o nome do vídeo com base na hora atual 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 ("Parando o comando de gravação do controlador") rc.cam.stop_recording () recordingInProcess = 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" and recordingInProcess == False: print ("Capture um comando de imagem do controlador") pictureName = "snappedPic_ "+ str (datetime.now ()) imagemNome = imagemNome.replace (':', ') imagemNome = imagemNome.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 ("nenhum / n") rc.opt = "nenhum / n"

Etapa 10: iniciar o servidor

SSH no pi e inicie o servidor usando a linha de comando mostrada acima.

Etapa 11: EXPERIMENTE

Acesse a página da web usando o endereço IP e você poderá controlar a câmera remotamente!