Categoria: Progetti

Un nuovo podcast

L’esperienza del podcast Geek Cookies fondato qualche mese fa mi è piaciuta parecchio, mi piace ancora e mi dà grandi soddisfazioni. Per questo ho provato a fare un altro podcast in solitaria, sempre di tecnologia, ma con un target leggermente diverso. Vorrei far capire cosa si cela sotto le custodie dei dispositivi che abbiamo attorno durante tutto il giorno. Una specie di “come funziona” orientato a tutto ciò che è tecnologico, con parole semplici, adatto a chi la tecnologia la usa, non sa cosa c’è sotto, ma è curioso.

Pillole di bit è la mia nuova creazione. Sono puntate brevi (15-20 minuti) da incastrare nei vostri aggregatori di podcast, se l’argomento è di interesse.

Come già Geek Cookeis, è un podcast a basso impatto economico, sfrutto tutte risorse gratuite, per questo con alcuni limiti, soprattutto per lo storage dei file. Vedremo tra qualche puntata come andrà.

Videosorveglianza con Raspberry Pi – Parte settima

Per chi si fosse perso le puntate precedenti: Parte prima, Parte seconda, Parte terza, Parte Quarta, Parte quinta, Parte sesta

Ed eccoci qui al cuore del sistema. Perché lasciato per ultimo? Così abbiamo tutti i pezzetti di contorno per farlo funzionare.

Torniamo alle specifiche. Il sistema va controllato via DM, ogni DM un comando, ad ogni comando un’azione, dopo l’esecuzione dell’azione il sistema risponderà con cosa ha fatto. Se il comando non è riconosciuto un DM manderà la lista di tutti i comandi utilizzabili.

Ecco i comandi che ho implementato:

  • motionon: se il sistema non è attivo lo attiva, se è già attivo lo comunica
  • motionoff: se il sistema è attivo lo spegne, se non è attivo lo comunica
  • motionstatus: risponde con lo stato del sistema (attivo o no)
  • click: scatta un’istantanea, come quella oraria, e la twitta
  • cancellatutto: abilita la rimozione di tutti i tweet
  • ippubblico: voglio sapere che indirizzo IP pubblico ha il router

Ecco il codice del file “cerca_dm.py”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#!/usr/bin/env python2.7
import tweepy
import sys
import datetime
import time
import string
import subprocess
import os
import requests
import json
 
# qualche costante
file_di_log = "/home/pi/tweepy/controllo_movimento.log" # file di log del sistema di controllo
file_semaforo_cancella = "/home/pi/tweepy/cancella_tutti_tweet" #file creato per autorizzare la cancellazione dei tweet
utente_dm = "iltuoutente" # utente a cui mandare i DM (magari poi saranno gestibili diversi utenti)
 
# Autenticazione su Twitter
consumer_key = 'xxx'
consumer_secret = 'xxx'
access_token = 'xxx'
access_token_secret = 'xxx'
 
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
 
api = tweepy.API(auth)
 
# apro il file di log in append
log = open (file_di_log, "a")
 
# memorizzo il timestamp attuale (cosi' lo metto nei tweet ed evito il blocco dei doppioni)
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
 
# recupero l'ultimo DM ricevuto
dm_comando = api.direct_messages(count=1)
 
# memorizzo una stringa vuota in ultimo_dm, nel caso in cui non si trovino DM
ultimo_dm = " "
 
# imposto id_ultimo_dm a zero, se non si trovano DM, lo uso per non mandare DM a fine pagina
id_ultimo_dm = 0
 
# memorizzo il testo del tweet recuperato
for directmessage in dm_comando:
    # converto la stringa tutta in minuscolo, per non avere problemi con le iniziali maiuscole dei vari client
    ultimo_dm = directmessage.text.lower()
    id_ultimo_dm = directmessage.id
    luogo_ultimo_dm = directmessage.sender.location
    data_ultimo_dm = directmessage.created_at
    # scrivo il log della richiesta
    log.write(st + " - DM di comando: " + ultimo_dm + " (" + str(id_ultimo_dm) + ") - da " + luogo_ultimo_dm + " \n")
    # elimino il DM
    api.destroy_direct_message(id_ultimo_dm)
    log.write(st + " - cancellato il DM di comando con id " + str(id_ultimo_dm) + " \n")
 
# controllo se il processo 'motion' e' attivo o no
processname = 'motion'
tmp = os.popen("ps -Af").read()
proccount = tmp.count(processname)
 
# l'ultimo DM contiene l'ashtag motionoff? (voglio spegnere il sistema)
if string.find(ultimo_dm, "motionoff") != -1:
    # se il processo 'motion' e' attivo lo uccido e avviso che e' disattivato
    if proccount != 0:
        os.system("pkill motion")
        log.write(st + " - Ucciso motion" + " \n")
        api.send_direct_message(utente_dm,text="Motion disattivato - " + st)
    else:
        api.send_direct_message(utente_dm,text="Motion era gia' disattivato - " + st)
 
# l'ultimo DM contiene l'ashtag motionon? (voglio accendere il sistema)
elif string.find(ultimo_dm, "motionon") != -1:
    # se il processo 'motion' non e' attivo lo avvio e avviso che e' attivato
    if proccount == 0:
        os.system("/home/pi/motion-mmal/motion")
        log.write(st + " - avviato motion \n")
        api.send_direct_message(utente_dm,text="Motion attivato - " + st)
    else:
        api.send_direct_message(utente_dm,text="Motion era gia' attivo - " + st)
 
# l'ultimo DM contiene l'ashtag motionstatus? (voglio sapere se il sistema e' attivo o no)
elif string.find(ultimo_dm, "motionstatus") != -1:
    # se il processo non c'e' twitto che e' disattivato
    if proccount == 0:
        api.send_direct_message(utente_dm,text="Stato motion: NON ATTIVO - " + st)
        log.write(st + " - controllo stato motion: NON attivo \n")
    # se il processo c'e' twitto che e' attivo
    else:
        api.send_direct_message(utente_dm,text="Stato motion: ATTIVO - " + st)
        log.write(st + " - controllo statio motion: attivo \n")
 
# l'ultimo DM contiene il comando cancellatutto? (voglio cancellare tutti i tweet dell'account)
elif string.find(ultimo_dm, "cancellatutto") != -1:
    #creo il file di semaforo
    semaforo = open (file_semaforo_cancella, "a")
    semaforo.write("cancella")
    log.write(st + " - creato il semaforo per la cancellazione\n")
    api.send_direct_message(utente_dm,text="Procedura rimozione tweet impostata, esecuzione entro 1h - " + st)
 
# l'ultimo DM contiene il comando ippubblico (voglio sapere qual e' l'indirizzo IP pubblico)
elif string.find(ultimo_dm, "ippubblico") != -1:
    req = requests.get("http://httpbin.org/ip")
    if req.status_code == 200:
        text = json.loads(req.text)
        ip = text['origin']
 
    api.send_direct_message(utente_dm,text="Indirizzo IP pubblico: " + ip + " - " + st)
    log.write(st + " - IP pubblico di questo momento " + ip + " \n")
 
# l'ultimo DM contiene il comando click (voglio scattare una foto)
elif string.find(ultimo_dm, "click") != -1:
    # se motion e' attivo la videocamera e' impegnata, devo quindi prima spegnerlo
    if proccount != 0:
        os.system("pkill motion")
        log.write(st + " - ucciso motion per foto \n")
        time.sleep(5)
        os.system("raspistill -w 1600 -h 1200 -t 1 -o /home/pi/Pictures/SingoloClick.jpg")
        log.write(st + " - scattata la foto \n")
        time.sleep(15)
        os.system("/home/pi/motion-mmal/motion")
        log.write(st + " - avviato motion dopo foto \n")
    else:
        os.system("raspistill -w 1600 -h 1200 -t 1 -o /home/pi/Pictures/SingoloClick.jpg")
        log.write(st + " - scattata la foto con motion non attivo \n")
 
    api.update_with_media("/home/pi/Pictures/SingoloClick.jpg", utente_dm + " Istantanea del " + st)
    log.write(st + " - mandato tweet con istantanea \n")
    os.system("rm /home/pi/Pictures/SingoloClick.jpg")
    log.write(st + " - rimossa istantanea \n")
 
