სახის ამოცნობის უსაფრთხოების სისტემა მაცივრისთვის ჟოლოს პი: 7 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

ინტერნეტის დათვალიერებისას აღმოვაჩინე, რომ უსაფრთხოების სისტემების ფასები მერყეობს 150 აშშ დოლარიდან 600 აშშ დოლარამდე და ზემოთ, მაგრამ ყველა გამოსავალი (თუნდაც ძალიან ძვირი) არ შეიძლება იყოს ინტეგრირებული სხვა ჭკვიან ინსტრუმენტებთან თქვენს სახლში! მაგალითად, თქვენ არ შეგიძლიათ დააყენოთ უსაფრთხოების კამერა თქვენს შესასვლელ კართან, ასე რომ ის ავტომატურად ხსნის კარს თქვენთვის ან თქვენი მეგობრებისთვის!

მე გადავწყვიტე გავაკეთო მარტივი, იაფი და ძლიერი გადაწყვეტა, რომლის გამოყენებაც ყველგან შეგიძლიათ! არსებობს მრავალი სახელმძღვანელო იმის შესახებ, თუ როგორ უნდა შეიქმნას იაფი და ხელნაკეთი უსაფრთხოების სისტემები, თუმცა მე მსურს წარმოვაჩინო მათი მართლაც არატრადიციული გამოყენება - უსაფრთხოების სისტემა მაცივრის სახის ამოცნობისთვის!

Როგორ მუშაობს? მაცივრის თავზე განთავსებული IP კამერა, სენსორები (ორი ღილაკი) ამოიცნობს, როდესაც ადამიანი ხსნის მაცივრის კარს, ამის შემდეგ Raspberry Pi იღებს იმ ადამიანის სურათს (IP კამერით), შემდეგ აგზავნის მას Microsoft Face API- ში სურათის გაანალიზება და პირის სახელის მიღება. ამ ინფორმაციის საშუალებით Raspberry Pi სკანირებს "წვდომის სიას": თუ პირს არ აქვს მაცივარზე წვდომის ნებართვა, ჟოლო ატყობინებს მფლობელს ელ.ფოსტის, ტექსტური შეტყობინების და ტვიტერის საშუალებით! (იხილეთ სურათები ზემოთ)

რატომ? სისტემა საშუალებას გაძლევთ გააკონტროლოთ თქვენი ოჯახის წევრები, განსაკუთრებით მაშინ, როდესაც ისინი დიეტაზე არიან, ან უჭირთ შუაღამის შემდეგ არ ჭამოთ! ან გამოიყენეთ მხოლოდ გასართობად!

უფრო მეტიც, თქვენ შეგიძლიათ რეალურად დააყენოთ კამერა თქვენს შესასვლელ კართან და დააკონფიგურიროთ სისტემა, რომ გააღოს კარი, როდესაც თქვენ, თქვენი ოჯახის წევრები ან მეგობრები უახლოვდებით. და ეს არ არის დასასრული! განაცხადის შესაძლებლობები უსასრულოა!

Მოდით დავიწყოთ!

ნაბიჯი 1: მომზადება

თქვენ დაგჭირდებათ:

• Raspberry Pi 3 (შეგიძლიათ გამოიყენოთ ძველი ვერსიები, მაგრამ მესამე თაობას აქვს Wi-Fi, ასე რომ ძალიან მოსახერხებელია)
• ღილაკები
• მავთულები
• ძველი სმარტფონი ან Raspberry Pi კამერა

პირველი რაც თქვენ უნდა გააკეთოთ არის თქვენი Raspberry Pi– ის კონფიგურაცია. დეტალური ინსტრუქციები იმის შესახებ, თუ როგორ უნდა გააკეთოთ ეს, შეგიძლიათ იხილოთ აქ და აქ, მაგრამ ამ სახელმძღვანელოში ჩვენ განვიხილავთ ყველაზე მნიშვნელოვან ნაბიჯებს.

1. ჩამოტვირთეთ Win32 DiskImager აქედან (თუ იყენებთ Windows- ს)
2. ჩამოტვირთეთ SD ფორმატი აქედან
3. ჩადეთ SD ბარათი თქვენს კომპიუტერში და დააფორმატეთ იგი SD ფორმატით
4. ჩამოტვირთეთ Raspbian სურათი აქედან (აირჩიეთ "Raspbian Jessie with pixel")
5. გაუშვით Win32 DiskImager, შეარჩიეთ თქვენი SD ბარათი, მიუთითეთ Raspbian გამოსახულების გზა, დააწკაპუნეთ "ჩაწერაზე"
6. ჩადეთ SD ბარათი თქვენს Raspberry Pi- ში და ჩართეთ დენი!

