描述

一、簡介：-

歡迎大家來我的項目。首先，我想說我們生活在互聯網世界中，開發和實踐新想法比以前更容易。我們可以很容易地開發出任何可以為我們提供更好的生活水平，也可以幫助社會并給世界帶來巨大影響的模型。

如今，許多行業和許多人都大量使用安全系統來獲得更好的安全性。由于對高度穩定的安全系統的需求不斷增加，許多公司準備投資這個市場以提高可靠性和可擴展性。在這里，我的項目是創建一個安全系統，該系統主要包含兩個不同的模塊，基于哪個系統工作：

• 圖像識別
• 聲音識別（文本和語音識別）

這兩個模塊將由 BOLT IoT 和 Arduino 設備控制，當兩個模塊都正確識別一個人時，它允許他們鎖定或解鎖任何設備。在這里，我正在開發一個可以在任何設備上實現的原型，即鎖定或解鎖桌面上的任何門或文件夾或任何用戶或客戶想要的任何東西。由于我們的安全系統包含鎖定和解鎖部分；對于解鎖部分，我將使用一個 LED，當兩個模塊完美識別一個人時它會發光，這意味著系統已解鎖，否則將保持關閉狀態。并且為了顯示鎖定部分，當系統解鎖時，即當LED發光時，系統再次識別人，如果所有模塊都識別人，則系統將被鎖定并且它可以用Led顯示，即 它將被關閉。在這里，我們還將為用戶創建一個 GUI，以決定他們是要鎖定還是解鎖系統。GUI 中有兩個按鈕供用戶選擇是否要解鎖系統或鎖定系統。可以用任何東西代替 LED，但代碼和實現保持不變。此外，如果用戶試圖解鎖一個已經打開的設備，那么系統將提示該設備已經解鎖，并保持鎖定機制。

在這里，很多人都會有一個問題，為什么我們需要再次識別鎖定系統的人。因此，我這樣做是為了提供一些額外的安全性，以便在實施該系統的任何設備上，用戶都可以在整個過程中感到安全，并且可以相信沒有人可以在未經他許可的情況下解鎖或鎖定任何設備。

似乎是一個令人興奮的項目，對！所以讓我們開始吧。

注意：-我目前沒有伺服電機，所以我使用 LED 來證明打開和關閉的目的。

2. 基本軟件設置：

2.1 窗口：

由于我們在 Windows 上執行所有操作，因此我們需要在繼續之前對其進行設置。首先，我們應該在我們的系統上運行 python，如果沒有，下載并在您的系統中安裝 python。之后，我們需要安裝 bolt iot 包來使用 pip 命令訪問 windows 中的 bolt 設備。

pip install boltiot

完成此操作后，我們還需要安裝其他包來運行我們的代碼，即 dlib 包、人臉識別包、termcolor、matplotlib、opencv 和 sklearn 包。可以使用 pip 命令安裝所有軟件包，后跟安裝和軟件包名稱。例如：

pip install dlib

用戶還必須在您的系統中安裝 pyqt 工具。這個 pyqt 工具支持 python，將用于為用戶創建 GUI。

2.2 Bolt-IoT API 密鑰

在這里，Bolt-IoT 用于管理所有任務，如果有任何入侵者，向用戶或所有者發送短信。它也有自己的云平臺。

要獲取 Bolt API 密鑰，請單擊菜單中的 API，您將找到您的 API 密鑰。您還可以重新生成 API 密鑰或復制生成的密鑰并妥善保管以供日后使用。還要保存您將在主窗口中看到的唯一 Bolt id。這兩個數據稍后可用于向用戶發送短信或通過 Internet 訪問您的 Bolt 設備。

2.3 暮光之城：

Twilio 用于從遠程服務器向所有者發送短信。因此，當任何入侵者試圖訪問安全系統時，我們將使用此服務通知安全系統的所有者。我們可以利用 python 對設備進行編程，借助 Bolt 設備和 Twilio 帳戶的 API 密鑰向用戶發送短信。您可以訪問https://www.twilio.com/開設 Twilio 帳戶

