Sistema di sicurezza con riconoscimento facciale per un frigorifero con Raspberry Pi: 7 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Navigando in internet ho scoperto che i prezzi per i sistemi di sicurezza variano dai 150$ ai 600$ e oltre, ma non tutte le soluzioni (anche quelle molto costose) sono integrabili con altri strumenti smart di casa tua! Ad esempio, non puoi impostare una telecamera di sicurezza alla porta di casa in modo che apra automaticamente la porta per te o per i tuoi amici!

Ho deciso di creare una soluzione semplice, economica e potente, che puoi usare ovunque! Ci sono molti manuali su come creare sistemi di sicurezza economici e fatti in casa, tuttavia voglio dimostrare un'applicazione davvero non banale di quelli: sistema di sicurezza per un frigorifero con riconoscimento facciale!

Come funziona? La telecamera IP posizionata sulla parte superiore di un frigorifero, i sensori (due pulsanti) rilevano quando una persona apre la porta del frigorifero, dopodiché Raspberry Pi scatta una foto di quella persona (con telecamera IP), quindi la invia a Microsoft Face API per analizzare l'immagine e ricevere il nome della persona. Con queste informazioni Raspberry Pi scansiona la "lista di accesso": se la persona non ha il permesso di accedere al frigorifero, Raspberry avvisa il proprietario via e-mail, sms e twitter! (Vedi foto sopra)

Come mai? Il sistema ti consente di controllare i tuoi familiari, soprattutto quando sono a dieta o hanno difficoltà a non mangiare dopo la mezzanotte! Oppure usalo solo per divertimento!

Inoltre, puoi effettivamente impostare la telecamera alla porta di casa e configurare il sistema per aprire la porta quando tu, i tuoi familiari o amici vi avvicinate. E questa non è la fine! Le possibilità dell'applicazione sono infinite!

Cominciamo!

Passaggio 1: preparazione

Avrai bisogno:

• Raspberry Pi 3 (puoi usare versioni precedenti, ma la terza generazione ha il Wi-Fi, quindi è molto conveniente)
• pulsanti
• fili
• Vecchio smartphone o fotocamera Raspberry Pi

La prima cosa che devi fare è configurare il tuo Raspberry Pi. Istruzioni dettagliate su come farlo si possono trovare qui e qui, ma tratteremo i passaggi più importanti in questo manuale.

1. Scarica Win32 DiskImager da qui (se usi Windows)
2. Scarica SD Formatter da qui
3. Inserisci la scheda SD nel tuo computer e formattala con SD Formatter
4. Scarica l'immagine Raspbian da qui (scegli "Raspbian Jessie con pixel")
5. Esegui Win32 DiskImager, scegli la tua scheda SD, specifica il percorso dell'immagine Raspbian, fai clic su "Scrivi"
6. Inserisci la scheda SD nel tuo Raspberry Pi e accendi l'alimentazione!

Inoltre, dovresti configurare il tuo Raspberry Pi per avere l'accesso al sistema tramite SSH. Ci sono molte istruzioni in Internet, puoi usare questo, ad esempio, oppure puoi collegare monitor e tastiera.

Ora il tuo Pi è configurato e sei pronto per procedere!

Passaggio 2: creazione di un sensore

Descrizione del passaggio: In questo passaggio creeremo un sensore che rileva quando la persona apre la porta di un frigorifero e attiva Raspberry Pi.

Per configurarlo avresti bisogno dei 2 pulsanti che hai originariamente preparato. Il primo pulsante rileverà quando la porta viene aperta, il secondo pulsante rileverà quando la porta viene aperta al punto in cui stiamo scattando una foto di una persona.

1. Saldare i fili ai pulsanti.
2. Attaccare il primo pulsante alla porta del frigorifero in modo che venga premuto quando la porta è chiusa (vedi foto sopra)
3. Attacca il secondo pulsante alla porta del frigorifero come mostrato nella foto sopra. Questo pulsante deve essere sempre rilasciato, tranne quando la porta raggiunge il punto in cui il sistema scatta una foto. Per configurarlo devi attaccare qualcosa al tuo frigorifero in modo che questo pulsante venga premuto quando la porta viene aperta nella misura desiderata (vedi foto sopra).
4. Collega i fili dai pulsanti al Raspberry Pi: primo pulsante a GPIO 23 e massa, secondo pulsante a GPIO 24 e massa (vedi diagramma fritzing).