გარდა ამისა, თქვენ უნდა დააკონფიგურიროთ თქვენი Raspberry Pi, რომ გქონდეთ სისტემაში წვდომა SSH– ის საშუალებით. ინტერნეტში ბევრი ინსტრუქციაა, შეგიძლიათ გამოიყენოთ ეს, მაგალითად, ან დაურთოთ მონიტორი და კლავიატურა.

ახლა თქვენი Pi არის კონფიგურირებული და მზად ხართ გააგრძელოთ!

ნაბიჯი 2: სენსორის შექმნა

ნაბიჯის აღწერა: ამ ეტაპზე ჩვენ გავაკეთებთ სენსორს, რომელიც ამოიცნობს როდის ხსნის ადამიანი მაცივრის კარს და ააქტიურებს Raspberry Pi.

მის დასაყენებლად დაგჭირდებათ ორი ღილაკი, რომელიც თქვენ თავდაპირველად მოამზადეთ. პირველი ღილაკი გამოავლენს კარის გაღებისას, მეორე ღილაკი გამოავლენს, როდესაც კარი იხსნება იმ წერტილამდე, როდესაც ჩვენ ვიღებთ პიროვნების ფოტოს.

1. შეაერთეთ მავთულები ღილაკებზე.
2. მიამაგრეთ პირველი ღილაკი მაცივრის კარზე ისე, რომ იგი დაიჭიროს როდესაც კარი დაკეტილია (იხ. სურათი ზემოთ)
3. მიამაგრეთ მეორე ღილაკი მაცივრის კარზე, როგორც ეს მოცემულია ზემოთ მოცემულ ფოტოში. ეს ღილაკი ყოველთვის უნდა გათავისუფლდეს, გარდა იმ შემთხვევისა, როდესაც კარი აღწევს იმ წერტილს, როდესაც სისტემა იღებს სურათს. მისი დასაყენებლად თქვენ უნდა დაურთოთ რაიმე თქვენს მაცივარს ისე, რომ ეს ღილაკი დააჭიროს, როდესაც კარი სასურველ ხარისხზე გაიხსნება (იხ. ფოტოები ზემოთ).
4. მიამაგრეთ მავთულები ღილაკიდან ჟოლოს Pi: პირველი ღილაკი GPIO 23 -ზე და მიწაზე, მეორე ღილაკი GPIO 24 -ზე და მიწაზე (იხილეთ გამაგრების დიაგრამა).

შენიშვნა: მე ვიყენებ BCM pinout- ს (არა დაფას), უფრო მეტი განსხვავების შესახებ წაიკითხეთ აქ.

მას შემდეგ რაც დაუკავშირდებით თქვენს Raspberry Pi– ს SSH– ის საშუალებით, პითონის გარსის გასაშვებად ჩაწერეთ ტერმინალი:

პითონი 3

თუ თქვენ აერთებთ მონიტორს და კლავიატურას ჟოლოს Pi- ზე, უბრალოდ გაუშვით "Python 3 IDLE" მენიუდან.

შემდეგი ნაბიჯი არის ის, რომ ჟოლოს პი მუშაობდეს ღილაკებით. ჩვენ დავამაგრებთ სპეციალურ მსმენელს GPIO 23 და 24 ქინძისთავებისთვის, რომლებიც მოუსმენენ მოვლენას "ამოსვლის ზღვარზე" და "დავარდნის ზღვარზე" იმ ქინძისთავებზე. ღონისძიების შემთხვევაში მსმენელები დარეკავენ ჩვენს მიერ განსაზღვრულ ფუნქციებს. "მზარდი ზღვარი" ნიშნავს იმას, რომ ღილაკი დაჭერილი იყო და ახლა გამოვიდა (პირველი ღილაკი - კარი ღიაა), "დავარდნილი ზღვარი" ნიშნავს, რომ ღილაკი გამოვიდა და ახლა დაჭერილია (მეორე ღილაკი - კარი მიაღწია კონკრეტულ წერტილს). უფრო მეტი ღილაკების ფუნქციონირების შესახებ - აქ.

