Kamera bezpieczeństwa Raspberry Pi: 11 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:28

Jest to instrukcja krok po kroku, jak stworzyć kamerę bezpieczeństwa IoT aktywowaną ruchem za pomocą Raspberry Pi. Dowiesz się, jak stworzyć serwer sieciowy kolby i formularz, który pozwoli użytkownikowi dostosować czułość kamery i czas nagrywania, ręcznie rozpocząć/zatrzymać nagrywanie i/lub zrobić zdjęcie, które zostanie zapisane lokalnie.

Kieszonkowe dzieci

• Raspberry Pi 3
• Kamera Pi
• Czujnik ruchu PIR
• karta SD
• Źródło prądu

Krok 1: Złóż sprzęt

Gdy Pi jest wyłączone, włóż kartę micro-SD do Pi. Włóż kabel taśmowy modułu kamery do portu modułu kamery w Pi. Następnie podłącz 3 piny (oznaczone VCC, OUT i GND) detektora ruchu PRI do pinów GPIO Pi. Podłącz VCC do 5,5 V zasilania, GND do masy, a OUT do styku 11 na Pi.

Krok 2: Upewnij się, że Twoje Pi jest połączone z Internetem

Teraz włącz Pi, podłączając go do źródła zasilania i sprawdź, czy masz połączenie z Internetem za pomocą polecenia ping. Jeśli nie wiesz, jak podłączyć swoje Pi do Internetu, kliknij tutaj.

sudo ping www.google.com

Jeśli odniesiesz sukces, powinieneś zobaczyć, że dane są odbierane przez google.

Dodatkowo możesz użyć ifconfig, aby zobaczyć swój adres IP.

sudo ifconfig

Krok 3: Skonfiguruj kamerę

Użyj następującego polecenia, aby otworzyć interfejs konfiguracyjny i włączyć kamerę w „opcjach interfejsu”.

sudo raspi-config

Po ponownym uruchomieniu możesz wyświetlić stan kamery, aby upewnić się, że jest prawidłowo podłączona.

vcgencmd get_camera

Na koniec zainstaluj moduł picamera.

pip zainstaluj picamera

Krok 4: Zainstaluj kolbę

Zainstaluj moduł flask and flask-restful dla Pythona:

sudo apt-get zainstaluj python-dev python-pip

python -m pip zainstaluj kolbę kolbę-spokojny

Następnie zainstalujemy moduł python flask służący do tworzenia formularzy.

pip zainstalować kolbę-wtf

Krok 5: Utwórz klasę formularza

Utwórz katalog o nazwie iotProject, w którym będą przechowywane wszystkie pliki.

sudo mkdir iotProject

Utwórz plik Pythona o nazwie „camControl.py”.

sudo nano camControl.py

W tym pliku utworzymy naszą klasę formularza, która pozwoli nam stworzyć formularz internetowy z polami tekstowymi i rozwijanym menu, aby użytkownik mógł zmieniać ustawienia kamery, ręcznie uruchamiać/zatrzymywać nagrywanie i przechwytywać wideo.

from flask_wtf import FlaskFormfrom wtforms.validators import DataRequired z wtforms import SubmitField z wtforms import walidatorów, IntegerField, BooleanField, SelectField

klasa camFrame(FlaskForm):

videoDuration = IntegerField('Czas nagrywania (w sekundach)')

czułość = IntegerField('Czułość ruchu (zakres 2500-10000)\nIm wyższa liczba, tym mniej czuła kamera', validators=[validators. NumberRange(min=2500, max=10000, message='Wartość poza zakresem')])

options = SelectField('Opcje', choices=[('brak', 'Brak działania'), ('nagrywanie', 'Rozpocznij nagrywanie'), ('zatrzymaj', 'Zatrzymaj nagrywanie'), ('pic', 'Zrób zdjęcie')])

submit= PrześlijField('Prześlij')

Krok 6: Utwórz szablon kolby

Aby stworzyć interfejs użytkownika, musisz zaprojektować szablon Flask, który wykorzystuje właśnie utworzony formularz. Ten plik zostanie napisany w html i przechowywany w folderze o nazwie szablony, który powinien znajdować się w tym samym katalogu, co formularz.

W folderze szablonów utwórz plik o nazwie index.html. W tym pliku zreplikuj kod pokazany powyżej.

Krok 7: Renderuj szablon

Teraz nadszedł czas na stworzenie pliku, który renderuje szablon. Utwórz plik o nazwie appCam.py (upewnij się, że nie znajdujesz się już w folderze szablonów). Każda zawartość dynamiczna użyta w szablonie musi być użyta jako nazwany argument w wywołaniu funkcji render_template().

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

aplikacja = Kolba(_nazwa_)

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

parser = reqparse. RequestParser()

parser.add_argument('dur', type=int, help='Czas trwania wideo po wykryciu ruchu') parser.add_argument('sens', type=int, help='Poziom ruchu wymagany do wyzwolenia nagrywania') parser.add_argument('opt', type=str, help='Ręcznie nagraj wideo lub przechwyć obraz')

Aktualizacja klasy (zasób):