您可以使用帳戶 SID 和帳戶令牌等 Twilio 內容，通過儀表板上顯示的手機號碼通過 Internet 發送短信。

上圖 - 2 代表 Twilio 儀表板，您可以從中獲取通過 Internet 向所需人員發送短信所需的信息。

3. 開發軟件：

由于我們的軟件太大，我們將把它分解成不同的模塊，逐步了解每個模塊是如何構建的以及它們是如何工作的。

3.1 人臉識別模塊：

在這里，對于人臉識別，我將使用 opencv、深度學習和 python。在這里，我們不是試圖輸出圖像的單個標簽，而是輸出一個實值特征向量。對于我們正在創建的 dlib 面部識別模塊，輸出特征向量是 128-d，即用于量化面部的 128 個實數值的列表。使用三元組訓練網絡。所以在這里，我們需要大量的數據集，其中包含將被允許訪問安全系統的人的圖像。然后將使用 SVM 方法對這些數據集中的圖像進行訓練。我們將在項目的主要部分中使用這些經過訓練的數據集來識別人臉。讓我們看一個示例圖像：

通過深度度量學習進行面部識別涉及“三元組訓練步驟”。三元組由 3 個獨特的人臉圖像組成——3 個中的 2 個是同一個人。神經網絡為 3 個人臉圖像中的每一個生成一個 128 維向量。對于同一個人的兩張人臉圖像，我們通過距離度量調整神經網絡權重以使向量更接近。

這里我們向網絡提供三張圖片：

• 其中兩個圖像是同一個人的示例面孔。
• 第三張圖片是我們數據集中的一張隨機人臉，與其他兩張圖片不是同一個人。

作為示例，讓我們再次考慮上圖 -3，其中我們提供了三張圖像：一張是 Chad Smith，兩張是 Will Ferrell。我們的網絡對人臉進行量化，為每個人臉構建 128 維嵌入（量化）。從那里開始，一般的想法是我們將調整我們的神經網絡的權重，以便兩個 Will Ferrel 的 128 維測量值將彼此更接近并且遠離 Chad Smith 的測量值。

我們的人臉識別模塊基于 CNN（卷積神經網絡）。

如上圖所示，您可以看到我創建的包含三個文件夾的數據集。每個文件夾都包含將被訓練的那些人的一些圖像。

上圖 - 5 顯示了用于創建人臉識別系統的文件。encodes_faces python 文件包含用于訓練數據集的代碼。正確訓練數據集后，它將創建一個encodings.pickle文件，其中包含每個人臉的人臉結構和關鍵值，用于驗證實時人臉并提供授權訪問等。每當我們想要識別新面孔以授予權限時，recognize_faces_image python 文件都會運行。它將創建新驗證人臉的 128 維向量，并將其與經過訓練的數據集文件匹配以授予權限。下面提供了訓練數據集的完整代碼。

# import the necessary packages
from imutils import paths
import face_recognition
import argparse
import pickle
import cv2
import os

# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--dataset", required=True,
	help="path to input directory of faces + images")
ap.add_argument("-e", "--encodings", required=True,
	help="path to serialized db of facial encodings")
ap.add_argument("-d", "--detection-method", type=str,,
	help="face detection model to use: either `hog` or `cnn`")
args = vars(ap.parse_args())

# grab the paths to the input images in our dataset
print("[INFO] quantifying faces...")
imagePaths = list(paths.list_images(args["dataset"]))

# initialize the list of known encodings and known names
knownEncodings = []
knownNames = []

# loop over the image paths
for (i, imagePath) in enumerate(imagePaths):
	# extract the person name from the image path
	print("[INFO] processing image {}/{}".format(i + 1,
		len(imagePaths)))
	name = imagePath.split(os.path.sep)[-2]

	# load the input image and convert it from RGB (OpenCV ordering)
	# to dlib ordering (RGB)
	image = cv2.imread(imagePath)
	rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

	# detect the (x, y)-coordinates of the bounding boxes
	# corresponding to each face in the input image
	boxes = face_recognition.face_locations(rgb,
		model=args["detection_method"])

	# compute the facial embedding for the face
	encodings = face_recognition.face_encodings(rgb, boxes)

	# loop over the encodings
	for encoding in encodings:
		# add each encoding + name to our set of known names and
		# encodings
		knownEncodings.append(encoding)
		knownNames.append(name)