#se nessun comando e' stato riconosciuto
else:
    if id_ultimo_dm != 0:
        api.send_direct_message(utente_dm,text="Comandi utilizzabili: motionon, motionstatus, motionoff, cancellatutto, ippubblico, click - " + st)
        log.write(st + " - comando non riconosciuto: " + ultimo_dm + " \n")
 
# chiudo il file di log
log.close()

Tutti commenti sono nel codice, la procedura è semplice, cerco nell’ultimo DM ricevuto il comando, se lo trovo eseguo l’azione, rimuovo l’ultimo DM ricevuto per non eseguire continuamente l’ultima azione richiesta. Per ogni azione eseguita viene registrata una riga nel file di log, compresi i dati del DM ricevuto e la posizione geografica del mittente (se abilitata dal client da cui si sta mandando il DM)

Questo programma va eseguito ogni minuto, si deve mettere di nuovo mano al crontab aggiungendo

1
2

#controllo di motion tramite DM di twitter (una volta ogni minuto)
*/1 * * * * python /home/pi/tweepy/cerca_dm.py >/dev/null 2>&1

Attenzione che Twitter ha una frequenza massima di interrogazioni su DM, se dovete fare prove a mano lanciando il programma dalla riga di comando, interrompete il servizio del crontab o commentate quest’ultima riga anteponendo il “#” al comando. Se non lo fate vi troverete bloccati per superamento del limite di interrogazioni.

Concludendo

Ce l’abbiamo fatta! abbiamo un sistema di controllo di una zona fatto completamente da noi, completamente personalizzabile e gestibile da twitter! Ovviamente il codice è un po’ scritto da me, un po’ scopiazzato qua e là per Internet, potrebbero esserci errori e sicuramente potrebbe essere ottimizzato, vale la regola della licenza GNU, viene fornito così com’è e non potrò mai essere ritenuto responsabile di eventuali danni che questo progetto potrebbe arrecarvi.

Ovviamente se avete idee, miglioramenti, correzione di errori, sarò lieto di ascoltarli ed eventualmente implementarli tra le pagine del blog e sul dispositivo che ho a casa.

Altre idee?

Ho pubblicato questa guida per condividerla con chi è alle prime armi con il Raspberry (come me), ma sopratutto perché magari i lettori potrebbero proporre modifiche, aggiunte, nuove funzioni, tutto allo scopo di migliorare il progetto.

Problemi riscontrati ed evoluzioni

Il progetto non è esente da difetti e sicuramente potrebbe avere evoluzioni interessanti, magari ci farò altri post, man mano che mi vengono idee. Ovviamente se avete qualche idea non fatevi problemi a postarla qui sotto nei commenti!

Ecco qui alcuni pensieri che ho fatto

  • Salvare tutti i file in un disco collegato via USB, per non consumare la scheda SD e poter tenere un archivio
  • Fare in modo di avere un server web per poter accedere dall’esterno all’archivio delle immagini
  • Utilizzare il GPIO del Raspberry per attivare un qualche dispositivo esterno in caso di rilevazione di movimento

E qui alcuni problemi che mi sono passati per le mani

  • Pare che la WiFi, dopo che non accedo via SSH per un po’ di tempo, smetta di funzionare per metà, tutto il sistema funziona, ma non riesco più a collegarmici. Non so se è colpa del router, indago
  • La videocamera è eccellente di giorno, ma pessima di notte, serve quella IR con illuminatore apposito (dovrei riuscire a procurarmelo prima delle vacanze)
  • Ci sono ancora troppi falsi movimenti rilevati, devo trovare un modo per filtrarli
  • Il LED rosso della videocamera resta acceso durante lo stato attivo, è da coprire con un pezzo di nastro nero
  • Se va via la corrente ed il vs router è in po’ troppo lento ad avere la connessione è necessario ritardare l’invio del DM di riattivazione al reboot. Comunque ogni tanto lo perdo
  • Qualcosa non torna con il comando “pkill” per ammazzare motion, ogni tanto il processo non viene terminato, pertanto ne parte un altro e così via a catena. Questo riempie RAM, CPU e pianta il sistema che va riavviato. Ci sto lavorando

Ed infine… ecco un banalissimo avatar che ho impostato sul mio account Twitter per il controllo, l’uovo era davvero brutto…

Avatar Motion Twitter

 

Videosorveglianza con Raspberry Pi – Parte sesta

Per chi si fosse perso le puntate precedenti: Parte prima, Parte seconda, Parte terza, Parte Quarta, Parte quinta

Ed eccoci all’ultimo step prima di implementare il controllo vero e proprio. Diciamo che questo è lo step del paranoico.

Non mi arriva nessun tweet con il movimento, ma siamo sicuri che vada tutto bene? Io sto tranquillo e tu mi mandi ogni ora un foto della zona sotto controllo, in definizione più alta di quella del controllo in tempo reale.

Questo il codice del file “foto_oraria.py”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#!/usr/bin/env python2.7
import tweepy
import sys
import datetime
import time
import subprocess
import os
 
# qualche costante
utente_dm = "tuoutente" # utente a cui mandare i DM (magari poi saranno gestibili diversi utenti)
 
 
# Autenticazione di twitter
consumer_key = 'xxx'
consumer_secret = 'xxx'
access_token = 'xxx'
access_token_secret = 'xxx'
 
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
 
api = tweepy.API(auth)
 
# memorizzo il timestamp attuale (cosi' lo metto nei tweet ed evito il blocco dei doppioni)
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
 
# controllo se il processo 'motion' e' attivo o no
processname = 'motion'
tmp = os.popen("ps -Af").read()
proccount = tmp.count(processname)
 
# se motion e' attivo la videocamera e' impegnata, devo quindi prima spegnerlo
if proccount != 0:
    os.system("pkill motion") # ammazzo il processo motion
    time.sleep(5) #aspetto 5 secondi in modo che il processo venga terminato
    os.system("raspistill -w 1600 -h 1200 -t 1 -o /home/pi/Pictures/SingoloClick.jpg") #scatto la foto a 1600x1200 e la salvo nel file SingoloClick.jpg
    time.sleep(5) #aspetto 5 secondo per la memorizzazione della foto. La videocamera e' un po' lenta
    os.system("/home/pi/motion-mmal/motion") # riattivo il processo motion
else:
    os.system("raspistill -w 1600 -h 1200 -t 1 -o /home/pi/Pictures/SingoloClick.jpg") #motion, non e' attivo. Scatto semplicemente la foto
 
#mando il tweet
api.update_with_media("/home/pi/Pictures/SingoloClick.jpg", utente_dm + " Istantanea del " + st)
#cancello il file immagine appena salvato
os.system("rm /home/pi/Pictures/SingoloClick.jpg")

L’attività, come le altre, è banale. Faccio una foto ogni ora e la twitto. L’unico problema è che se la videocamera è impegnata dal controllo di movimento, la foto non si può fare. si deve quindi disattivare, fare la foto e riattivare. La foto, una volta salvata, viene twittata e poi cancellata

Per fare questo è di nuovo necessario mettere mano al crontab ed aggiungere l’operazione, tutte le ore al minuto 00

1
2

# scatto una foto ad ogni ora
00 * * * * python /home/pi/tweepy/foto_oraria.py >/dev/null 2>&1