პირველი, შემოიტანეთ ბიბლიოთეკა, რომელიც გვაძლევს წვდომას ქინძისთავებზე:

იმპორტი RPi. GPIO როგორც GPIO

ახლა განსაზღვრეთ სპეციალური ფუნქციები, რომელსაც დარეკავს მოვლენის გააქტიურებისას:

def sensor1 (არხი): ბეჭდვა („სენსორი 1 გამოიწვია“) def sensor2 (არხი): ბეჭდვა („სენსორი 2 გააქტიურებულია)

დააყენეთ pinout ტიპი:

GPIO.setmode (GPIO. BCM)

ქინძისთავების კონფიგურაცია:

GPIO.setup (23, GPIO. IN, pull_up_down = GPIO. PUD_UP) GPIO.setup (24, GPIO. IN, pull_up_down = GPIO. PUD_UP)

მიამაგრეთ მსმენელები:

GPIO.add_event_detect (23, GPIO. RISING, callback = sensor1, bouncetime = 300) GPIO.add_event_detect (24, GPIO. FALLING, callback = sensor2, bouncetime = 300)

ახლა თქვენ შეგიძლიათ შეამოწმოთ იგი! თუ დააჭერთ ღილაკს 1 დაინახავთ შეტყობინებას ტერმინალში „სენსორი 1 გააქტიურებულია“, ღილაკი 2 გაძლევთ შეტყობინებას „სენსორი 2 გააქტიურებულია“.

შენიშვნა: როდესაც ექსპერიმენტებს დაასრულებთ, არ დაგავიწყდეთ დარეკოთ შემდეგი ფუნქცია: GPIO.cleanup ().

მოდით შევქმნათ კიდევ ერთი ფუნქცია, რომელსაც ჰქვია, როდესაც კარი მიაღწევს იმ წერტილს, სადაც ჩვენ ვიღებთ ფოტოს! თქვენ შეგიძლიათ ამის გაკეთება საკუთარ თავს ან გამოიყენოთ ჩემი განხორციელება, რომელიც მე დავამატე აქ (sensor.py)

შენიშვნა: sensor.py გამოიყენება მხოლოდ სატესტო მიზნებისთვის, ფაილები სრული ფუნქციონირებით მე დავამატე ბოლო საფეხურზე.

ნაბიჯი 3: IP კამერის კონფიგურაცია

ნაბიჯის აღწერა: ახლა ჩვენ ვაპირებთ ძველი სმარტფონის კონფიგურაციას IP კამერის სახით.

სმარტფონის, როგორც IP კამერის, გამოყენება ხდება აპლიკაციის საშუალებით. არსებობს სხვადასხვა პროგრამები Android, iOS, Windows Phone, რომელთა გამოყენებაც შეგიძლიათ. მე ავირჩიე ის, სახელწოდებით "IP ვებკამერა" Android- ისთვის. ეს არის უფასო აპლიკაცია და მისი კონფიგურაცია ადვილია.

გაუშვით აპლიკაცია, გადადით "ვიდეო პარამეტრებში", რომ შექმნათ ფოტოების გარჩევადობა, რომელსაც აპი მოგაწვდით. შემდეგ შეეხეთ "სერვერის დაწყება" (პირველი სურათი ზემოთ). ეკრანის ბოლოში თქვენ უნდა ნახოთ კამერის ip მისამართი (იხ. მეორე სურათი ზემოთ). ბრაუზერში შეგიძლიათ აკრიფოთ https://cam_ip_address/photo-j.webp

და ბოლოს, მიამაგრეთ კამერა მაცივარზე (ბოლო სურათი ზემოთ).

ნაბიჯი 4: Face API

ნაბიჯის აღწერა: ამ ეტაპზე ჩვენ ვისაუბრებთ Microsoft– ის Face API– ზე, რომელიც ახდენს სახის ამოცნობას და იდენტიფიცირებას ახდენს ადამიანებზე.

Microsoft– ის Face API არის სახის ამოცნობის სერვისი, რომლის მეშვეობითაც ჩვენ შეგვიძლია გავაანალიზოთ ფოტოები და გამოვავლინოთ ისინი.

პირველ რიგში, თქვენ გჭირდებათ Microsoft Azure ანგარიში. თუ არ გაქვთ, შეგიძლიათ უფასოდ შექმნათ აქ.