# dump the facial encodings + names to disk
print("[INFO] serializing encodings...")
data = {"encodings": knownEncodings, "names": knownNames}
f = open(args["encodings"], "wb")
f.write(pickle.dumps(data))
f.close()

一旦我們訓練了我們的數據集，它將如上所述創建.pickle 文件。代碼中給出的注釋將指導我們出于什么目的使用了代碼或語句的哪一部分。

上圖 6 顯示了訓練圖像的過程。這將需要很長時間，具體取決于您的數據集圖像大小以及數據集中的圖像總數。接下來，我們將運行識別人臉代碼以在 python 中識別人臉。

# import the necessary packages
import face_recognition
import argparse
import pickle
import cv2

# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-e", "--encodings", required=True,
	help="path to serialized db of facial encodings")
ap.add_argument("-i", "--image", required=True,
	help="path to input image")
ap.add_argument("-d", "--detection-method", type=str,,
	help="face detection model to use: either `hog` or `cnn`")
args = vars(ap.parse_args())

# load the known faces and embeddings
print("[INFO] loading encodings...")
data = pickle.loads(open(args["encodings"], "rb").read())

# load the input image and convert it from BGR to RGB
image = cv2.imread(args["image"])
rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# detect the (x, y)-coordinates of the bounding boxes corresponding
# to each face in the input image, then compute the facial embeddings
# for each face
print("[INFO] recognizing faces...")
boxes = face_recognition.face_locations(rgb,
	model=args["detection_method"])
encodings = face_recognition.face_encodings(rgb, boxes)

# initialize the list of names for each face detected
names = []

# loop over the facial embeddings
for encoding in encodings:
	# attempt to match each face in the input image to our known
	# encodings
	matches = face_recognition.compare_faces(data["encodings"],
		encoding)
	name = "Unknown"

	# check to see if we have found a match
	if True in matches:
		# find the indexes of all matched faces then initialize a
		# dictionary to count the total number of times each face
		# was matched
		matchedIdxs = [i for (i, b) in enumerate(matches) if b]
		counts = {}
		# loop over the matched indexes and maintain a count for
		# each recognized face face
		for i in matchedIdxs:
			name = data["names"][i]
			counts[name] = counts.get(name, 0) + 1
			print (counts)
		key_max = max(counts.keys(), key=(lambda k: counts[k]))
		print (counts[key_max])
		
		# determine the recognized face with the largest number of
		# votes (note: in the event of an unlikely tie Python will
		# select first entry in the dictionary)
		
		a = counts[key_max]-8 #adjust this number 8 as per ur dataset
		if (a==0):
			name = max(counts, key=counts.get)
		else:
			name = "Unknown"
		
	# update the list of names
	names.append(name)

# loop over the recognized faces
for ((top, right, bottom, left), name) in zip(boxes, names):
	# draw the predicted face name on the image
	cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2)
	y = top - 15 if top - 15 > 15 else top + 15
	cv2.putText(image, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
		0.75, (0, 255, 0), 2)

# show the output image
cv2.imshow("Image", image)
cv2.waitKey(0)

訓練數據后，我們將僅在項目中使用 .pickle 文件和識別人臉 python 文件以供進一步使用。代碼中給出的注釋將幫助我們更好地理解代碼。

3.2 音頻識別：

在這里，在音頻識別方面，我們遵循了與 Shazam 大致相同的概念。在這里，我們還將存儲一些我們想要驗證音頻的用戶的 mp3。然后，我們將訓練這些 mp3 文件來存儲 mp3 文件的一些指紋，例如音高、音調等。在這里，我們按照傅里葉變換算法來完成任務。一旦我們訓練并記錄了一些數據集的指紋以用于匹配目的，我們將運行我們的主要代碼來識別來自麥克風的音頻并將其與我們訓練的數據集進行匹配，如果匹配，我們將提供授權訪問。