Nota: utilizzo il pinout BCM (non Board), leggi di più sulla differenza qui.

Una volta connesso al tuo Raspberry Pi tramite SSH, per eseguire la shell Python, digita nel terminale:

pitone3

Se stai collegando monitor e tastiera a Raspberry Pi, esegui semplicemente "Python 3 IDLE" dal menu.

Il prossimo passo è far funzionare Raspberry Pi con i pulsanti. Collegheremo ascoltatori speciali ai pin GPIO 23 e 24, che ascolteranno l'evento "rising edge" e l'evento "falling edge" su quei pin. In caso di evento gli ascoltatori chiameranno le funzioni che abbiamo definito. "Fronte di salita" significa che il pulsante è stato premuto e ora rilasciato (primo pulsante - la porta è aperta), "bordo di discesa" significa che il pulsante è stato rilasciato e ora premuto (secondo pulsante - la porta ha raggiunto il punto specifico). Maggiori informazioni sulla funzionalità dei pulsanti - qui.

Innanzitutto, importa la libreria che ci dà accesso ai pin:

importa RPi. GPIO come GPIO

Ora definisci le funzioni speciali che verranno chiamate quando l'evento viene attivato:

def sensore1(canale): print(“sensore 1 attivato”)def sensore2(canale): print(“sensore 2 attivato)

Imposta il tipo di piedinatura:

GPIO.setmode(GPIO. BCM)

Configura i pin:

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

Allega ascoltatori:

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

Ora puoi testarlo! Se premi il pulsante 1 vedrai un messaggio nel terminale "sensore 1 attivato", il pulsante 2 ti darà un messaggio "sensore 2 attivato".

Nota: quando hai finito di sperimentare, non dimenticare di chiamare la seguente funzione: GPIO.cleanup().

Impostiamo un'altra funzione che viene chiamata quando la porta raggiunge il punto in cui scattiamo una foto! Puoi farlo da solo o utilizzare la mia implementazione che ho allegato qui (sensor.py)

Nota: sensor.py viene utilizzato solo a scopo di test, i file con funzionalità complete che ho allegato all'ultimo passaggio.

Passaggio 3: configurare la telecamera IP

Descrizione del passaggio: Ora configureremo il vecchio smartphone come telecamera IP.

L'utilizzo dello smartphone come telecamera IP avviene tramite app. Esistono diverse app per Android, iOS, Windows Phone che puoi utilizzare. Ho scelto quello chiamato "IP Webcam" per Android. Questa è un'app gratuita ed è facile da configurare.

Esegui l'app, vai su "Preferenze video" per impostare la risoluzione delle foto che l'app fornirà. Quindi tocca "Avvia server" (prima immagine sopra). Nella parte inferiore dello schermo devi vedere l'indirizzo IP della cam (vedi la seconda immagine sopra). Nel browser puoi digitare https://cam_ip_address/photo-j.webp

Infine, collega la fotocamera al frigorifero (ultima immagine sopra).

Passaggio 4: API per il viso

Descrizione del passaggio: in questo passaggio parleremo dell'API Face di Microsoft che esegue il riconoscimento facciale e identifica le persone.

Face API di Microsoft è un servizio di riconoscimento facciale, attraverso il quale possiamo analizzare le foto e identificare le persone su di esse.

Innanzitutto, è necessario un account Microsoft Azure. Se non ne hai uno puoi crearlo gratuitamente qui.

In secondo luogo, vai su https://portal.azure.com, fai clic su "Nuovo" sul lato sinistro, digita nel modulo "API di servizi cognitivi", selezionalo e fai clic su "Crea". Oppure puoi aprire questo link. Ora devi inserire il nome del tuo servizio, selezionare il tipo di abbonamento, il tipo di API di cui hai bisogno (nel nostro caso è l'API Face), posizione, piano tariffario, gruppo di risorse e accettare i termini legali (vedi screenshot aggiunto a questo passaggio).

Terzo, fai clic su "Tutte le risorse", seleziona il servizio API Face e visualizza le statistiche di utilizzo, le credenziali, ecc.