მეორე, გადადით https://portal.azure.com, დააწკაპუნეთ "ახალი" მარცხენა მხარეს, ჩაწერეთ ფორმაში "შემეცნებითი სერვისების API", შეარჩიეთ იგი და დააწკაპუნეთ "შექმნა". ან შეგიძლიათ გახსნათ ეს ბმული. ახლა თქვენ უნდა შეიყვანოთ თქვენი სერვისის სახელი, შეარჩიოთ გამოწერის ტიპი, თქვენთვის საჭირო API ტიპი (ჩვენს შემთხვევაში ეს არის Face API), მდებარეობა, ფასების დონე, რესურსების ჯგუფი და შეთანხმდეთ იურიდიულ პირობებზე (იხილეთ ამ ნაბიჯზე დამატებული ეკრანის ანაბეჭდი).

მესამე, დააწკაპუნეთ "ყველა რესურსი", შეარჩიეთ Face API სერვისი და ნახეთ გამოყენების სტატისტიკა, რწმუნებათა სიგელები და ა.

Face API დეტალები შეგიძლიათ იხილოთ აქ, მოცემულია პროგრამირების სხვადასხვა ენაზე მაგალითები. ამ პროექტისთვის ჩვენ ვიყენებთ პითონს. თქვენ შეგიძლიათ წაიკითხოთ დოკუმენტაცია და შექმნათ თქვენი საკუთარი ფუნქციების კომპლექტი ან გამოიყენოთ აქ მოცემული (ეს არ არის Microsoft– ის მიერ მოწოდებული ფუნქციონირების სრული ნაკრები, მხოლოდ ის წერტილები, რომლებიც საჭიროა ამ პროექტისათვის). ამ პუნქტს თან ერთვის ჩემი პითონის ფაილები.

მოდით გადავიდეთ მუშაობის სტრუქტურაზე Face API– ით. "იდენტიფიკაციის" ფუნქციონირების გამოსაყენებლად ჩვენ უნდა შევქმნათ ადამიანების ბიბლიოთეკა, რომლის საშუალებითაც Face API სერვისი ამოიცნობს აპს მიერ გადაღებულ ფოტოებს. მისი დასაყენებლად, მიჰყევით ნაბიჯებს:

1. შექმენით ჯგუფი
2. დაამატეთ პირები ამ ჯგუფში
3. დაამატეთ სახეები ამ ადამიანებს
4. მატარებლის ჯგუფი
5. გაგზავნეთ ფოტო იმ პირთან, ვისი ამოცნობაც გსურთ (თქვენ უნდა მიუთითოთ ფოტოსურათი და ჯგუფის პირადობის მოწმობა, რომელშიც სერვისი მოიძიებს კანდიდატებს)
6. შედეგი: საპასუხოდ თქვენ მიიღებთ იმ კანდიდატების ჩამონათვალს, რომლებიც შეიძლება იყვნენ თქვენს მიერ წარდგენილ ფოტოზე.

მე შევქმენი სამი ფაილი კონკრეტული ფუნქციონირებით, რომელიც საშუალებას იძლევა ვიმუშაო ჯგუფებთან, ცალკეულ პირებთან და ერთ ფოტოზე:

• PersonGroup.py - შეიცავს მახასიათებლებს, რომლებიც საშუალებას გაძლევთ: შექმნათ ჯგუფი, მიიღოთ ინფორმაცია ჯგუფის შესახებ, მიიღოთ ყველა თქვენი ჯგუფის სია, გაწვრთნათ ჯგუფი და მიიღოთ ტრენინგის სტატუსი
• Person.py - შეიცავს მახასიათებლებს, რომლებიც საშუალებას იძლევა: შექმენით ადამიანი, მიიღეთ ინფორმაცია ადამიანზე, ჩამოთვალეთ ყველა პირი მითითებულ ჯგუფში, დაამატეთ სახეები მითითებულ პირს
• Face.py - შეიცავს მახასიათებლებს, რომლებიც საშუალებას იძლევა: აღმოაჩინონ სახე გამოსახულებაზე, ამოიცნონ პირი, მიიღონ იდენტიფიცირებული პირის სახელი

ფაილში სახელწოდებით "ճանաչვა. Py" მე ვაძლევ ფუნქციებს, რომლებიც საშუალებას გაძლევთ შეამოწმოთ შეიცავს თუ არა სურათი სახეს და დაამატოთ სახეები მითითებულ პირს (ავტომატურად ამატებს სახეს მითითებული საქაღალდის მრავალი სურათისგან).