首先，我們將創建并存儲一些需要匹配語音的用戶的 mp3 文件。

然后我們將使用下面提供的代碼從每個音頻文件中識別或收集一些重要的指紋。

import os
from termcolor import colored
import libs.fingerprint as fingerprint
from libs.config import get_config
from libs.db_sqlite import SqliteDatabase
from libs.reader_file import FileReader

if __name__ == '__main__':
    config = get_config()
    db = SqliteDatabase()
    path = "mp3/"
    # fingerprint all files in a directory
    for filename in os.listdir(path):
        if filename.endswith(".mp3"):
            reader = FileReader(path + filename)
            audio = reader.parse_audio()

            song = db.get_song_by_filehash(audio['file_hash'])
            song_id = db.add_song(filename, audio['file_hash'])

            msg = ' * %s %s: %s' % (
                colored('id=%s', 'white', attrs=['dark']),  # id
                colored('channels=%d', 'white', attrs=['dark']),  # channels
                colored('%s', 'white', attrs=['bold'])  # filename
            )
            print(msg % (song_id, len(audio['channels']), filename))

            if song:
                hash_count = db.get_song_hashes_count(song_id)

                if hash_count > 0:
                    msg = '   already exists (%d hashes), skip' % hash_count
                    print(colored(msg, 'red'))

                    continue

            print(colored('   new song, going to analyze..', 'green'))

            hashes = set()
            channel_amount = len(audio['channels'])

            for channeln, channel in enumerate(audio['channels']):
                msg = '   fingerprinting channel %d/%d'
                print(colored(msg, attrs=['dark']) % (channeln + 1, channel_amount))

                channel_hashes = fingerprint.fingerprint(channel, Fs=audio['Fs'],
                                                         plots=config['fingerprint.show_plots'])
                channel_hashes = set(channel_hashes)

                msg = '   finished channel %d/%d, got %d hashes'
                print(colored(msg, attrs=['dark']) % (channeln + 1, channel_amount, len(channel_hashes)))

                hashes |= channel_hashes

            msg = '   finished fingerprinting, got %d unique hashes'

            values = []
            for hash, offset in hashes:
                values.append((song_id, hash, offset))

            msg = '   storing %d hashes in db' % len(values)
            print(colored(msg, 'green'))

            db.store_fingerprints(values)

    print('end')

一旦收集了所有文件的指紋，它將創建一個config.json文件，其中包含所有音頻的所有指紋。

注意：- 注釋有助于更好地理解代碼的不同部分。

上圖 7 顯示了從我們數據集中存儲的每個音頻中收集指紋的片段。接下來，我們將運行另一個 python 代碼來識別通過麥克風輸入的實時聲音。下面的代碼片段說明了用于該目的的代碼。

import argparse
import sys
from argparse import RawTextHelpFormatter
from itertools import zip_longest as izip_longest
from termcolor import colored
import libs.fingerprint as fingerprint
from libs.config import get_config
from libs.db_sqlite import SqliteDatabase
from libs.reader_microphone import MicrophoneReader
from libs.visualiser_console import VisualiserConsole as visual_peak
from libs.visualiser_plot import VisualiserPlot as visual_plot

def align_matches(matches):
    diff_counter = {}
    largest = 0
    largest_count = 0
    song_id = -1

    for tup in matches:
        sid, diff = tup

        if diff not in diff_counter:
            diff_counter[diff] = {}

        if sid not in diff_counter[diff]:
            diff_counter[diff][sid] = 0

        diff_counter[diff][sid] += 1

        if diff_counter[diff][sid] > largest_count:
            largest = diff
            largest_count = diff_counter[diff][sid]
            song_id = sid

    songM = db.get_song_by_id(song_id)

    nseconds = round(float(largest) / fingerprint.DEFAULT_FS *
                     fingerprint.DEFAULT_WINDOW_SIZE *
                     fingerprint.DEFAULT_OVERLAP_RATIO, 5)

    return {
        "SONG_ID": song_id,
        "SONG_NAME": songM[1],
        "CONFIDENCE": largest_count,
        "OFFSET": int(largest),
        "OFFSET_SECS": nseconds
    }