I dettagli dell'API Face sono disponibili qui, vengono forniti esempi in diversi linguaggi di programmazione. Per questo progetto stiamo usando Python. Puoi leggere la documentazione e creare il tuo set di funzionalità oppure puoi utilizzare quello fornito qui (questo non è il set completo di funzionalità fornito da Microsoft, solo i punti necessari per questo progetto). I miei file Python sono allegati a questo passaggio.

Passiamo alla struttura del lavoro con Face API. Per utilizzare la funzionalità "Identificazione" dobbiamo creare una libreria di persone che utilizzano il servizio Face API che riconoscerà le foto scattate dall'app. Per configurarlo, segui i passaggi:

1. Crea un gruppo
2. Aggiungi persone a questo gruppo
3. Aggiungi volti a queste persone
4. Gruppo treno
5. Invia foto con la persona che desideri identificare (devi fornire foto e ID gruppo in cui il servizio cercherà i candidati)
6. Risultato: in risposta riceverai un elenco di candidati che possono essere presenti nella foto che hai inviato.

Ho creato tre file con funzionalità specifiche che permettono di lavorare con gruppi, singole persone e singole foto:

• PersonGroup.py - contiene funzionalità che consentono: creare un gruppo, ottenere informazioni sul gruppo, ottenere un elenco di tutti i gruppi, formare un gruppo e ottenere lo stato della formazione
• Person.py - contiene funzionalità che consentono: creare una persona, ottenere informazioni sulla persona, elencare tutte le persone nel gruppo specificato, aggiungere volti a una persona specificata
• Face.py - contiene funzionalità che consentono: rilevare il volto sull'immagine, identificare la persona, ottenere il nome della persona identificata

Nel file chiamato "recognition.py" fornisco funzionalità che consentono di verificare se l'immagine contiene un volto e aggiungere volti a una persona specificata (aggiunge automaticamente volti da molte immagini dalla cartella specificata).

Scarica il file allegato a questo passaggio, decomprimilo, modifica la variabile globale 'KEY' in questi tre file: PersonGroup.py, Person.py e Face.py nella tua chiave che puoi trovare: portal.azure.com > tutte le risorse > face api service (o come lo hai chiamato) > scheda chiavi. Puoi usare una qualsiasi delle due chiavi.

Nota: qui addestreremo il servizio API Face per riconoscere le persone, quindi le seguenti azioni possono essere eseguite da qualsiasi computer (Raspberry Pi non è necessario per questo): le modifiche vengono salvate sul server di Microsoft.

Dopo aver cambiato KEY, esegui recognition.py e inserisci il seguente comando nella shell python:

PersonGroup.create("family", 'fff-fff')) // puoi usare il tuo nome e ID per

gruppo printResJson(PersonGroup.getPersonGroup('fff-fff'))

Devi vedere i dati sul gruppo che hai appena creato. Ora inserisci:

printResJson(Person.createPerson('fff-fff', 'nome della persona'))

Ora ottieni l'ID della persona. Crea una cartella con le immagini di questa persona in modo che tutte le immagini contengano il volto di questa persona. Puoi usare la funzione detectFaceOnImages in recognition.py che ti mostra su quali foto viene rilevato il volto. Ora, esegui il comando:

addFacesToPerson('cartella con immagini', 'ID persona che hai ottenuto dopo il comando precedente', 'fff-fff')

Quindi dobbiamo addestrare il nostro servizio inserendo quanto segue:

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

Ora il nostro gruppo è formato ed è pronto per identificare una persona.

Per controllare la persona sull'immagine puoi:

Face.checkPerson(immagine, 'fff-fff')

In risposta otterrai un elenco di candidati e probabilità chi è sulla foto.

Nota: ogni volta che aggiungi volti a una persona oa un gruppo, devi addestrare il gruppo!

Passaggio 5: configurazione del nodo rosso

Descrizione del passaggio: in questo passaggio, creeremo il flusso Node-Red che ti avviserà della violazione di accesso al tuo frigorifero =)

Se il tuo Raspberry Pi funziona su Raspbian Jessie November 2015 o versione successiva, non è necessario installare Node-Red, perché è già preinstallato. Devi solo aggiornarlo. Si prega di utilizzare il manuale qui.