#Rzeczy dla wtforms def post(self): args = parser.parse_args() #rc.input(args['dur'], args['sens'], args['opt']) #zapisz do pliku tekstowego, który rozmawia z kamerą działającą równolegle 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(): """Strona główna kontrolera""" form = camControl.camFrame() #to jest formularz 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 (Aktualizacja, '/aktualizacja/')

if _name_ == '_main_':

app.run(host='0.0.0.0', port =80, debug=prawda, wątki=prawda)

Krok 8: Utwórz klasę operatora kamery

Teraz chcemy stworzyć plik o nazwie camOperator.py. W nim stworzymy klasę kamery z metodami obsługi kamery, wykorzystując już dostępne funkcje PiCamera. Wykorzystamy instancję tego obiektu w kolejnym kroku, gdzie połączymy funkcjonalność kamery i czujnika ruchu.

Metody zdefiniowane w tej klasie zmieniają ustawienia „nagrywania” w kamerze bezpieczeństwa przy użyciu wprowadzonych przez użytkownika danych wejściowych dotyczących czułości i czasu trwania, jednocześnie ustalając wartości domyślne dla tych zmiennych, jeśli dane wejściowe użytkownika nie są dostępne.

importuj RPi. GPIO jako GPIOimportuj czas importuj picamera z datetime import datetime

GPIO.setmode(GPIO. BOARD)

Konfiguracja. GPIO(11, GPIO. IN)

wykryj = 0

kamera klasy Operator:

def _init_(self):

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

rekord def(własny, czas trwania):

#Rekordy przez określony czas ustawiony przez kontroler videoName = str(datetime.now()) videoName = videoName.replace(':', ') videoName = videoName.replace('.', ') self.cam.start_recording('/home/pi/iotProject/videos/'+ nazwa_filmu + '.h264') time.sleep(dur) self.cam.stop_recording()

def operacja (self, dur, sens):

#Główne działanie kamery, która stale sprawdza, czy w pobliżu jest człowiek, jeśli człowiek zostanie wystarczająco długo, rozpoczynamy nagrywanie! global detection i = GPIO.input(11) if i == 0: #Kiedy sygnał wyjściowy z czujnika ruchu jest LOW detection=0 time.sleep(0.1) elif i == 1: #Gdy sygnał wyjściowy z czujnika ruchu jest HIGH print(" wykryto ruch "+str(detect)) jeśli wykryj >= sens*10: self.record(dur) print("RECORDED") wykryj = 0 time.sleep(0.1) wykryj += 1

Krok 9: Utwórz moduł nagrywania

Ostatni program potrzebny do tego projektu zostanie zapisany w pliku o nazwie rec.py. Ten plik informuje aparat, kiedy nagrywać, jak długo nagrywać i czy/kiedy zrobić zdjęcie. Czyni to poprzez ciągłe sprawdzanie i odczytywanie danych użytkownika zapisanych w pliku tekstowym z kroku 5. Jeśli plik został zaktualizowany, odpowiednio dostosowuje wartości czułości i czasu trwania, a następnie, jeśli jest robione nagranie lub zdjęcie, zapisuje zawartość do pi, w formacie.h264 lub.jpg.

'''Uruchamia równolegle z serwerem kolby, odczytując zmienne sterujące ustawione przez formularze serwera. Zmienne kontrolne serwera są ustawiane w osobnym pliku po przesłaniu formularzy. Moduł rec odczytuje te zmienne i na ich podstawie aktualizuje kamerę. ''' importuj camOperator z datetime import datetime import time

rc = OperatorKamery. OperatorKamery()

cameraSettingsFile = open("cameraSettings.txt", 'w') cameraSettingsFile.close() #tutaj otwieramy i zamykamy w trybie zapisu, aby usunąć zawartość pliku przed uruchomieniem głównej pętli

#Ciągła pętla, która obserwuje, czy ludzie są w pobliżu. Jeśli tak, to

#kamera rozpoczyna nagrywanie. Ta funkcja działa równolegle z serwerem kolby #, który steruje tą kamerą. recordInProcess = False while True: #check/record if (recordingInProcess == False): rc.operation(rc.dur, rc.sens) #zmień ustawienia kamery na podstawie serwera cameraSettingsFile = open("cameraSettings.txt", 'r') settingNum = 0 dla ustawienia w cameraSettingsFile.readlines(): if settingNum == 0: #Zmiana czasu trwania rc.dur = int(setting) elif settingNum == 1: #Zmiana czułości rc.sens = int(setting) elif settingNum == 2: #Action change rc.opt = setting settingNum += 1 cameraSettingsFile.close()

#wykonaj akcję

# if rc.opt == "none": # Continue if rc.opt == "rec\n" and recordingInProcess == False: print("Uruchamianie polecenia nagrywania z kontrolera") #Generuj nazwę wideo na podstawie bieżącego czasu 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" and recordingInProcess == True: print("Zatrzymywanie polecenia nagrywania z kontrolera") rc.cam.stop_recording() recordingInProcess = Fałsz 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("Zrób zdjęcie z kontrolera") 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("brak\n") rc.opt = "brak\n"

Krok 10: Uruchom serwer

SSH do pi i uruchom serwer za pomocą wiersza poleceń pokazanego powyżej.

Krok 11: WYPRÓBUJ

Wejdź na stronę internetową za pomocą adresu IP i powinieneś mieć możliwość zdalnego sterowania kamerą!