def grouper(iterable, n, fillvalue=None):
    args = [iter(iterable)] * n
    return (filter(None, values)
            for values in izip_longest(fillvalue=fillvalue, *args))


def find_matches(samples, Fs=fingerprint.DEFAULT_FS):
    hashes = fingerprint.fingerprint(samples, Fs=Fs)
    return return_matches(hashes)


def return_matches(hashes):
    mapper = {}
    for hash, offset in hashes:
        mapper[hash.upper()] = offset
    values = mapper.keys()

    for split_values in map(list, grouper(values, 1000)):
        # @todo move to db related files
        query = """
    SELECT upper(hash), song_fk, offset
    FROM fingerprints
    WHERE upper(hash) IN (%s)
  """
        query = query % ', '.join('?' * len(split_values))

        x = db.executeAll(query, split_values)
        matches_found = len(x)
        print(x)

        if matches_found > 0:
            msg = '   ** found %d hash matches (step %d/%d)'
            print(colored(msg, 'green') % (
                matches_found,
                len(split_values),
                len(values)
            ))
        else:
            msg = '   ** not matches found (step %d/%d)'
            print(colored(msg, 'red') % (len(split_values), len(values)))

        for hash_code, sid, offset in x:
            # (sid, db_offset - song_sampled_offset)
            print(sid)
            print(sum(list(offset)))
            print(offset)
            print(mapper[hash_code])
            print(-(list(offset)-mapper[hash_code]))
            yield (sid, sum(list(offset)) - mapper[hash_code])


if __name__ == '__main__':
    config = get_config()

    db = SqliteDatabase()

    parser = argparse.ArgumentParser(formatter_class=RawTextHelpFormatter)
    parser.add_argument('-s', '--seconds', nargs='?')
    args = parser.parse_args()

    if not args.seconds:
        parser.print_help()
        sys.exit(0)

    seconds = int(args.seconds)

    chunksize = 2 ** 12  # 4096
    channels = 2  # int(config['channels']) # 1=mono, 2=stereo

    record_forever = False
    visualise_console = bool(config['mic.visualise_console'])
    visualise_plot = bool(config['mic.visualise_plot'])

    reader = MicrophoneReader(None)

    reader.start_recording(seconds=seconds,
                           chunksize=chunksize,
                           channels=channels)

    msg = ' * started recording..'
    print(colored(msg, attrs=['dark']))

    while True:
        bufferSize = int(reader.rate / reader.chunksize * seconds)

        for i in range(0, bufferSize):
            nums = reader.process_recording()

            if visualise_console:
                msg = colored('   %05d', attrs=['dark']) + colored(' %s', 'green')
                print(msg % visual_peak.calc(nums))
            else:
                msg = '   processing %d of %d..' % (i, bufferSize)
                print(colored(msg, attrs=['dark']))

        if not record_forever:
            break

    if visualise_plot:
        data = reader.get_recorded_data()[0]
        visual_plot.show(data)

    reader.stop_recording()

    msg = ' * recording has been stopped'
    print(colored(msg, attrs=['dark']))

    data = reader.get_recorded_data()

    msg = ' * recorded %d samples'
    print(colored(msg, attrs=['dark']) % len(data[0]))

    # reader.save_recorded('test.wav')

    Fs = fingerprint.DEFAULT_FS
    channel_amount = len(data)

    result = set()
    matches = []

    for channeln, channel in enumerate(data):
        # TODO: Remove prints or change them into optional logging.
        msg = '   fingerprinting channel %d/%d'
        print(colored(msg, attrs=['dark']) % (channeln + 1, channel_amount))

        matches.extend(find_matches(channel))

        msg = '   finished channel %d/%d, got %d hashes'
        print(colored(msg, attrs=['dark']) % (channeln + 1,
                                              channel_amount, len(matches)))

    total_matches_found = len(matches)
    print(matches)
    print('')

    if total_matches_found > 0:
        msg = ' ** totally found %d hash matches'
        print(colored(msg, 'green') % total_matches_found)

        song = align_matches(matches)

        msg = ' => song: %s (id=%d)\n'
        msg += '    offset: %d (%d secs)\n'
        msg += '    confidence: %d'

        print(colored(msg, 'green') % (song['SONG_NAME'], song['SONG_ID'],
                                       song['OFFSET'], song['OFFSET_SECS'],
                                       song['CONFIDENCE']))
    else:
        msg = ' ** not matches found at all'
        print(colored(msg, 'red'))