გადმოწერეთ ამ საფეხურზე მიმაგრებული ფაილი, გახსენით იგი, შეცვალეთ 'KEY' გლობალური ცვლადი ამ სამ ფაილში: PersonGroup.py, Person.py და Face.py თქვენი გასაღები, რომელსაც ნახავთ: portal.azure.com> ყველა რესურსი > face api სერვისი (ან როგორ დაარქვით)> კლავიშების ჩანართი. თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი ორი გასაღები.

შენიშვნა: აქ ჩვენ ვაპირებთ Face API სერვისის მომზადებას ადამიანების ამოცნობის მიზნით, ასე რომ შემდეგი მოქმედებები შეიძლება გაკეთდეს ნებისმიერი კომპიუტერიდან (Raspberry Pi არ არის საჭირო ამისათვის) - ცვლილებები ინახება Microsoft სერვერზე.

KEY- ის შეცვლის შემდეგ გაუშვით ამოცნობა. Py და შეიყვანეთ შემდეგი ბრძანება პითონის გარსში:

PersonGroup.create ("ოჯახი", "fff-fff")) // შეგიძლიათ გამოიყენოთ თქვენი საკუთარი სახელი და ID

ჯგუფი printResJson (PersonGroup.getPersonGroup ('fff-fff'))

თქვენ უნდა ნახოთ მონაცემები თქვენს მიერ შექმნილი ჯგუფის შესახებ. ახლა შეიყვანეთ:

printResJson (Person.createPerson ('fff-fff', 'person of name'))

ახლა თქვენ მიიღებთ პირადობის მოწმობას. შექმენით საქაღალდე ამ ადამიანის სურათებით ისე, რომ ყველა სურათი შეიცავდეს ამ პირის სახეს. თქვენ შეგიძლიათ გამოიყენოთ ამოცნობა ახლა გაუშვით ბრძანება:

addFacesToPerson ("საქაღალდე სურათებით", "პირადობის მოწმობა, რომელიც მიიღეთ წინა ბრძანების შემდეგ", "fff-fff")

შემდეგ ჩვენ უნდა მოვამზადოთ ჩვენი სერვისი შემდეგში შესვლის გზით:

PersonGroup.trainPersonGroup ('fff-fff') printResJson (PersonGroup.getPersonGroupTrainingStatus ('fff-fff'))

ახლა ჩვენი ჯგუფი გაწვრთნილია და მზად არის პიროვნების იდენტიფიცირება.

სურათზე პირის შესამოწმებლად შეგიძლიათ:

Face.checkPerson (სურათი, 'fff-fff')

საპასუხოდ თქვენ მიიღებთ კანდიდატების სიას და ალბათობას ვინ არის ფოტოზე.

შენიშვნა: ყოველ ჯერზე, როდესაც თქვენ დაამატებთ სახეებს პირს ან ჯგუფს, თქვენ უნდა გაწვრთნათ ჯგუფი!

ნაბიჯი 5: Node-Red კონფიგურაცია

ნაბიჯის აღწერა: ამ ეტაპზე ჩვენ შევქმნით Node-Red ნაკადს, რომელიც შეგატყობინებთ თქვენს მაცივარზე წვდომის დარღვევის შესახებ =)

თუ თქვენი Raspberry Pi მუშაობს Raspbian Jessie– ზე 2015 წლის ნოემბერში ან გვიანდელ ვერსიაზე, თქვენ არ გჭირდებათ Node-Red– ის დაყენება, რადგან ის უკვე წინასწარ არის დაინსტალირებული. თქვენ უბრალოდ უნდა განაახლოთ იგი. გთხოვთ გამოიყენოთ სახელმძღვანელო აქ.

ახლა, ჩვენ უნდა დავაინსტალიროთ Twilio კვანძი Node-Red- ზე, ასე რომ ჩვენ შეგვიძლია ტექსტური შეტყობინების გააქტიურება. გახსენით ტერმინალი და ჩაწერეთ:

cd ~/.node-rednpm დააინსტალირეთ node-red-node-twilio

მეტი Twilio კვანძის შესახებ აქ. ამის შემდეგ, გაუშვით Node-Red ტერმინალში აკრეფით:

კვანძი-წითელი