Ora, dobbiamo installare il nodo Twilio su Node-Red, in modo da poter attivare un messaggio di testo. Apri il terminale e digita:

cd ~/.node-rednpm install node-red-node-twilio

Maggiori informazioni sul nodo Twilio qui. Successivamente, esegui Node-Red digitando nel terminale:

nodo-rosso

Quindi vai a: https://127.0.0.1:1880/ - se apri il browser sul tuo Raspberry Pihttps://{raspberry_pi_ip}: 1880/ - se vuoi aprire l'editor Node-Red da un altro computer

Per conoscere l'indirizzo IP di Raspberry Pi usa questa istruzione.

Ora devi trovare il nodo Twilio nell'elenco dei nodi nel tuo editor Node-Red (di solito appare dopo il gruppo 'social').

È tempo di creare il flusso!

Nota: puoi utilizzare il mio flusso allegato a questo passaggio, ma non dimenticare di configurare i nodi: email, twitter e twilio. Leggilo più tardi.

Il nostro flusso inizia con il nodo "notifica" che accetta la richiesta POST dal nostro programma principale con alcuni dati sulla violazione di accesso (un esempio dei dati può essere trovato nel nodo di commento "sulla ricezione di oggetti"). Questo nodo risponde immediatamente con il messaggio "Ok", quindi il programma principale sa che i dati sono stati ricevuti (Flow: /notify > response with Ok > response). Il nodo verde in basso con il nome msg.payload è lì per scopi di debug: se qualcosa non funziona puoi usarlo.

Dal primo nodo (/notify) i dati si sono propagati a "Data Topic" e "Image Topic" dove gli argomenti "data" e "image" sono stati aggiunti rispettivamente.

Nel nodo "compila" riceviamo i dati (che otteniamo durante il primo passaggio) con l'argomento "dati" e un'immagine con l'argomento "immagine" (l'immagine è presa da /home/pi/image.jpg). Questi due messaggi dovrebbero essere compilati in un oggetto, ma i due oggetti vengono ricevuti in momenti diversi! Per gestire ciò utilizzeremo la funzione "contesto" che ci consente di memorizzare i dati tra le chiamate di funzione.

Il prossimo passo è verificare se la persona dalla nostra lista di accesso o è un estraneo (nodo checkConditions). C'è un campo "trustedPerson" nei dati che riceviamo: "true" significa che conosciamo questa persona, ma ha violato il permesso di accesso, "false" significa che la persona è un estraneo.

Quando il risultato è “vero” inviamo una notifica a twitter, twilio ed e-mail; quando il risultato è "falso" - solo email e twilio. Creiamo un oggetto per email con messaggio, immagine allegata e oggetto email, un oggetto per twilio con messaggio. Per Twitter aggiungiamo dati a un oggetto se "trustedPerson" è vero. Quindi invia questi tre oggetti a tre diversi nodi.

Nota: se il nodo seguente non riceve un messaggio, gli inviamo semplicemente "null".

È ora di configurare i nodi per la notifica!

Twitter Aggiungi il nodo "twitter" al flusso. Aprilo con un doppio clic. Fare clic sulla matita accanto a "ID Twitter". Quindi fare clic su "Clicca qui per autenticarsi con Twitter". Accedi al tuo account Twitter e dai le autorizzazioni necessarie a Node-Red.

EmailAggiungi il nodo "email" al flusso. Se non utilizzi Gmail dovresti modificare i dati nei seguenti campi - "Server" e "Porta" (puoi trovare quale server e porta dovresti usare nelle pagine di aiuto del tuo agente di posta elettronica) altrimenti non cambiarli campi.

• A > indirizzo email a cui verranno inviati i messaggi
• ID utente > accedi dalla tua email (forse lo stesso del campo "A")
• Password > password dal tuo account di posta elettronica
• Nome > nome per questo nodo

Twilio Vai su https://www.twilio.com/try-twilio e registra un account. Verificalo. Vai su https://www.twilio.com/console. Fai clic su "Numeri di telefono" (icona grande #) e crea un numero gratuito. Se sei fuori dagli USA devi aggiungere i permessi GEO, vai su https://www.twilio.com/console/sms/settings/geo-pe… e aggiungi il tuo paese.