Tutto sommato semplice, no?

(continua…)

Videosorveglianza con Raspberry Pi – Parte quinta

Per chi si fosse perso le puntate precedenti: Parte prima, Parte seconda, Parte terza, Parte Quarta

In questa puntata affrontiamo un tema quasi di diritto della privacy. Il mio sistema twitta un sacco di immagini quando è attivo, ma a me, una volta viste, non piace molto che queste restino sui server di Twitter, anche se l’account è riservato.

Oggi mettiamo su un pezzetto di codice che, se attivato, cancellerà tutti i tweet dell’utente gestito dal motion control. Ho creato una procedura separata dal resto del sistema (che vedremo tra qualche puntata) perché l’attività, sopratutto se i tweet sono molti, ci mette parecchio tempo, più del minuto di intervallo tra un controllo dei comandi e l’altro.

In definitiva, questo sarà l’algoritmo

  1. mando il comando via DM per cancellare i tweet
  2. il sistema mi risponde che ha impostato la procedura e che sarà eseguita al massimo entro un’ora
  3. viene generato un file specifico che farà da “semaforo” per la procedura che cancella i tweet
  4. ogni ora la procedura che cancella i tweet viene eseguita
  5. se il file di semaforo è presente
    1. i tweet vengono cancellati
    2. viene mandato un messaggio di conferma
    3. il file semaforo viene cancellato
  6. Se il file semaforo non è presente non viene eseguito nulla

Sembra difficile, ma, come il resto del progetto, vi accorgerete che è più facile del previsto.

Create il nuovo file  “rimuovitutti.py”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

#!/usr/bin/env python2.7
# twitterwin.py by Alex Eames http://raspi.tv/?p=5281
import tweepy
import sys
import datetime
import time
import os
 
file_semaforo_cancella = "/home/pi/tweepy/cancella_tutti_tweet" #file creato per autorizzare la cancellazione dei tweet
file_di_log = "/home/pi/tweepy/controllo_movimento.log" # file di log del sistema di controllo
log = open (file_di_log, "a")
utente_dm = "iltuoutente"
 
# Autenticazione twitter
consumer_key = 'xxx'
consumer_secret = 'xxx'
access_token = 'xxx'
access_token_secret = 'xxx'
 
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
 
api = tweepy.API(auth)
 
# memorizzo il timestamp attuale (cosi' lo metto nei tweet ed evito il blocco dei doppioni)
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
 
#memorizzo quanti tweet cancello e quanti falliscono
cancellati = 0
errore = 0
 
#il file di semaforo che autorizza la cancellazione esiste?
if os.path.exists(file_semaforo_cancella ):
    # per ogni tweet che ho inviato
    for status in tweepy.Cursor(api.user_timeline).items():
        #provo a cancellarlo
        try:
            api.destroy_status(status.id)
            log.write(st + " - Tweet rimosso: " + str(status.id) + "\n")
            cancellati = cancellati + 1
        #se non riesco a cancellarlo registro l'errore
        except:
            log.write(st + " - Tweet NON rimosso: " + str(status.id) + "\n")
            errore = errore + 1
    #rimuovo il file del semaforo 
    os.remove(file_semaforo_cancella)
#invio il DM con il resoconto delle attivita
api.send_direct_message(utente_dm,text="Ho rimosso " + str(cancellati) + " tweet. Ho trovato " + str(errore) + " errori - " + st)
#memorizzo nel log
log.write(st + " - Rimossi " + str(cancellati) + " tweet. Ho trovato " + str(errore) + " errori\n")
 
log.close()

Questo file dovrà essere eseguito ogni ora (nel nostro caso al 30° minuto di ogni ora) dal nostro fido Raspberry, configuriamo quindi il crontab (ricordate come si fa?) aggiungendo queste due righe

1
2

# se attivato il semaforo, cancello tutti i tweet, ogni ora
30 * * * * python /home/pi/tweepy/rimuovitutti.py >/dev/null 2>&1

Per adesso non c’è la gestione di creazione del file via comandi (la implementeremo nelle prossime puntate), provate a creare un file con un contenuto qualsiasi che si chiami “cancella_tutti_tweet” in “/home/pi/tweepy” e vedrete che pian piano tutti i tweet inviati saranno cancellati dal sistema (lo potete vedere dal file di log)

Continua…

Videosorveglianza con Raspberry Pi – Parte quarta

Per chi si fosse perso le puntate precedenti: Parte prima, Parte seconda, Parte terza

Il nostro sistema funziona già bene, abbiamo impostato la struttura principale, adesso ci servono i ricami.

Se va via la corrente, come facciamo a farlo riprendere in automatico e avvisarci di questo? Ci viene in aiuto un nuovo pezzetto di codice, che ho chiamato “avvia_reboot.py”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

#!/usr/bin/env python2.7
import tweepy
import sys
import datetime
import time
import os
import requests
import json
 
# qualche costante
file_di_log = "/home/pi/tweepy/motion.log" # file di log del sistema di controllo
utente_dm = "@tuoutente" # utente a cui mandare i DM (magari poi saranno gestibili diversi utenti)
 
# Chiavi e autenticazione per Twitter
consumer_key = 'xxx'
consumer_secret = 'xxx'
access_token = 'xxx'
access_token_secret = 'xxx'
 
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
 
api = tweepy.API(auth)
 
# apro il file di log in append
log = open (file_di_log, "a")
 
# memorizzo il timestamp attuale (cosi' lo metto nei tweet ed evito il blocco dei doppioni)
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
 
# avvio motion
os.system("/home/pi/motion-mmal/motion")
 
# recupero l'indirizzo IP pubblico assegnato al router, non si sa mai
req = requests.get("http://httpbin.org/ip")
if req.status_code == 200:
    text = json.loads(req.text)
    ip = text['origin']
 
api.send_direct_message(utente_dm,text="Reboot! Motion Attivato! Indirizzo IP pubblico: " + ip + " - " + st)
 
log.write(st + " - Motion attivato dopo reboot \n")
 
# chiudo il file di log
log.close()

Il codice è tutto commentato, direi che non dovrebbe essere di grande difficoltà. In parole povere quando viene eseguito il programma questo avvia il processo “motion”, recupera l’indirizzo IP pubblico assegnato al router (è una comodità e potrebbe sempre tornare utile nel caso in cui si volesse accedere da remoto alla propria rete, sempre se avete fatto le dovute configurazioni) e infine avvisa con un DM che il servizio è attivo e qual è l’IP pubblico nuovo.

Introduciamo qui il log delle attività del sistema. Perché un file di log? Perché è bene sapere cosa ha fatto il sistema per capire ed andare a trovare errori durante gli sviluppi e l’attività. Da ora in poi tutti i programmi scriveranno le cose essenziali nel file di log nel formato [dataora] – [evento]. Vi ricordo che con il comando

1

tail [nomefile] -f

potete vedere in tempo reale cosa viene scritto nel file di log. Questa visualizzazione occupa la console, aprite una sessione aggiuntiva sul Raspberry. Il file non si chiama “motion” o un nome che contenga “motion” perché nel caso in cui vogliate controllare il funzionamento visualizzando il file di log con il comando “tail”, quando cercheremo di scoprire se “motion” è attivo, il nome del file di log potrebbe falsare questa attività.

Questo programma per avviare il motion controller però deve essere eseguito dal Raspberry in automatico al riavvio del sistema, come si fa?

Dalla riga dei comandi scrivete

1

crontab -e

Si apre l’editor di testo “nano” con le impostazioni delle operazioni pianificate del processo cron, lo useremo ancora dopo questa parte. Andate al fondo ed aggiungere queste righe

1
2

# avvio il motion control all'avvio del sistema
@reboot python /home/pi/tweepy/avvia_reboot.py >/dev/null 2>&1