შემდეგ გადადით: https://127.0.0.1:1880/ - თუ გახსნით ბრაუზერს თქვენს Raspberry Pihttps:// {raspberry_pi_ip}: 1880/ - თუ გსურთ გახსნათ Node -Red რედაქტორი სხვა კომპიუტერიდან

ჟოლოს პი მისამართის გასაგებად გამოიყენეთ ეს ინსტრუქცია.

ახლა თქვენ უნდა იპოვოთ Twilio კვანძი თქვენი Node-Red რედაქტორის კვანძების სიაში (ჩვეულებრივ, ის ჩნდება "სოციალური" ჯგუფის შემდეგ).

დროა შევქმნათ ნაკადი!

შენიშვნა: თქვენ შეგიძლიათ გამოიყენოთ ჩემი ნაბიჯი, რომელიც თან ერთვის ამ ნაბიჯს, მაგრამ არ დაგავიწყდეთ კვანძების კონფიგურაცია: ელ.ფოსტა, ტვიტერი და twilio. წაიკითხეთ ამის შესახებ მოგვიანებით.

ჩვენი ნაკადი იწყება "შეატყობინეთ" კვანძით, რომელიც იღებს ჩვენი ძირითადი პროგრამის POST მოთხოვნას წვდომის დარღვევის შესახებ გარკვეული მონაცემებით (მონაცემების მაგალითი შეგიძლიათ იხილოთ კომენტარის კვანძში "ობიექტების მიღების შესახებ"). ეს კვანძი დაუყოვნებლივ პასუხობს "Ok" შეტყობინებით, ასე რომ მთავარმა პროგრამამ იცის, რომ მონაცემები მიღებულია (ნაკადი: /შეატყობინეთ> პასუხი Ok> პასუხი). მწვანე კვანძი ბოლოში სახელით msg.payload არის გამართვის მიზნით: თუ რამე არ მუშაობს შეგიძლიათ გამოიყენოთ.

მუშტის კვანძიდან (/შეატყობინეთ) მონაცემები გავრცელებულია "მონაცემთა თემა" და "სურათის თემა", სადაც თემები "მონაცემები" და "სურათი" დამატებულია შესაბამისად.

"შედგენის" კვანძში ჩვენ ვიღებთ მონაცემებს (რომელსაც ვიღებთ პირველი ნაბიჯის განმავლობაში) "მონაცემების" თემასთან და სურათს "გამოსახულების" თემასთან (სურათი აღებულია /home/pi/image.jpg– დან). ეს ორი შეტყობინება უნდა იყოს შედგენილი ერთ ობიექტში, მაგრამ ორი ობიექტი მიიღება სხვადასხვა დროს! ამის გასაკეთებლად ჩვენ გამოვიყენებთ "კონტექსტის" ფუნქციას, რომელიც საშუალებას გვაძლევს შევინახოთ მონაცემები ფუნქციის გამოძახებებს შორის.

შემდეგი ნაბიჯი არის იმის შემოწმება, არის თუ არა პირი ჩვენი წვდომის სიიდან თუ ის უცხოა (checkConditions კვანძი). ჩვენს მიერ მიღებულ მონაცემებში არის "სანდო პირის" ველი: "ჭეშმარიტი" ნიშნავს იმას, რომ ჩვენ ვიცნობთ ამ ადამიანს, მაგრამ მან დაარღვია წვდომის ნებართვა, "ყალბი" ნიშნავს, რომ ადამიანი უცხოა.

როდესაც შედეგი არის "ჭეშმარიტი" ჩვენ ვაგზავნით შეტყობინებას twitter, twilio და ელ. როდესაც შედეგი არის "ყალბი" - მხოლოდ ელ.ფოსტა და twilio. ჩვენ ვქმნით ელ.ფოსტის ობიექტს შეტყობინებით, თანდართული სურათი და ელ.ფოსტის სათაური, ობიექტი twilio– ით შეტყობინებით. ტვიტერისთვის ჩვენ ვამატებთ მონაცემებს ობიექტს, თუ "trustedPerson" მართალია. შემდეგ გაგზავნეთ ეს სამი ობიექტი სამ სხვადასხვა კვანძზე.

შენიშვნა: თუ შემდეგ კვანძს არ უნდა მიეღო შეტყობინება, ჩვენ მას უბრალოდ ვგზავნით "null".

დროა დააკონფიგურიროთ შეტყობინებების კვანძები!