一旦我們的conf.json文件被構建，我們將使用它并從麥克風文件中識別音頻作為我們的主要目的。

所以完全用于音頻和圖像識別，我們將只使用四個 file.pickle 包含（128 -d 矢量）圖像信息的文件，.json 文件（包含音頻指紋），識別圖像和音頻 python 文件。

3.3 創建用戶界面用戶界面起著重要的作用，也有更好的外觀和更好的理解。因此，為了獲得更好的界面，我們將借助 python 中的 pyqt 工具創建一個用戶界面，這將幫助我們識別圖像和聲音。從某種意義上說，我們可以說這個用戶界面處理圖像和聲音識別文件。當我們的系統運行時，它會調用這個用戶界面，首先詢問用戶是否要鎖定或解鎖設備。根據用戶的選擇，執行操作。但是如果系統已經被鎖定并且如果用戶再次按下鎖定按鈕，那么它將顯示設備或系統已經鎖定的提示，并且相同的情況下也適用于解鎖部分。但是如果系統沒有被鎖定，而用戶想要鎖定系統，那么它會先捕獲用戶圖像并進行驗證。如果匹配，則通過麥克風識別用戶聲音，然后判斷用戶是否被授權。如果模塊上的任何一個發生故障，它只會通知螺栓模塊向所有者發送警報短信，指示入侵者正在嘗試訪問安全系統。

上圖 8 顯示了當安全系統通過螺栓設備 python 文件運行時將調用的 UI 第一頁。系統會提示，詢問用戶是否要鎖定或解鎖設備。根據用戶的選擇，將執行操作并且 UI 將被重定向到下一頁是否會處理進一步的處理。

上圖 9 顯示了為處理圖像和音頻識別而創建的 UI。當bolt iot調用這個python文件時，它將在右側空白處顯示用戶實時圖像，在底部空白處顯示用戶實時音頻頻譜。當這兩個驗證正確并且如果訪問被授予時，它將向螺栓設備發送確認以進行進一步處理，或者發送警報以向安全系統的所有者發送警報短信。

Note:- The code for UI and rest all other code along with custom built-in libraries will be provided at the end of the project section.代碼中給出的注釋可以更好地理解不同的部分。

3.4 配置文件：

現在，由于我們所有的模塊都準備好了，我們還將準備好我們的配置文件，以便通過互聯網調用 Bolt-IoT 設備，并在檢測到任何入侵者時發送短信。因此，為此我們需要創建一個包含以下信息的 python 文件：

SID = "Your TWILIO SSID"
AUTH_TOKEN = "Your Twilio Authentication Token"
FROM_NUMBER = "Your TWILIO Generated Number"
TO_NUMBER = "Number to which you want to send sms with +91"
API_KEY = "Your Bolt Cloud API"
Device_ID = "Your Bolt Device ID"

最后，我們所有的模塊都是單獨構建的，現在我們需要將它們集成在一起使用。我們現在將為 BOLT_IoT 設備創建一個單獨的 python 文件，所有這些模塊將在其中集成并一一調用以達到預期目的。

4.集成所有模塊：