Ora vai nell'editor Node-Red, aggiungi il nodo Twilio, fai doppio clic su di esso per configurare e compila tutti i campi:

• Credenziali > Usa credenziali locali
• Twilio > modifica
  • SID account > prendi da qui
  • Da > digita il numero virtuale che hai creato
  • Token > prendi da qui
  • Nome > Twilio
• Uscita > SMS
• A > il tuo numero di telefono
• Nome > nome per questo nodo.

Fare clic su Distribuisci

Ora il tuo flusso è pronto! Puoi testarlo inviando una richiesta POST con l'oggetto specificato!

Passaggio 6: compilazione dell'intero progetto

Descrizione del passaggio: in questo passaggio metteremo insieme tutte le parti e le faremo funzionare come un sistema separato.

In questo passaggio devi:

1. Configura il vecchio smartphone come telecamera IP
2. Avere sensori funzionanti
3. API Face di Microsoft addestrata
4. Flusso Nodo-Rosso configurato

Ora dobbiamo migliorare il codice che abbiamo scritto nel passaggio 2. Più specificamente la funzione process() che viene chiamata quando la persona apre la porta. In questa funzione faremo quanto segue:

1. Ottieni l'immagine dalla telecamera IP e salvala in "/home/pi/" con il nome "image.jpg" (funzione "fromIpCam" nel file "getImage")
2. Ottieni il nome della persona su quell'immagine (funzione "checkPerson" nel file "recognition")
3. Verifica il permesso di accesso per quella persona (funzione "verifica" nel file "accesso")
4. In base al risultato della funzione di "verifica" componi il messaggio
5. Invia messaggio composto a Node-Red (funzione “toNodeRed” nel file “sendData”)

Nota: per vedere il codice completo delle funzioni menzionate, scaricare il file zip allegato a questo passaggio.

Informazioni sulla funzione “fromIpCam”. Questa funzione effettua la richiesta GET alla tua telecamera IP, ottiene l'immagine focalizzata in risposta e la salva nel percorso specificato da te. Devi fornire l'indirizzo IP della fotocamera a questa funzione.

Informazioni sulla funzione "checkPerson". La funzione ottiene il percorso dell'immagine e del gruppo in cui si desidera cercare la persona dalla foto come parametri. Innanzitutto, rileva un volto sull'immagine fornita (file Face.py, funzione "rileva"). In risposta ottiene l'ID se il volto è stato rilevato. Quindi chiama la funzione "identifica" (file Face.py) che trova persone simili nel gruppo specificato. In risposta ottiene un ID persona se la persona viene trovata. Quindi chiama la funzione "person" (file Person.py) con ID persona come parametro, la funzione "persona" restituisce la persona con l'ID specificato, otteniamo il nome della persona e lo restituiamo.

Informazioni sulla funzione "verifica". Questa funzione si trova nel file “access” dove mette anche “access list” come variabile globale (puoi modificarla come vuoi). Ottenendo il nome della persona dalla funzione precedente, la funzione "verifica" confronta questa persona con l'elenco di accesso e restituisce il risultato.

Nota: il progetto completo è allegato al passaggio successivo.

Passaggio 7: conclusione

In questo passaggio ho allegato il progetto completo che dovresti decomprimere e posizionare sul tuo Raspberry Pi.

Per far funzionare questo progetto, esegui il file "main.py".

Se controlli Raspberry Pi tramite SSH devi eseguire due programmi da una shell: programma python e Node-Red. Digita nel terminale quanto segue:

nodo-rosso

Premi “Ctrl + Z” e digita:

lavori

Hai visto il processo Node-Red. Guarda l'ID del processo e digita:

bg

Ora Node-Red deve iniziare a lavorare in background. Quindi vai alla directory con il tuo progetto ed esegui il programma principale:

python3 main.py

Nota: non dimenticare di modificare KEY nei file python (passaggio 4) e le credenziali nel flusso Node-Red (passaggio 5)

Fatto! Il tuo frigorifero è al sicuro!

Spero ti sia piaciuto questo intrattabile! Sentiti libero di lasciare le tue menti nei commenti.

Apprezzerei se votassi per il mio progetto =)

Grazie!