Twitter დაამატეთ "ტვიტერის" კვანძი ნაკადს. გახსენით იგი ორმაგი დაწკაპუნებით. დააწკაპუნეთ ფანქარზე "Twitter ID" - ს გვერდით. შემდეგ დააწკაპუნეთ "დააწკაპუნეთ აქ Twitter- ით ავტორიზაციისთვის". შედით თქვენს Twitter ანგარიშზე და მიეცით Node-Red საჭირო ნებართვები.

ელ.ფოსტის დამატება "ელ.ფოსტის" კვანძი ნაკადში. თუ არ იყენებთ Gmail– ს, თქვენ უნდა შეცვალოთ მონაცემები შემდეგ ველში - „სერვერი“და „პორტი“(თქვენ შეგიძლიათ იპოვოთ რომელი სერვერი და პორტი უნდა გამოიყენოთ თქვენი ელ.ფოსტის აგენტის დახმარების გვერდებზე) წინააღმდეგ შემთხვევაში არ შეცვალოთ ისინი ველები.

• > ელ.ფოსტის მისამართზე, რომელზეც შეტყობინებები გაიგზავნება
• Userid> შესვლა თქვენი ელ.ფოსტიდან (შესაძლოა იგივე იყოს ველში "To")
• პაროლი> პაროლი თქვენი ელ.ფოსტის ანგარიშიდან
• სახელი> სახელი ამ კვანძის

Twilio გადადით https://www.twilio.com/try-twilio და დაარეგისტრირეთ ანგარიში. გადაამოწმეთ. გადადით https://www.twilio.com/console. დაწკაპეთ "ტელეფონის ნომრები" (დიდი # ხატი) და შექმენით უფასო ნომერი. თუ აშშ-ს ფარგლებს გარეთ ხართ, თქვენ უნდა დაამატოთ GEO ნებართვები, გადადით https://www.twilio.com/console/sms/settings/geo-pe… და დაამატეთ თქვენი ქვეყანა.

ახლა, გადადით Node-Red რედაქტორზე, დაამატეთ Twilio კვანძი, ორჯერ დააწკაპუნეთ მასზე, რომ დააკონფიგურიროთ და შეავსოთ ყველა ველი:

• რწმუნებათა სიგელები> გამოიყენეთ ადგილობრივი რწმუნებათა სიგელები

• Twilio> შესწორება

  • ანგარიშის SID> მიიღეთ აქედან
  • აქედან> ჩაწერეთ თქვენ მიერ შექმნილი ვირტუალური ნომერი
  • ნიშანი> აიღეთ აქედან
  • სახელი> Twilio
• გამომავალი> SMS
• > თქვენი ტელეფონის ნომრისთვის>
• სახელი> სახელი ამ კვანძის.

დააწკაპუნეთ განლაგებაზე

ახლა თქვენი ნაკადი მზად არის! თქვენ შეგიძლიათ შეამოწმოთ იგი POST მოთხოვნის გაგზავნით მითითებული ობიექტით!

ნაბიჯი 6: მთლიანი პროექტის შედგენა

ნაბიჯის აღწერა: ამ ნაბიჯში ჩვენ დავაყენებთ ყველა ნაწილს ერთად და ვაქცევთ მათ მუშაობას ცალკე სისტემად.

ამ ნაბიჯით თქვენ უნდა:

1. ძველი სმარტფონის კონფიგურაცია IP კამერის სახით
2. აქვს სამუშაო სენსორები
3. გაწვრთნილი Microsoft– ის Face API
4. კონფიგურირებული კვანძი-წითელი ნაკადი

ახლა ჩვენ უნდა გავაუმჯობესოთ კოდი, რომელიც ჩვენ დავწერეთ 2 -ე საფეხურზე. უფრო კონკრეტულად ფუნქციის პროცესი (), რომელსაც ეძახიან როდესაც ადამიანი კარს ხსნის. ამ ფუნქციაში ჩვენ გავაკეთებთ შემდეგს:

1. მიიღეთ სურათი ip კამერიდან და შეინახეთ "/home/pi/" - ში სახელწოდებით "image.jpg" (ფუნქცია "fromIpCam" ფაილში "getImage")
2. მიიღეთ იმ პირის სახელი იმ სურათზე (ფუნქცია "checkPerson" ფაილში "აღიარება")
3. შეამოწმეთ იმ პირის წვდომის ნებართვა (ფუნქცია "შემოწმება" ფაილში "წვდომა")
4. "შემოწმების" ფუნქციის შედეგის საფუძველზე შეადგინეთ შეტყობინება
5. გაგზავნეთ შედგენილი შეტყობინება Node-Red- ზე (ფუნქცია "toNodeRed" ფაილში "sendData")