現在，我們將開始將所有模塊集成在一起。我們現在將創建一個主 python 文件（例如：-bolt.py），它將控制所有操作。這個 python 文件將導入上面創建的配置文件，并在 python 的 OS 模塊的幫助下，它將調用第一個 UI 頁面。這個 UI 頁面將通過一個一個調用面部和音頻模塊來處理進一步的處理并識別這個人。如果識別成功完成，則 UI 頁面將控制權傳回主 python 文件 (bolt.py)，指示識別成功并要求螺栓模塊成功鎖定或解鎖系統。這可以通過打開或關閉 Led 來顯示，即當從 UI 頁面接收到肯定控制時，我們將根據用戶從第一個 UI 頁面中選擇的選擇向螺栓模塊發送信號，使特定引腳為高電平或低電平，即是鎖定還是解鎖，并在那里放置一個發光或關閉的 LED。人們可以更換這個 LED，也可以將伺服電機放在那個螺栓 IoT 引腳或任何其他東西以顯示代碼的物理工作，因為里面的一切都保持不變。

假設，如果模塊無法識別該人，即如果識別失敗，則 UI 頁面會將負面控制發送回主 python 文件（bolt.py）。一旦主 python 文件從 UI 頁面接收到負面控制，它將請求 Twilio 向用戶發送一條警報短信，提醒他們有入侵者，最后蜂鳴器會發出聲音通知附近的人。

import os
import conf,json,time
from boltiot import Sms, Bolt
mybolt = Bolt(conf.API_Key, conf.Device_ID)
sms = Sms(conf.SID,conf.AUTH_Token,conf.TO_Number,conf.FROM_Number)
os.system('python 1st_page.py')
f = open("del.txt", "r")
res = []
for x in f:
	res.append(x)
f.close()
if int(res[0])==0:
	print("Unlocking device")
	mybolt.digitalWrite('0','HIGH')
	os.remove("del.txt")
elif int(res[0])==1:
	print("Locking device")
	mybolt.digitalWrite('0','LOW')
	os.remove("del.txt")
elif int(res[0])==2:
	print("Making request to Twilio to send an sms")
	response = sms.send_sms("Intruder detected, Someone trying to access security system")
	print("Response received from twilio = " + str(response))
	print("Status of sms = " +str(response.status))
	os.remove("del.txt")

上面的代碼演示了主代碼文件 (bolt.py)，它充當驅動程序類并完成上述必要的工作。

簡單的電路圖

上圖 - 10 顯示了電路圖。由于我們所有的工作都依賴于代碼，因此電路設置很小。再次提及，人們還可以設置任何設備或任何其他東西來代替 led，當安全系統為特定用戶授予訪問權限時，它們將起作用。

注意：-我們的bolt模塊必須聯網，我們只需要運行我們的驅動python文件即可執行，即bolt.py和rest文件將在內部一一調用。所有文件也應該在同一目錄中。

5. 示范

正如上面已經從理論上解釋了代碼是如何工作的，現在讓我們看看它是否實際發生。下面的結果截圖展示了實現所有模塊的項目的完整工作，并顯示了項目是否按上述方式工作。現在為了更好地理解，讓我們也將我們的演示分成不同的部分。

We have also talked about the buzzer which will make sound during intruder detection. Bu due to some problem my buzzer destroyed so I have not added it in the circuit. One can add it to the circuit with a small changes in the bolt.py file.

• 第 1 部分 - 如果授予訪問權限，則演示鎖定或解鎖系統

Note :- We can place anything instead of LED. Suppose we connect the door control with the BOLT IOT then when the system identifies the user it performs locking or unlocking of door based on his choice selected on the first page.
Due to lack of equipment's I just used an LED to demonstrate the working.

• 第 2 部分 - 演示當任何模塊無法識別人員時會發生什么

• 第 3 部分 - 演示當用戶嘗試鎖定已鎖定的系統或解鎖已打開的系統時會發生什么。

Note:- All the codes are provided while explanation. Remaining two GUI codes will be provided at the end of the sections.

5. 結論

該項目演示了使用圖像和聲音處理的安全系統。人們還可以將生物識別傳感器添加到給定的項目中，以使其更加安全。為了保持項目簡短，我刪除了生物識別部分。一旦我們添加了生物識別傳感器，我們就可以實現更高的安全性，包括圖像、聲音和指紋，入侵者將很難繞過系統。