Premete Ctrl+o, confermate con Y, poi Ctrl+x e uscite dal programma, lo schedulatore viene immediatamente aggiornato. Avete appena detto al Raspberry che al riavvio deve eseguire il programma che abbiamo appena scritto, la parte al fondo “>/dev/null 2>&1” farà sì che il risultato dell’attività non vi arrivi come mail di sistema, insomma non lascia traccia

(continua…)

Videosorveglianza con Raspberry Pi – Parte terza

Per chi si fosse perso le puntate precedenti: Parte prima, Parte seconda

Ma adesso? Posso attivare e disattivare il sistema se ho una connessione SSH e posso vedere le foto salvate solo se mi collego con un client SCP e mi scarico le immagini sul mio PC. Io voglio che tutto questo sia fattibile in qualunque parte del mondo e dal mio telefonino! Ok, adesso è necessario chiedere una mano a Twitter. Quello che a noi serve è che il programma ci dia evidenza del movimento via Twitter (con un tweet contenente l’immagine) e che si possa comandare con un piccolo set di istruzioni, anche da remoto. Questa seconda parte la faremo tramite i DM.

Perché non uso i DM per le immagini del movimento? Per due buoni motivi: il primo è che la libreria Python non gestisce i DM con le immagini, il secondo, molto più importante, è che Twitter limita moltissimo l’invio di DM in modo massivo. In caso di movimento prolungato avremo una media di 3-4 immagini al secondo, dopo poco tempo i DM non verranno più accolti da Twitter.

Registriamo un nuovo account Twitter e, seguendo questa breve guida, otteniamo tutte le chiavi di autorizzazione per poter utilizzare il nostro nuovo account Twitter via Python. Ricordate che l’account deve essere protetto e l’unico follower dovrà essere il vostro account Twitter personale (non vorrete mica che qualcuno veda dentro casa vostra o abiliti/disabiliti il sistema a suo piacimento?)

Python dovrebbe già essere installato sul vostro Raspberry Pi, quindi si può procedere ad installare “tweepy”

1

sudo pip install tweepy

Fatto. Semplice, no? Adesso è giunto il momento di mettere mano a Python e insegnare alla nostra scheda cosa deve fare, un passo alla volta avremo il nostro sistema completo e funzionante.

Se avete registrato il nuovo account, creato l’app di Twitter e dati i diritti anche per scrivere i DM, sarete in possesso delle chiavi di autenticazione per poter iniziare ad interagire con il social network. Non fate come ho fatto io che ho prima dato le autorizzazioni di sola lettura, quando poi ho abilitato i DM tutte le chiavi sono cambiate e le ho dovute sostituire nei programmi. Iniziamo dal “mandami una menzione se rilevi del movimento”

Per comodità createvi una cartella “tweepy” o un altro nome a voi gradito nella vostra home /home/pi

Adesso create il primo file di python che potete chiamare “tweet.py”

1

nano tweet.py

Potete usare l’editor di testo “nano” già presente sul raspberry e programmare direttamente dalla console SSH, in alternativa potete installare un bel server FTP sul raspberry, dare l’accesso in lettura e scrittura alla cartella dei vostri script ed usare un comodissimo editor di testo sul vostro PC/Mac che apra i file via FTP. La seconda soluzione vince in comodità. Su Mac uso Komodo Edit, per PC potete usare Notepad++ o un altro milione di editor di testo che supportino FTP e colorazione del codice

Questo è il programma che manda un tweet quando il movimento è rilevato

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#!/usr/bin/env python2.7
import tweepy
import sys
import datetime
import time
 
# chiavi di accesso per Twitter
consumer_key = 'xxx'
consumer_secret = 'xxx'
access_token = 'xxx'
access_token_secret = 'xxx'
 
# autenticazione su twitter
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
 
api = tweepy.API(auth)
 
# genero la stringa con data/ora attuale
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
 
# utente che deve essere notificato
twitter_user = "@iltuoutente"
 
# controllo l'esistenza di due argomenti nel lancio del file py
if len(sys.argv) >=2:
    tweet_image = sys.argv[1] #motion salva nell'argomento il percorso completo del fiel appena salvato
    tweet_text = twitter_user + " Movimento rilevato! (" + st + ")"
else:
    tweet_text = twitter_user + " Qualcosa non va nello script del tweet..."
 
# mando il tweet
api.update_with_media(tweet_image, status=tweet_text)

Partendo da livello zero in Python e usando per bene Google sono riuscito ad imparare le basi, quindi questo piccolo programma fa esattamente quel che a me serve. Adesso si deve dire a Motion “quando salvi un’immagine, twittala!” per fare questo andiamo nel file di configurazione e mettiamo il programma nella riga relativa all’evento

1

on_picture_save python /home/pi/tweepy/tweet.py %f

Il “%f” dice a Motion che alla fine del comando deve mettere il percorso completo dell’immagine appena salvata. Se adesso attivate a mano il programma e generate movimento davanti alla videocamera ecco che compariranno tutti i tweet con i frame e l’indicazione di dove è avvenuto il movimento. Ma dopo tante registrazioni, tutti questi file, anche se piccoli, inizieranno ad occupare un po’ di spazio sulla scheda SD del raspberry, sicuramente, una volta fatto il tweet, l’immagine non ci servirà più e la potremo cancellare. Per fare questo c’è il comando lanciato all’evento “on event end”, che se ricordate, accade dopo un numero di secondi impostato nel parametro “event gap” all’interno del file di configurazione

1