შენიშვნა: ხსენებული ფუნქციების სრული კოდის სანახავად გადმოწერეთ ამ ნაბიჯზე მიმაგრებული zip ფაილი.

ფუნქციის შესახებ "fromIpCam". ეს ფუნქცია GET ითხოვს თქვენს IP კამერას, მიიღეთ ფოკუსირებული სურათი საპასუხოდ და შეინახეთ იგი თქვენს მიერ მითითებულ გზაზე. თქვენ უნდა მიუთითოთ კამერის IP მისამართი ამ ფუნქციისთვის.

ფუნქციის "checkPerson" შესახებ. ფუნქცია იღებს გზას სურათისა და ჯგუფისკენ, რომელშიც გსურთ პიროვნების ძებნა ფოტოდან, როგორც პარამეტრები. პირველ რიგში, ის ამოიცნობს სახეს მოწოდებულ სურათზე (ფაილი Face.py, ფუნქცია "აღმოაჩინე"). საპასუხოდ იგი იღებს პირადობის მოწმობას, თუ სახე აღმოჩენილია. შემდეგ ის იძახებს "ამოცნობის" ფუნქციას (Face.py ფაილი), რომელიც მსგავს პირებს პოულობს მითითებულ ჯგუფში. საპასუხოდ იგი იღებს პირადობის მოწმობას, თუ ადამიანი იპოვეს. შემდეგ გამოვიძახოთ ფუნქცია „პირი“(ფაილი Person.py), რომელსაც აქვს პირადობის მოწმობა, როგორც პარამეტრი, „პირი“ფუნქცია აბრუნებს პირს მითითებული პირადობის მოწმობით, ჩვენ ვიღებთ პირის სახელს და ვუბრუნებთ მას.

ფუნქციის "შემოწმების" შესახებ. ეს ფუნქცია მოთავსებულია ფაილში "წვდომა", სადაც ასევე განთავსებულია "წვდომის სია", როგორც გლობალური ცვლადი (თქვენ შეგიძლიათ შეცვალოთ ის, როგორც გსურთ). პირის ფუნქციის, ფუნქციის "შემოწმების" მიღებისას შეადარეთ ეს პირი წვდომის სიას და დააბრუნეთ შედეგი.

შენიშვნა: სრული პროექტი თან ერთვის შემდეგ საფეხურს.

ნაბიჯი 7: დასკვნა

ამ ნაბიჯში მე დავამატე სრული პროექტი, რომელიც უნდა გახსნათ და განათავსოთ თქვენს Raspberry Pi– ს.

იმისათვის, რომ ეს პროექტი იმუშაოს გაუშვით "main.py" ფაილი.

თუ თქვენ აკონტროლებთ Raspberry Pi– ს SSH– ის საშუალებით, თქვენ უნდა გაუშვათ ორი პროგრამა ერთი ჭურვიდან: პითონის პროგრამა და Node-Red. ჩაწერეთ ტერმინალი შემდეგი:

კვანძი-წითელი

ჩაწერეთ "Ctrl + Z" და ჩაწერეთ:

სამუშაო ადგილები

თქვენ ნახეთ Node-Red პროცესი. შეხედეთ პროცესის პირადობას და ტიპი:

ბგ

ახლა Node-Red– მა უნდა დაიწყოს მუშაობა ფონზე. შემდეგ გადადით დირექტორიასთან თქვენი პროექტით და გაუშვით ძირითადი პროგრამა:

python3 main.py

შენიშვნა: არ დაგავიწყდეთ შეიცვალოს KEY პითონის ფაილებში (ნაბიჯი 4) და რწმუნებათა სიგელები Node-Red ნაკადში (ნაბიჯი 5)

Შესრულებულია! თქვენი მაცივარი უსაფრთხოა!

ვიმედოვნებ, რომ თქვენ ისიამოვნეთ ამ უხერხულით! თავისუფლად დატოვეთ თქვენი აზრი კომენტარებში.

მადლობელი ვიქნები, თუ ჩემს პროექტს მისცემთ ხმას =)

Გმადლობთ!