on_event_end rm /home/pi/Pictures/*.jpg

Alla fine dell’evento, le immagini saranno state mandate su twitter, quindi possiamo cancellare tutti i file immagine all’interno della cartella dove il programma li salva

(continua…)

Videosorveglianza con Raspberry Pi – Parte seconda

Per chi si fosse perso le puntate precedenti: Parte prima

Adesso passiamo ad installare il programma che ci permetterà, con relativa semplicità, di attivare la videosorveglianza: motion. Si installa con il comando

1

sudo apt-get install motion

Qualche minuto di pazienza e il programma sarà pronto. Adesso inizia il bello. Si deve configurare il programma, andando a lavorare sul suo elaborato file di configurazione. Qui un esempio (nello specifico quello che uso io, togliendo un po’ delle mille opzioni che ho lasciato inutilizzate)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521

############################################################
# Daemon
############################################################
 
# Start in daemon (background) mode and release terminal (default: off)
daemon on
 
# File to store the process ID, also called pid file. (default: not defined)
;process_id_file /var/run/motion/motion.pid
 
############################################################
# Basic Setup Mode
############################################################
 
# Start in Setup-Mode, daemon disabled. (default: off)
setup_mode off
 
 
# Use a file to save logs messages, if not defined stderr and syslog is used. (default: not defined)
logfile /home/pi/controllo_movimento.log
 
# Level of log messages [1..9] (EMR, ALR, CRT, ERR, WRN, NTC, INF, DBG, ALL). (default: 6 / NTC)
log_level 7
 
# Filter to log messages by type (COR, STR, ENC, NET, DBL, EVT, TRK, VID, ALL). (default: ALL)
log_type all
 
###########################################################
# Capture device options
############################################################
 
# Videodevice to be used for capturing  (default /dev/video0)
# for FreeBSD default is /dev/bktr0
videodevice /dev/video0
 
# v4l2_palette allows to choose preferable palette to be use by motion
# to capture from those supported by your videodevice. (default: 17)
# E.g. if your videodevice supports both V4L2_PIX_FMT_SBGGR8 and
# V4L2_PIX_FMT_MJPEG then motion will by default use V4L2_PIX_FMT_MJPEG.
# Setting v4l2_palette to 2 forces motion to use V4L2_PIX_FMT_SBGGR8
# instead.
#
# Values :
# V4L2_PIX_FMT_SN9C10X : 0  'S910'
# V4L2_PIX_FMT_SBGGR16 : 1  'BYR2'
# V4L2_PIX_FMT_SBGGR8  : 2  'BA81'
# V4L2_PIX_FMT_SPCA561 : 3  'S561'
# V4L2_PIX_FMT_SGBRG8  : 4  'GBRG'
# V4L2_PIX_FMT_SGRBG8  : 5  'GRBG'
# V4L2_PIX_FMT_PAC207  : 6  'P207'
# V4L2_PIX_FMT_PJPG    : 7  'PJPG'
# V4L2_PIX_FMT_MJPEG   : 8  'MJPEG'
# V4L2_PIX_FMT_JPEG    : 9  'JPEG'
# V4L2_PIX_FMT_RGB24   : 10 'RGB3'
# V4L2_PIX_FMT_SPCA501 : 11 'S501'
# V4L2_PIX_FMT_SPCA505 : 12 'S505'
# V4L2_PIX_FMT_SPCA508 : 13 'S508'
# V4L2_PIX_FMT_UYVY    : 14 'UYVY'
# V4L2_PIX_FMT_YUYV    : 15 'YUYV'
# V4L2_PIX_FMT_YUV422P : 16 '422P'
# V4L2_PIX_FMT_YUV420  : 17 'YU12'
#
v4l2_palette 17
 
# The video input to be used (default: -1)
# Should normally be set to 0 or 1 for video/TV cards, and -1 for USB cameras
input -1
 
# Rotate image this number of degrees. The rotation affects all saved images as
# well as movies. Valid values: 0 (default = no rotation), 90, 180 and 270.
rotate 0
 
# Image width (pixels). Valid range: Camera dependent, default: 352
width 1024
 
# Image height (pixels). Valid range: Camera dependent, default: 288
height 768
 
# Maximum number of frames to be captured per second.
# Valid range: 2-100. Default: 100 (almost no limit).
framerate 4
 
# URL to use if you are using a network camera, size will be autodetected (incl http:// ftp:// mjpg:// or file:///)
# Must be a URL that returns single jpeg pictures or a raw mjpeg stream. Default: Not defined
;netcam_url http://127.0.0.1/cgi-bin/raspicam.sh
 
# Username and password for network camera (only if required). Default: not defined
# Syntax is user:password
; netcam_userpass value
 
# The setting for keep-alive of network socket, should improve performance on compatible net cameras.
# off:   The historical implementation using HTTP/1.0, closing the socket after each http request.
# force: Use HTTP/1.0 requests with keep alive header to reuse the same connection.
# on:    Use HTTP/1.1 requests that support keep alive as default.
# Default: off
netcam_keepalive off
 
# Let motion regulate the brightness of a video device (default: off).
# The auto_brightness feature uses the brightness option as its target value.
# If brightness is zero auto_brightness will adjust to average brightness value 128.
# Only recommended for cameras without auto brightness
auto_brightness off
 
# Set the initial brightness of a video device.
# If auto_brightness is enabled, this value defines the average brightness level
# which Motion will try and adjust to.
# Valid range 0-255, default 0 = disabled
brightness 0
 
# Set the contrast of a video device.
# Valid range 0-255, default 0 = disabled
contrast 0
 
# Set the saturation of a video device.
# Valid range 0-255, default 0 = disabled
saturation 0
 
############################################################
# OpenMax/MMAL camera support for Raspberry Pi
############################################################
mmalcam_name vc.ril.camera
#mmalcam_control_params
#mmalcam_raw_capture_file /home/pi/motion-mmal.capture
 
# Switch this setting to "on" to use the still image mode of the Pi's camera
# instead of video. This gives a wider field of view, but requires
# a much slower frame-rate to achieve exposure stability
# (e.g. 0.25 fps or slower). You can use the minimum_frame_time
# parameter above to achieve this
 
mmalcam_use_still off
 
 
############################################################
# Round Robin (multiple inputs on same video device name)
############################################################
 
# Number of frames to capture in each roundrobin step (default: 1)
roundrobin_frames 1
 
# Number of frames to skip before each roundrobin step (default: 1)
roundrobin_skip 1
 
# Try to filter out noise generated by roundrobin (default: off)
switchfilter off
 
 
############################################################
# Motion Detection Settings:
############################################################
 
# Threshold for number of changed pixels in an image that
# triggers motion detection (default: 1500)
threshold 5000
 
# Automatically tune the threshold down if possible (default: off)
threshold_tune off
 
# Noise threshold for the motion detection (default: 32)
noise_level 32
 
# Automatically tune the noise threshold (default: on)
noise_tune on
 
# Despeckle motion image using (e)rode or (d)ilate or (l)abel (Default: not defined)
# Recommended value is EedDl. Any combination (and number of) of E, e, d, and D is valid.
# (l)abeling must only be used once and the 'l' must be the last letter.
# Comment out to disable
despeckle_filter EedDl
 
# Detect motion in predefined areas (1 - 9). Areas are numbered like that:  1 2 3
# A script (on_area_detected) is started immediately when motion is         4 5 6
# detected in one of the given areas, but only once during an event.        7 8 9
# One or more areas can be specified with this option. Take care: This option
# does NOT restrict detection to these areas! (Default: not defined)
; area_detect value
 
# PGM file to use as a sensitivity mask.
# Full path name to. (Default: not defined)
; mask_file value
 
# Dynamically create a mask file during operation (default: 0)
# Adjust speed of mask changes from 0 (off) to 10 (fast)
smart_mask_speed 0
 
# Ignore sudden massive light intensity changes given as a percentage of the picture
# area that changed intensity. Valid range: 0 - 100 , default: 0 = disabled
lightswitch 0
 
# Picture frames must contain motion at least the specified number of frames
# in a row before they are detected as true motion. At the default of 1, all
# motion is detected. Valid range: 1 to thousands, recommended 1-5
minimum_motion_frames 1
 
# Specifies the number of pre-captured (buffered) pictures from before motion
# was detected that will be output at motion detection.
# Recommended range: 0 to 5 (default: 0)
# Do not use large values! Large values will cause Motion to skip video frames and
# cause unsmooth movies. To smooth movies use larger values of post_capture instead.
pre_capture 0 
 
# Number of frames to capture after motion is no longer detected (default: 0)
post_capture 0
 
# Event Gap is the seconds of no motion detection that triggers the end of an event.
# An event is defined as a series of motion images taken within a short timeframe.
# Recommended value is 60 seconds (Default). The value -1 is allowed and disables
# events causing all Motion to be written to one single movie file and no pre_capture.
# If set to 0, motion is running in gapless mode. Movies don't have gaps anymore. An
# event ends right after no more motion is detected and post_capture is over.
event_gap 60
 
# Maximum length in seconds of a movie
# When value is exceeded a new movie file is created. (Default: 0 = infinite)
max_movie_time 0
 
# Always save images even if there was no motion (default: off)
emulate_motion off
 
 
############################################################
# Image File Output
############################################################
 
# Output 'normal' pictures when motion is detected (default: on)
# Valid values: on, off, first, best, center
# When set to 'first', only the first picture of an event is saved.
# Picture with most motion of an event is saved when set to 'best'.
# Picture with motion nearest center of picture is saved when set to 'center'.
# Can be used as preview shot for the corresponding movie.
output_pictures on
 
# Output pictures with only the pixels moving object (ghost images) (default: off)
output_debug_pictures off
 
# The quality (in percent) to be used by the jpeg compression (default: 75)
quality 75
 
# Type of output images
# Valid values: jpeg, ppm (default: jpeg)
picture_type jpeg
 
############################################################
# FFMPEG related options
# Film (movies) file output, and deinterlacing of the video input
# The options movie_filename and timelapse_filename are also used
# by the ffmpeg feature
############################################################
 
# Use ffmpeg to encode movies in realtime (default: off)
ffmpeg_output_movies off
 
# Use ffmpeg to make movies with only the pixels moving
# object (ghost images) (default: off)
ffmpeg_output_debug_movies off
 
# Use ffmpeg to encode a timelapse movie
# Default value 0 = off - else save frame every Nth second
ffmpeg_timelapse 0
 
# The file rollover mode of the timelapse video
# Valid values: hourly, daily (default), weekly-sunday, weekly-monday, monthly, manual
ffmpeg_timelapse_mode daily
 
# Bitrate to be used by the ffmpeg encoder (default: 400000)
# This option is ignored if ffmpeg_variable_bitrate is not 0 (disabled)
ffmpeg_bps 500000
 
# Enables and defines variable bitrate for the ffmpeg encoder.
# ffmpeg_bps is ignored if variable bitrate is enabled.
# Valid values: 0 (default) = fixed bitrate defined by ffmpeg_bps,
# or the range 2 - 31 where 2 means best quality and 31 is worst.
ffmpeg_variable_bitrate 0
 
# Codec to used by ffmpeg for the video compression.
# Timelapse mpegs are always made in mpeg1 format independent from this option.
# Supported formats are: mpeg1 (ffmpeg-0.4.8 only), mpeg4 (default), and msmpeg4.
# mpeg1 - gives you files with extension .mpg
# mpeg4 or msmpeg4 - gives you files with extension .avi
# msmpeg4 is recommended for use with Windows Media Player because
# it requires no installation of codec on the Windows client.
# swf - gives you a flash film with extension .swf
# flv - gives you a flash video with extension .flv
# ffv1 - FF video codec 1 for Lossless Encoding ( experimental )
# mov - QuickTime ( testing )
# ogg - Ogg/Theora ( testing )
ffmpeg_video_codec mpeg4
 
# Use ffmpeg to deinterlace video. Necessary if you use an analog camera
# and see horizontal combing on moving objects in video or pictures.
# (default: off)
ffmpeg_deinterlace off
 
############################################################
# Snapshots (Traditional Periodic Webcam File Output)
############################################################
 
# Make automated snapshot every N seconds (default: 0 = disabled)
snapshot_interval 0
 
 
############################################################
# Text Display
# %Y = year, %m = month, %d = date,
# %H = hour, %M = minute, %S = second, %T = HH:MM:SS,
# %v = event, %q = frame number, %t = thread (camera) number,
# %D = changed pixels, %N = noise level, \n = new line,
# %i and %J = width and height of motion area,
# %K and %L = X and Y coordinates of motion center
# %C = value defined by text_event - do not use with text_event!
# You can put quotation marks around the text to allow
# leading spaces
############################################################
 
# Locate and draw a box around the moving object.
# Valid values: on, off, preview (default: off)
# Set to 'preview' will only draw a box in preview_shot pictures.
locate_motion_mode on
 
# Set the look and style of the locate box if enabled.
# Valid values: box, redbox, cross, redcross (default: box)
# Set to 'box' will draw the traditional box.
# Set to 'redbox' will draw a red box.
# Set to 'cross' will draw a little cross to mark center.
# Set to 'redcross' will draw a little red cross to mark center.
locate_motion_style redcross
 
# Draws the timestamp using same options as C function strftime(3)
# Default: %Y-%m-%d\n%T = date in ISO format and time in 24 hour clock
# Text is placed in lower right corner
text_right %Y-%m-%d\n%T-%q
 
# Draw a user defined text on the images using same options as C function strftime(3)
# Default: Not defined = no text
# Text is placed in lower left corner
; text_left CAMERA %t
 
# Draw the number of changed pixed on the images (default: off)
# Will normally be set to off except when you setup and adjust the motion settings
# Text is placed in upper right corner
text_changes on
 
# This option defines the value of the special event conversion specifier %C
# You can use any conversion specifier in this option except %C. Date and time
# values are from the timestamp of the first image in the current event.
# Default: %Y%m%d%H%M%S
# The idea is that %C can be used filenames and text_left/right for creating
# a unique identifier for each event.
text_event %Y%m%d%H%M%S
 
# Draw characters at twice normal size on images. (default: off)
text_double on
 
 
############################################################
# Target Directories and filenames For Images And Films
# For the options snapshot_, picture_, movie_ and timelapse_filename
# you can use conversion specifiers
# %Y = year, %m = month, %d = date,
# %H = hour, %M = minute, %S = second,
# %v = event, %q = frame number, %t = thread (camera) number,
# %D = changed pixels, %N = noise level,
# %i and %J = width and height of motion area,
# %K and %L = X and Y coordinates of motion center
# %C = value defined by text_event
# Quotation marks round string are allowed.
############################################################
 
# Target base directory for pictures and films
# Recommended to use absolute path. (Default: current working directory)
target_dir /home/pi/Pictures
 
# File path for snapshots (jpeg or ppm) relative to target_dir
# Default: %v-%Y%m%d%H%M%S-snapshot
# Default value is equivalent to legacy oldlayout option
# For Motion 3.0 compatible mode choose: %Y/%m/%d/%H/%M/%S-snapshot
# File extension .jpg or .ppm is automatically added so do not include this.
# Note: A symbolic link called lastsnap.jpg created in the target_dir will always
# point to the latest snapshot, unless snapshot_filename is exactly 'lastsnap'
snapshot_filename %v-%Y%m%d%H%M%S-snapshot
 
# File path for motion triggered images (jpeg or ppm) relative to target_dir
# Default: %v-%Y%m%d%H%M%S-%q
# Default value is equivalent to legacy oldlayout option
# For Motion 3.0 compatible mode choose: %Y/%m/%d/%H/%M/%S-%q
# File extension .jpg or .ppm is automatically added so do not include this
# Set to 'preview' together with best-preview feature enables special naming
# convention for preview shots. See motion guide for details
picture_filename %v-%Y%m%d%H%M%S-%q
 
# File path for motion triggered ffmpeg films (movies) relative to target_dir
# Default: %v-%Y%m%d%H%M%S
# Default value is equivalent to legacy oldlayout option
# For Motion 3.0 compatible mode choose: %Y/%m/%d/%H%M%S
# File extension .mpg or .avi is automatically added so do not include this
# This option was previously called ffmpeg_filename
movie_filename %v-%Y%m%d%H%M%S
 
# File path for timelapse movies relative to target_dir
# Default: %Y%m%d-timelapse
# Default value is near equivalent to legacy oldlayout option
# For Motion 3.0 compatible mode choose: %Y/%m/%d-timelapse
# File extension .mpg is automatically added so do not include this
timelapse_filename %Y%m%d-timelapse
 
############################################################
# Global Network Options
############################################################
# Enable or disable IPV6 for http control and stream (default: off )
ipv6_enabled off
 
############################################################
# Live Stream Server
############################################################
 
# The mini-http server listens to this port for requests (default: 0 = disabled)
stream_port 8091
 
# Quality of the jpeg (in percent) images produced (default: 50)
stream_quality 50
 
# Output frames at 1 fps when no motion is detected and increase to the
# rate given by stream_maxrate when motion is detected (default: off)
stream_motion on
 
# Maximum framerate for stream streams (default: 1)
stream_maxrate 10
 
# Restrict stream connections to localhost only (default: on)
stream_localhost off
 
# Limits the number of images per connection (default: 0 = unlimited)
# Number can be defined by multiplying actual stream rate by desired number of seconds
# Actual stream rate is the smallest of the numbers framerate and stream_maxrate
stream_limit 0
 
# Set the authentication method (default: 0)
# 0 = disabled
# 1 = Basic authentication
# 2 = MD5 digest (the safer authentication)
stream_auth_method 0
 
# Authentication for the stream. Syntax username:password
# Default: not defined (Disabled)
; stream_authentication username:password
 
 
############################################################
# HTTP Based Control
############################################################
 
# TCP/IP port for the http server to listen on (default: 0 = disabled)
webcontrol_port 0
 
# Restrict control connections to localhost only (default: on)
webcontrol_localhost off
 
# Output for http server, select off to choose raw text plain (default: on)
webcontrol_html_output on
 
# Authentication for the http based control. Syntax username:password
# Default: not defined (Disabled)
; webcontrol_authentication username:password
 
 
 
 
############################################################
# External Commands, Warnings and Logging:
# You can use conversion specifiers for the on_xxxx commands
# %Y = year, %m = month, %d = date,
# %H = hour, %M = minute, %S = second,
# %v = event, %q = frame number, %t = thread (camera) number,
# %D = changed pixels, %N = noise level,
# %i and %J = width and height of motion area,
# %K and %L = X and Y coordinates of motion center
# %C = value defined by text_event
# %f = filename with full path
# %n = number indicating filetype
# Both %f and %n are only defined for on_picture_save,
# on_movie_start and on_movie_end
# Quotation marks round string are allowed.
############################################################
 
# Do not sound beeps when detecting motion (default: on)
# Note: Motion never beeps when running in daemon mode.
quiet on
 
# Command to be executed when an event starts. (default: none)
# An event starts at first motion detected after a period of no motion defined by event_gap
; on_event_start value
 
# Command to be executed when an event ends after a period of no motion
# (default: none). The period of no motion is defined by option event_gap.
on_event_end rm /home/pi/Pictures/*.jpg
 
# Command to be executed when a picture (.ppm|.jpg) is saved (default: none)
# To give the filename as an argument to a command append it with %f
on_picture_save python /home/pi/tweepy/tweet.py %f
 
 
# Command to be executed when a motion frame is detected (default: none)
; on_motion_detected value
 
# Command to be executed when motion in a predefined area is detected
# Check option 'area_detect'.   (default: none)
; on_area_detected value
 
# Command to be executed when a movie file (.mpg|.avi) is created. (default: none)
# To give the filename as an argument to a command append it with %f
; on_movie_start value
 
# Command to be executed when a movie file (.mpg|.avi) is closed. (default: none)
# To give the filename as an argument to a command append it with %f
; on_movie_end value
 
# Command to be executed when a camera can't be opened or if it is lost
# NOTE: There is situations when motion don't detect a lost camera!
# It depends on the driver, some drivers dosn't detect a lost camera at all
# Some hangs the motion thread. Some even hangs the PC! (default: none)
; on_camera_lost value

Paura, eh? Non vi preoccupate, i parametri utili sono semplici ed abbastanza intuitivi, adesso li analizziamo uno per volta. Tutti i parametri che non affronto, semplicemente non li ho utilizzati, nella ricca documentazione trovate tutte le funzioni extra che potete aggiungere al vostro sistema.

1

daemon on

Questo dice al programma che quando viene avviato deve rilasciare la console libera e deve funzionare come demone (“servizio”, in lingua Windows). E’ bene tenerlo ad OFF durante tutte le vostre prove, in modo da vedere a video cosa sta combinando il programma e sopratutto se ci sono errori

1

logfile [percorso]

il file dentro cui saranno salvati tutti i log (quelli che vedete a video con l’impostazione “daemon off” appena vista, per intenderci). Consiglio personale: NON chiamate questo file “motion” o con un nome che contenga la parola “motion”, questo per evitare innumerevoli casini quando andremo a sviluppare l’applicazione

1

log_level 7

Quante cose devo memorizzare nel file di log? Dopo un po’ di prove, ho raggiungo la conclusione che “7” è il livello adatto per capire cosa sta succedendo, senza morire sommersi di informazioni inutili

1

videodevice /dev/video0

Questa è la videocamera che verrà utilizzata per rilevare il movimento, il default è la videocamera che avete appena collegato al Raspberry Pi e che avete provato

1
2

width 768
height 1024

Questa è la dimensione del video che verrà ripreso e dei fermo immagine che verranno salvati in caso di movimento. Assicuratevi che siano valori divisibili per 16 e che non superino la risoluzione della videocamera (1920×1080). Più solo alti, più il processore verrà messo sotto stress, ma se sono stroppo bassi perderete dettaglio nella registrazione. Con 1024×768 mi pare di aver trovato un buon compromesso

1

framerate 4

Quante foto devono essere salvate per ogni secondo? Più il valore è alto più la CPU sarà sotto stress, ma meno dettaglio avrete in caso di movimenti rapidi. L’unica è fare un po’ di tentativi. Per me 4 è un valore buono (vedo la faccia di chi entra in casa tutte le volte)

1

netcam_url [indirizzo]

Se non usate la videocamera del Raspberry Pi, potete collegarvi ad una videocamera IP (ma dovete avere le documentazione)

1

threshold 5000

Questo è un parametro importante. Per identificare il movimento il sistema fa un banale controllo: “quanti pixel sono cambiati dall’immagine precedente all’attuale?”. In un frame da 1024×768 i pixel sono 786.432, la domanda che ci si deve porre è “che percentuale dell’immagine deve cambiare perché io sia avvisato?”. La risposta è solo una: provare e provare

1

event_gap 60

dopo quanti secondi senza movimento devo identificare l’evento come terminato? Questo parametro ci servirà più tardi.

1

output_picture on

Devo salvare le immagini del movimento? con l’importazione ad “on2 la risposta è “sì, salvale tutte”

1

ffmpeg_output_movies OFF

Il sistema può anche salvare dei video, nei formati più disparati, per poterlo fare dovere installare un codec MPEG4 o simile, l’ho fatto, ma non mi è tornato utile, non salvo i video, ma solo le immagini

1

snapshot_interval 0

Se volete ottenere una foto ogni “x” secondi, mettete un valore numerico qui, l’immagine verrà salvata anche se non c’è movimento

1
2

locate_motion_mode on
locate_motion_style redcross

Se la domanda che vi ponete è “ma cosa si è mosso?” questa è la soluzione, una crocetta rossa identificherà il centro del movimento

1
2
3
4

text_right
text_left
text_changes on
text_double on

Il sistema metterà in sovraimpressione il testo che deciderete voi, così da identificare l’immgine. La “text_changes” mostra quanti pixel sono cambiati, vi aiuta per capire come impostare il parametro “treshold”. La “text_double” se impostata ad “on” renderà un po’ più leggibili le scritte se l’immagine è ad alta risoluzione

1

target_dir /home/pi/Pictures

Questa è la cartella dove verranno salvate tutte le immagini registrate. Se contate di non cancellarle mai è bene che sia un posto sufficientemente capiente, tipo un disco USB

1

[media]_filename

Il nome che viene assegnato al file salvato, io ho lasciato tutto impostato al default

1

stream_port 8091

Volete vedere cosa sta osservando la videocamera? Puntate il browser all’indirizzo http://[indirizzo IP del Raspberry]:8091 ed avrete la risposta. Se non è una cosa che vi interessa, mettete “0” al posto di “8091”. Non so perché, ma su Chrome lo streaming non va, provate con un altro browser prima di impazzire 2 giorni per capire cosa potrebbe non andare bene sulla vostra scheda Raspberry Pi

1
2
3

on_[evento]
on_event_end rm /home/pi/Pictures/*.jpg
on_picture_save python /home/pi/tweepy/tweet.py %f

Questa parte è importante! Cosa deve fare il programma quando succede qualcosa? Il cuore della funzionalità è qui.
Partiamo da “on_picture_save”. Ogni volta che un’immagine viene salvata io eseguo uno script in Python(lo vedremo oltre) che prende l’immagine salvata e la twitta (sì, posta l’immagine su twitter, con un apposito account protetto e citando il mio account principale: nessuno oltre me può vedere quell’immagine). Una volta twittata per me è inutile che questa stia sul Raspberry Pi, pertanto, alla fine dell’evento (dopo i secondi indicati nel parametro “event_gap”) il comando “rm /home/pi/Pictures/*.jpg” cancellerà tutte le foto salvate

Bene, abbiamo il file configurato. Ma dove lo mettiamo? Il file si deve chiamare “motion.conf” e deve stare nella cartella “/home/pi/.motion”. Commentate le righe relative agli eventi “on_[qualcosa]” anteponendo un “;” o un “#”, e impostate l’opzione “daemon” a “off”, salvate il file ed eseguite il programma “/home/pi/motion-mmal/motion”
Nota molto bene: in teoria motion parte digitando “motion” da una cartella qualunque, ma in questo caso non trova la videocamera, almeno nel mio caso.

Se tutto va come deve (no, la prima volta non va mai tutto come deve) il programma partirà, vi dirà che ha attivato la videocamera che he (se lo avete attivato) ha anche attivato il server web per lo streaming, una cosa del genere. Il LED rosso della videocamera si accenderà indicando che è attiva.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[-1242438816] [NTC] [ALL] [Jun 08 11:47:50] motion_startup: Using log type (ALL) log level (INF)
[-1242438816] [NTC] [ALL] [Jun 08 11:47:50] motion_startup: Motion running as daemon process
[-1242438816] [NTC] [ENC] [Jun 08 11:47:50] ffmpeg_init: ffmpeg LIBAVCODEC_BUILD 3482368 LIBAVFORMAT_BUILD 3478785
[0] [NTC] [ALL] [Jun 08 11:47:50] main: Thread 1 is from /home/pi/.motion/motion.conf
[0] [NTC] [ALL] [Jun 08 11:47:50] main: Thread 1 is device: /dev/video0 input -1
[0] [NTC] [ALL] [Jun 08 11:47:50] main: Stream port 8091
[0] [NTC] [ALL] [Jun 08 11:47:50] main: Waiting for threads to finish, pid: 5938
[1] [NTC] [ALL] [Jun 08 11:47:50] motion_init: Thread 1 started , motion detection Enabled
[1] [ALR] [VID] [Jun 08 11:47:50] mmalcam_start: MMAL Camera thread starting... for camera (vc.ril.camera) of 1024 x 768 at 4 fps
[1] [ALR] [VID] [Jun 08 11:47:50] mmalcam_start: MMAL Camera using video capture
[1] [NTC] [VID] [Jun 08 11:47:50] MMAL camera component created
[1] [NTC] [ALL] [Jun 08 11:47:50] image_ring_resize: Resizing pre_capture buffer to 1 items
[1] [NTC] [STR] [Jun 08 11:47:50] http_bindsock: motion-stream testing : IPV4 addr: 0.0.0.0 port: 8091
[1] [NTC] [STR] [Jun 08 11:47:50] http_bindsock: motion-stream Bound : IPV4 addr: 0.0.0.0 port: 8091
[1] [NTC] [ALL] [Jun 08 11:47:50] motion_init: Started motion-stream server in port 8091 auth Disabled

Adesso provate a passare davanti alla videocamera con la mano, voi stessi o banalmente generate un movimento davanti ad essa ed eco che il log vi dirà (sì, il file di log parla ed è buona norma ascoltarlo, sempre) una cosa del genere

1
2
3
4
5
6
7

[1] [NTC] [ALL] [Jun 08 10:52:18] motion_detected: Motion detected - starting event 1
[1] [NTC] [EVT] [Jun 08 10:52:19] event_newfile: File of type 1 saved to: /home/pi/Pictures/01-20140608105218-02.jpg
[1] [NTC] [EVT] [Jun 08 10:52:20] event_newfile: File of type 1 saved to: /home/pi/Pictures/01-20140608105219-00.jpg
[1] [NTC] [EVT] [Jun 08 10:52:21] event_newfile: File of type 1 saved to: /home/pi/Pictures/01-20140608105220-00.jpg
[1] [NTC] [EVT] [Jun 08 10:52:23] event_newfile: File of type 1 saved to: /home/pi/Pictures/01-20140608105221-00.jpg
[1] [NTC] [EVT] [Jun 08 10:52:24] event_newfile: File of type 1 saved to: /home/pi/Pictures/01-20140608105223-00.jpg
[1] [NTC] [ALL] [Jun 08 10:53:23] motion_loop: End of event 1

Terminate l’esecuzione del programma con un bel Ctrl+C andare a vedere nella cartella /home/pi/Pictures/ la presenza dei file salvati. Questi conterranno il movimento rilevato.

(continua…)

Videosorveglianza con Raspberry Pi – Parte prima

Antefatto: qualcuno, dopo avermi sentito parlare per milioni di volte del Raspberry Pi, ha avuto la fantastica e apprezzatissima idea di ordinarne uno con un sacco di accessori per farmelo avere come regalo di Natale. La spedizione ha tardato un po’ e il pacchetto è arrivato giusto per il compleanno (2 mesi dopo). Lì mi si sono accesi gli occhi e i neuroni. Avevo un Raspberry Pi, una videocamera e una scheda USB WiFi. Dovevo farci assolutamente qualcosa! Da questo evento è nato il progetto di cui parleremo in questi sette articoli. Sicuramente non sarà un progetto esente da difetti o errori, ma è il frutto della mia fantasia e dei miei studi notturni di Linux e Python. Spero vi possa interessare e magari essere spunto per vostri progetti più elaborati o che rispettino meglio le vostre esigenze. Alla fine l’importante è divertirsi!

Ok, bando alle ciance! Partiamo!

Premessa importante: questa guida è per chi ha voglia di imparare un po’ sul funzionamento del Raspberry Pi, se volete le cose già fatte, ci sono sul mercato videocamere che assolvono perfettamente al compito una volta accese e collegate alla rete. Se siete un po’ smanettoni e vi va di imparare qualcosa, questo lavoro potrebbe essere per voi.

Specifiche: Voglio poter mettere sotto controllo una determinata zona e voglio che il sistema mi avvisi quando viene rilevato del movimento. Voglio poter comandare il sistema anche quando non sono nelle vicinanze (accenderlo, spegnerlo, sapere se è acceso o meno) e voglio ottenere un’immagine estemporanea surichiesta. Tutto questo deve essere fattibile dallo smartphone e con una relativa semplicità.

Materiale necessario:

  • Scheda Raspberry Pi
  • Alimentatore per Raspberry Pi
  • Scheda WiFi USB
  • Tastiera USB e monitor HDMI (solo per la prima installazione)
  • Videocamera (va anche bene una videocamera USB o una videocamera IP)
  • Scatola con supporto per la videocamera
  • Scheda di memoria SD da almeno 4GB
  • Un account twitter con relativa app sul telefonino

In questa guida assumo che siate già riusciti ad installare Raspbian sul Raspberry e abbiate configurato la rete WiFi con indirizzo IP statico. Aggiornate anche il sistema.

Come prima cosa è necessario attivare la videocamera dalle configurazioni del Raspberry Pi. Adesso si può verificare se la videocamera funziona, inquadratevi, sorridete e date il comando

1

raspistill -o immagine.jpg

Il LED rosso della videocamera si accenderà e dopo 5 secondi la foto verrà salvata nella cartella in cui siete. Questa è già una buona cosa.

Volete vedere l’immagine? Cercatevi un client SCP, collegatevi al raspberry e scaricate l’immagine sul vostro PC per guardarla.

(continua…)