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:

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…)

Migliorare l’utilizzo di Gmail

Uso Gmail da quando è stata lanciata e si poteva accedere solo con invito. Da quel momento è passata un sacco di acqua (bit) sotto i ponti (router), la casella di posta di Google ha avuto una enorme evoluzione e la uso tutt’ora con grande soddisfazione, al punto da aver preso il servizio a pagamento, senza pubblicità e con 30GB di spazio su Google Drive. La uso con soddisfazione anche in ufficio e consiglierei a tutti di passare a Gmail anche per la posta aziendale (no, non mi hanno pagato per scrivere questo)

Da tempo al uso sul telefono cellulare e per evitare di essere infastidito dai troppi “biip” dovuti a mail magari poco importanti, ma che mi interessa leggere, ho pensato che, dopo essere riuscito a configurare la mail per rendermi ancora migliore l’utilizzo, poteva essere interessante condividere un po’ di trucchetti per avere una casella di posta quasi intelligente.

Leggi tutto “Migliorare l’utilizzo di Gmail”

Torino in auto – Parcheggi

Muoversi a Torino non è così difficile, diventa un po’ più complesso quando si vuole fermare l’auto da qualche parte per poi potersi muovere a piedi. La periferia non ha problemi, parcheggio libero lungo il lato di quasi ogni strada (viali dei corsi grandi esclusi), i problemi iniziano quando si va verso il centro. Il Comune, con una piccola spesa in vernici blu, ha reso una buona parte delle strade cittadine con sosta a pagamento, ovviamente non custodita.

Vi fornisco qui alcune informazioni per spendere meno e per non arrivare impreparati al pagamento della sosta.

  • Girate con tante monete, i parcometri non accettano banconote, ad esclusione dei parcheggi in barriera. Potete però pagare con FastPay (bancomat) o un sacco di app disponibili sul cellulare
  • Attenzione alle tariffe, oscillano da 1,30€ ad ora fino a 2,50€ ad ora, valutate attentamente se potrebbe valere la pena usare il bus
  • La sosta a pagamento lungo la strada è attiva solitamente dalle 8.30 alle 19.30 tutti i giorni, festivi esclusi (il sabato si paga). Alcune zone hanno orari differenti.
  • Ad Agosto ci sono sempre 2 settimane durante le quali la zona blu non è a pagamento, restano a pagamento tutti i parcheggi in barriera
  • I parcheggi in barriera o in struttura sono a pagamento sempre, 24h/24 anche nei festivi, ma le tariffe della sosta cambiano a seconda della fascia oraria. Sono ovviamente più comodi per le soste di cui ignorate la durata, si paga all’uscita in base al tempo di sosta

Non pagare la sosta in zona blu costa la multa oltre al pagamento di tutta la giornata di sosta, non ne vale la pena, ve lo assicuro. Nei parcheggi in barriera evitate di perdere il biglietto rilasciato all’ingresso, potrebbe costarvi fino a 5gg di sosta e inoltre è l’unico modo per entrare nel parcheggio per recuperare l’auto, soprattutto di notte.

Motocicli e ciclomotori non pagano la zona blu per le strade, pagano nei parcheggi in barriera/struttura. Evitate di occupare un posto auto intero con la moto però, non è una mossa molto apprezzata dall’automobilista torinese

Un consiglio: se volete parcheggiare nella zona della ZTL e spendere un po’ meno andate nel parcheggio in Piazza Arbarello (parcheggio Cittadella), costa 1,50€/ora invece di 2.50€ della sosta lungo le strade

Il sito del gestore dei parcheggi (fino ad oggi, pare che tutta la gestione verrà passata a privati a breve), dallo stesso sito è disponibile la situazione dei posti liberi nei parcheggi in struttura/barriera in tempo reale

Se siete dotati del dispositivo NeosPark, Torino è convenzionata. E se non lo avete e la Vs. città lo utilizza, prendetelo che è una comodità ed un risparmio notevole.

Tenere il PC pulito

No, non parlo di polvere, ma di sistema operativo, in particolar modo Windows.

Il primo vero e unico consiglio deriva da una imprescindibile certezza: il cervello del PC è tra la tastiera e la sedia: chi lo sta utilizzando.

Quindi fate funzionare il cervello quando usate il PC e soprattutto prestate molta, moltissima attenzione quando siete su internet. Qui un piccolo e non esaustivo elenco da tenere presente quando ci si addentra nei meandri, anche i più nascosti, di Internet

  • Antivirus sempre aggiornato. Anche quelli gratuiti vanno bene. Ricordate che non vi copre al 100%, come l’ombrello, se c’è vento vi bagnate
  • Installare il plugin “adblock” disponibile per tutti i browser, vi nasconde la pubblicità e i link di download che vi fregano quando cercate un software
  • Se cercate un programma ignorate i siti che forniscono download si ogni cosa (softonic e simili), ma recatevi sul sito del produttore.
  • Inutile dire che i banner pubblicitari non vanno cliccati mai, sopratutto se c’è scritto “clicca qui che hai vinto tutto l’oro del mondo” o proposte tanto allettanti quanto fasulle. Anche i banner pubblicitari con scritto “Download” normalmente vi fanno scaricare schifezze
  • Durante i wizard di installazione non fate il solito Avanti, Avanti, Avanti, Fine. Leggete tutte le finestre e cercate di capire cosa vi stanno chiedendo. Evitate le toolbar, i motori di ricerca predefiniti o le homepage diverse dalla vostra. Evitate anche tutte le offerte o i programmi sponsor. Tutti cercano di affibbiarvi software indesiderato, anche i “grandi e famosi” (Adobe, java, …)
  • Inutile dire che i siti “particolari” (crack, robe illecite, pornografia, …) sono pieni di fantastiche trappole ben mimetizzate. Se dovete proprio accedere a questi siti scaricatevi una distribuzione Linux Live tipo la Ubuntu, avviate il PC con il CD dentro e navigate usando quella, spegnendo il PC non avrete tracce di schifezze in giro e il PC resterà immacolato.
  • Attenzione, sempre. l’avevo già scritto?

E una volta che il PC è stato infestato?

Dipende da cosa vi siete presi, le toolbar si disinstallato dal pannello di controllo senza troppe difficoltà. La home page e il motore di ricerca del browser si reimpostano abbastanza facilmente (ma se poi subito dopo vengono modificate, la cosa è più grave). Si può provare a ripristinare il browser alle condizioni iniziali (tutti i browser hanno quest opzione).

Se queste semplici attività non risolvono potete provare con Combofix a vostro rischio e pericolo (nessuna responsabilità per lo scrivente). Occhio che la pagina di download di combofix è di per sè una trappola

Scaricare COmbofix

La giornata storta dell’informatico

L’ho imparato vivendo questo mondo, raramente un informatico è credente, raramente crede che se le cose funzionino correttamente ci sia un intervento divino e raramente è superstizioso. Anche se è certo del fatto che se una cosa può andar male, sicuramente lo farà. Per questo mette in pratica tutta una serie di meccanismi atti ad evitare che le cose possano andare male.

Poi ci sono le giornate come sabato. Qui ogni certezza cade e si apre una sensazione di terrore: “non è che davvero qualcuno/qualcosa può accedere dove la password di administrator la so solo io giusto per divertirsi ad incasinare tutto?”

Breve riepilogo (per voi se vi interessa, per me a memoria di questa giornata)

Sveglia alle 6 perché la fidanzata deve essere presto in stazione, controllatina alle mail e qui si rivela il primo segno. Una mail riporta: “Francesco, ma ci hanno hackerato il sito?” con un bellissimo screenshot allegato. Ti precipiti (passando dallo stato di assonnato allo stato di “ho già preso 6 caffè e ho più caffeina che sangue nelle vene” in circa due decimi di secondo) a verificare ed effettivamente è così. Sito defacciato, pupazzo che ride, musichetta di sottofondo. Un po’ te lo aspettavi, usando Joomla 1.5 e vari plugin non più supportati. Pazienza, rapida pulita, pagina di cortesia che stamattina non c’è tempo: il treno non aspetta e Torino Comics apre tra 3 ore.

A colazione finisci di controllare le mail, ci sono troppi allarmi di backup falliti, ma non è un cosa bloccante, la controllerai lunedì che c’è tutto il tempo (basta convincersi…)

Arrivi alla stazione, lasci la fidanzata, parcheggi l’auto e ti dirigi verso il centro, che così presto è vuoto e si fanno belle foto. Prendi il telefono e controlli la mail che ti è arrivata prima in auto. Il server critico e fondamentale dell’azienda per cui lavori ha deciso di bloccarsi. Fatturato a rischio. Ninete Tablet, nè PC per poter controllare. Avvisi chi di dovere “sono fuori non riesco ad intervenire subito” e ti dirigi verso l’auto.

Entri, ti siedi giri la chiave. Nulla accade, anzi, le lancette del tachimetro e contagiri iniziano a vibrare e il display si vede fioco fioco. Poi tutto sparisce. Batteria in corto.

Soprassiedo su tutte le brutte parole che mi sono passate per la mente.

Ti incammini verso casa, a piedi, avvisando l’azienda che il server starà spento per parecchio. Nel mentre chiami il meccanico (sono le 8:15 di sabato mattina) che risponde e ti dice che può intervenire.

Torni a casa (sudato marcio) vai dal meccanico, lo porti sul luogo del misfatto, lui ha il booster e l’auto parte. In officina cambia la batteria.

Mentre torni in officina una mail dice “il programma che hai sviluppato per noi e che gestisce tutto il nostro lavoro non funziona più“.

Dovevi andare a Torino Comics, invece chiami il cliente che ti dice “non sono in sede arrivo tra un po’”. Quindi vai a ritirare l’auto, torni a casa sfatto e aspetti la chiamata. Aspetti. Aspetti. Ti scocci di aspettare, entri nella doccia ed il cliente chiama. I due PC con Windows XP hanno deciso a loro insindacabile giudizio che l’accesso alle risorse di rete non è più funzionante. Mille test, ma non se ne esce. Nessuna soluzione trovata al momento.

Fine dei drammi per la mattinata. Riesci ad andare a Torino Comics con la metro senza che questa si fermi al buio a metà galleria. Sono soddisfazioni.

Riesci persino ad andare a prendere la fidanzata alla stazione senza che nessun treno deragli, dovrebbe essere finita…

La Tangenziale di Torino

Nuovo post per chi arriva in città e non sa come muoversi, soprattuto utilizzando la tangenziale.

Innanzitutto è necessario sapere che la tangenziale di Torino, a causa della collina, non fa il giro completo intorno alla città, pertanto inizia e finisce e non è possibile girare in tondo come si potrebbe fare a Roma o a Milano.

Sulle carte stradali sembra che le tangenziali a Torino siano due, la Nord e la Sud, non vi preoccupate, il passaggio da una all’altra è completamente trasparente.

Velocità

La tangenziale di Torino è percorribile, in entrambe le direzioni a 130Km/h, tranne in alcune zone, tipo nei pressi dello svincolo per Bardonecchia, dove il limite è più basso, ma è segnalato. La stessa velocità (130Km/h) si può tenere sul raccordo per Caselle, tranne per le moto che, sul raccordo, hanno un limite impostato a 100Km/h. Non ci sono autovelox fissi, nè tutor (al momento in cui scrivo…)

Costi

La tangenziale è gratuita, tranne se si esce per alcune direttrici importanti. Qui l’elenco

  • da Aosta si paga l’uscita dell’A5, ma non la tangenziale. Andando per Aosta, idem
  • da/per Milano si paga, ultima uscita gratuita: Caselle. Si paga anche arrivando da Aosta e andando direttamente per Milano. Per non pagare la tangenziale il direzione Milano si deve passare per la rotonda alla fine di Corso Giulio Cesare (ma è in città in zona molto trafficata). Per Milano è poi possibile uscire ed entrare gratuitamente fino a Rondissone
  • da/per Bardonecchia/Frejus si paga. Poi si paga dopo Avigliana Ovest e poi a Salbertrand. E’ un’autostrada molto particolare per quello che riguarda il pagamento.
  • da/per Pinerolo si paga. Attenzione che arrivando da Pinerolo, l’ultima uscita (Orbassano) è stata chiusa nel 2006 per evitare di aggirare il casello. Fino a Pinerolo non ci sono altre barriere, quindi si può entrare ed uscire a piacimento in entrambe le direzioni
  • da/per Savona non si paga la tangenziale, ma la prima uscita è dopo il casello dell’A6 a Carmagnola
  • da/per Piacenza si paga, l’ultima uscita gratuita è Corso Moncalieri, se si esce a Vadò, pur essendo poco prima della barriera, anche questa è a pagamento. In direzione Piacenza, prima della barriera, c’è l’uscita di Santena

Evito di mettere le tariffe, cambiano ogni anno e questo post potrebbe diventare vecchio a gennaio prossimo quando le alzeranno, di nuovo.

Punti critici

  • Nei giorni festivi c’è traffico e le code che si formano solitamente sono dall’uscita Sito a Corso Francia in direzione Milano e da Venaria a Collegno in direzione Piacenza
  • L’immissione da Corso Allamano in direzione Milano non ha corsia di accelerazione, è meglio stare in seconda corsia.
  • L’uscita Savonera è in due posti diversi nelle due direzioni. In Direzione Milano è prima di Corso Regina. In direzione Piacenza, anche (fatevi uno schema grafico e vi accorgerete che la mia frase ha perfettamente senso).
  • Lo svincolo del Sito ha un incrocio pericolosissimo e molto trafficato.

Direzioni consigliate

  • Ospedali comodi dalla tangenziale: Rivoli (uscita IV Novembre, direzione rivoli, si arriva in 2 minuti); Maria Vittoria (uscita Regina Margherita, si arriva in 5-7 minuti, occhio all’autovelox sul corso); polo Molinette, Regina margherita, S. Anna (Uscita Unità D’Itala, direzione centro, si arriva in circa 5 minuti, occhio all’autovelox)
  • Stadio della Juventus: Oltre a Venaria potete uscire in Corso Regina, affidarvi al GPS e arrivare allo stadio dall’altro lato, potreste trovare meno traffico
  • Stadio Olimpico: datemi retta. Uscita Stupinigi, parcheggio del Drosso, lasciate l’auto e prendete il 4. All’olimpico parcheggiare è un vero disastro quando ci sono le partite di calcio. Per gli eventi al Palaolimpico stessa uscita e buona fortuna, ma di solito c’è meno disastro.
  • IKEA: uscita Collegno e siete arrivati
  • Centro Commerciale Le Gru: uscita Corso Allamano
  • Capolinea Fermi della Metropolitana: Uscita Collegno
  • Centro città. Da ovunque praticamente. tendenzialmente io uso Regina Margherita per arrivare dietro Piazza Castello o Unità d’Italia per arrivare dal lato del parco del Valentino.

Ovviamente queste sono informazioni valide adesso, dovessero cambiare le cose non sono in alcun modo responsabile. Ma non lo sono neanche se domani mattina vi perdete, prendete un multa o cose così, ok?

Usare robocopy per copiare i profili di Windows 7 e 8

Il comando robocopy è molto comodo per copiare/spostare/sincronizzare intere cartelle. Lo uso spesso per spostare dati tra un PC e l’altro senza usare il comune drag&drop. ma da Windows 7 (non ho provato su Vista in effetti) nel profilo la cartella “App Data” ha dei punti di giunzione che puntano a sé stessa, questo genera un loop incredibile e rallenta la copia in maniera drammatica.

La soluzione è semplice: basta aggiungere l’opzione /XJ al comando di copia. Qui sotto un esempio di comando

robocopy C:\Users\[utente] [nuovo percorso] /e /r:0 /w:0 /xj

Dove

/e -> copia tutte le cartelle, anche quelle vuote
/r:0 /w:0 -> se un file ha un problema di accesso non riprova
/xj -> esclude i punti di giunzione

Se copiate un profilo di un utente riavviate il PC ed accedete con un utente diverso, onde evitare di trovare file bloccati. Fare solo il logoff non è sufficiente

Se avete Windows XP il comando robocopy non è presente nel sistema è necessario prenderlo da questo kit di comandi amministrativi e metterlo in C:\Windows

Nota importante: in nessun modo sono responsabile per danni fatti al Vs PC, ok?

Torino in auto – autovelox

La questione della velocità a Torino è molto sentita e la Polizia Locale fa controlli quotidiani sui corsi e le vie principali.

Innanzitutto è necessario sapere dove sono gli autovelox fissi, che funzionano di giorno e di notte. Sono sempre tutti segnalati.

E poi ci sono gli autovelox gestiti dalla Polizia municipale, questi sono ovviamente piazzati in posti sempre diversi, ma se volete avere un’idea di dove potrebbero essere vi consiglio vivamente di consultare la pagina apposita del Comune di Torino. E’ indicata la via ma non a che altezza, basta stare un po’ attenti.

 

A Torino in auto – viale e controviale

Torino ha una caratteristica a quanto pare poco conosciuta in altre città d’Italia, ci sono i viali e i controviali, dove il controviale non è un posto dove si può andare in contromano, ma possiamo definirlo la “corsia di destra del viale, separata da un marciapiede, dagli alberi o dai binari del tram”. Essenzialmente gli incroci dei viali sono solo i semafori principali, mentre tutte le viuzze sfociano solo nel controviale.

Ma quale senso potrebbe avere questo post? Spiegare ad un non-Torinese che si avventura in città con la propria auto come si deve comportare, per evitare multe, aggressioni verbali o troppo stress.

Innanzitutto non esiste una regola ben precisa che insegna a non impazzire, le due regole principali sono:

  1. Se devi fare un breve tratto di un corso (1-2 semafori) stai nel controviale, se il tratto è lungo stai nel viale centrale
  2. Il passaggio da viale a controviale (e viceversa), ad ogni semaforo è sempre permesso, anche se c’è il cartello che obbliga ad andare dritto (rispettare sempre le precedenze)

Adesso veniamo alle regole generali che in alcuni casi hanno la loro eccezione, giusto per non fare le cose troppo semplici

Nel controviale

  • si deve dare precedenza a destra ad ogni via che si affaccia, ma non in Corso Regina Margherita
  • la svolta a destra ad ogni incrocio è sempre permessa (sensi unici permettendo)
  • la svolta a sinistra al semaforo è permessa solo se è vietato nel viale centrale
  • di solito ai lati si può parcheggiare (occhio ai cartelli)

Nel viale centrale

  • Normalmente è vietata la svolta a destra e quella a sinistra.
  • Se si può svoltare a sinistra c’è la corsia dedicata ed il semaforo con la freccia (sbagliare corsia potrebbe portarvi ad essere oggetto di copiosi insulti)
  • In alcuni corsi il limite di velocità è di 70Km/h invece dei canonici 50
  • Attenzione alle corsie riservate, sono solo per bus, taxi e car sharing, non per le moto. I bus sono dotati di telecamera per fotografare chi la occupa e mandare la multa a casa
  • Alcune corsie sono “promiscue” (linea tratteggiata gialla e non continua), il bus, se c’è, deve essere fatto passare, ma se non c’è si possono liberamente occupare (anche questa è una cosa solo torinese da quello che ho visto in giro)

Spero di aver fatto cosa gradita e di aver reso i vostri giri in città meno stressanti.

Muoversi in Torino con i mezzi pubblici

Come in tutte le grandi città, in Torino, per andare da una parte all’altra, soprattutto al di fuori del centro, è necessario utilizzare un mezzo dotato di ruote e di propulsore, che sia a muscoli o a benzina.

Il servizio di mezzi pubblici in città, cintura e provincia è gestito da GTT. per potersi muovere è necessario essere dotati di biglietti o di carnet. In parole semplici alla prima salita su un qualunque mezzo pubblico in città è necessario bollare il biglietto (o strisciare la tessera del carnet), questo sarà valido per i 90 minuti successivi dandovi la possibilità di saliere e scendere da qualsiasi mezzo. E’ compreso un solo passaggio in metropolitana. Il biglietto ordinario al momento costa 1,50€. Se non ce l’avete potete salire sul mezzo pubblico e comprarlo dalla macchinetta rossa a bordo, al prezzo di 2,50€ (monete contate, senza resto). Non bollare ed essere beccati ha un prezzo superiore a 100€, lo sconsiglio.

Una nota che riguarda il carnet per più corse. Permette di risparmiare sul singolo biglietto, ma non permette l’utilizzo contemporaneo di più biglietti per più persone, quindi se siete in 4 potete bollare 4 biglietti singoli, oppure dovete avere un carnet di 5 o 15 corse a testa.

Ci sono anche molte opzioni per durate più lunghe (4h o giornate intere), qui tutti i dettagli.

Il servizio di mezzi pubblici torinese è integrato in Google Maps, pertanto, se siete dotati di smartphone (o di connessione ad internet, per la pianificazione), aprite l’applicazione, vi localizzate, trovate la fermata più vicina e avrete accesso agli orari dei passaggi calcolati in tempo reale oppure al calcolo automatico dei percorsi in base alla posizione dei mezzi sulla rete. Se invece avete un telefono “semplice”, ad ogni fermata c’è un numero identificativo ed un numero di cellulare, mandate un sms e vi tornerà un messaggio con i prossimi passaggi dei mezzi da quella fermata. Da gennaio 2016 c’è un bot di Telegram (@gttorari_bot)che vi permette di sapere gli orari dei passaggi in tempo reale e l’ubicazione delle rivendite di biglietti nelle vicinanze

la rete dei mezzi pubblici è molto attiva dalle 7 alle 20, prima o dopo i passaggi sono più diradati, informatevi prima di muovervi a tarda sera o la mattina all’alba. non ci sono mezzi solitamente dall’1 di notte alle 3 del mattino. Il sabato sera esiste una rete speciale, denominata Night Buster con alcune linee di autobus che viaggiano fino alle 5 del mattino dal centro verso la periferia.

la Metropolitana automatica, in una sola linea, è da provare, anche se non ne avete bisogno. Salire sul treno e vederlo viaggiare senza autista fa un certo effetto. Soprattutto se siete nella prima carrozza e guardate i binari ed il tunnel davanti a voi. Qui gli orari

La mappa dell’intera rete le trovate appesa (quasi) ad ogni fermata, a questo link

Attenzione che nei festivi la rete dei mezzi cambia leggermente.

Torino panoramica

Ed eccoci ad un altro post sulle cose interessanti da vedere/fare a Torino. Come quasi ogni città ci sono dei posti che permettono di vederla dall’alto, in tutto il suo splendore e dove ci ci può divertire a trovare i corsi principali, i monumenti, la Mole Antonelliana, il nuovo e “bellissimo” grattacielo… Vi presento un po’ di luoghi e qualche dritta per arrivarci.

Mole Antonelliana

E’ il monumento più alto di Torino e non è superato neanche dal nuovo grattacielo ancora in costruzione. Si può salire con il bellissimo ascensore che pare sollevarvi nel vuoto, visto che è tutto in cristallo e passa in mezzo alla maestosa cupola (dentro la quale c’è il Museo Nazionale del Dinema, assolutamente da vedere). Dalla cima si può vedere tutta la città, dalle montagne che le fanno da cornice a nord e a ovest fino alla collina a sud-est. Se andate la mattina avrete buona visuale sulle Alpi e pessima sulla collina, la sera viceversa, con il tramonto dietro le montagne. L’ascensore costa 6€ ed è aperto tutti i giorni tranne il lunedì. Abbandonate l’idea di arrivarci in auto, è in una zona pedonale e molto centrale. Usate il bus oppure parcheggiare in Piazza Vittorio Veneto (parcheggi sotterranei) e fate 4 passi in via Po per raggiungerla.
Vista di Torino dalla Mole Antonelliana

Leggi tutto “Torino panoramica”

Parco della Pellerina

Torino ha molti parchi all’interno della città, non saranno grandi come Central park a NYC, ma riescono comunque a dare grandi soddisfazioni. Uno di questi è il Parco della Pellerina.

View Larger Map

Moltissimi sentieri liberi da auto immersi in boschi e prati vi isolano completamente (o quasi) dai rumori della città, ideale per un po’ di relax o un pic-nic nel fine settimana (ma dovete arrivare presto, soprattutto in estate). Sede temporanea di circo e giostre e con due laghi e uno stagno naturale, creatosi nell’alluvione del 2001, pieni di fauna. Per i bambini è una meta molto interessante.

Ci sono aree per i cani, aree gioco per i più piccoli, qualche bar, panchine al sole o all’ombra, una pista di pattinaggio.

Se voltete riposare un po’ dopo aver camminato in lungo ed in largo questo è il posto giusto

E se avete la passione della fotografia è un posto per ogni tipo di foto, dai colori mutevoli con le stagioni e con tramonti che difficilmente un altro posto in città vi potrebbe dare.

Se volete fare un giro in bici è il parco più adatto, ogni viale è percorribile senza problemi, tranne dopo grandi piovute visto che la maggior parte sono viali sterrati. Si può arrivare in bici dalla lunghissima ciclabile che lo collega con il Parco Ruffini (più piccolo e più asfaltato della Pellerina).

Come tutti i parchi è da evitare dopo il tramonto.

Parcheggio gratuito lungo tutto il perimetro, durante i giorni di giostre e nei fine settimana estivi trovare parcheggio sarà un po’ difficile.

Lo stai facendo sbagliato

Azienda con 200 persone, molte delle quali usano il PC per lavorare collegandosi ad un server dove è installato il gestionale. Se il server si ferma, possono tutti giocare al solitario, anche se è stato rimosso da tutti i PC.

Questo server, fondamentale per l’azienda ha indirizzo IP 192.168.1.1. Nessun problema, all’interno di una rete un IP vale l’altro. E invece no.

Il server smette di funzionare, ma risponde correttamente al PING. Come se tutte le connessioni fossero chiuse, nessuno lo raggiunge più. Vabbè, lo riavvii. Niente. non riesci a collegarti neanche per la gestione. Ti alambicchi il cervello e poi decidi di avviare il network scanner per capire quali porte sono rimaste chiuse sul server. Fai la scansione e ti accorgi che il nome del server “PRODUZIONE” è diventato “ALICEMODEM”.

ALICEMODEM. ALICEMODEM!!!! (parolacce a piacere a profusione)

Apri l’interfaccia web e in effetti un fantastico modem di Alice ti chiede la password di accesso. Scrivi “admin” ed entri.

Per i non avvezzi alle questioni di rete faccio una piccola spiegazione. In una rete gli indirizzi IP devono essere univoci, non è ammesso un indirizzo IP duplicato, se no i pacchetti di dati non sanno dove andare. Immaginate se vi dicessero di andare in via Roma 15 e il navigatore vi chiedesse “in via roma 15 o in via roma 15?” non sapreste dove andare. Altra nozione tecnica: solitamente i router che di mettono a casa per la connessione ad internet hanno indirizzo IP assegnato pari a 192.168.1.1. Avete fatto 1+1?

Ecco questo è il problema. Ma non il solo. Perché un normale router ha anche una funzione che si chiama “DHCP server“; quando un PC viene acceso lui si presenta in rete e chiede “che indirizzo devo utilizzare?” il DHCP server gli risponde “Usa questo indirizzo: 192.168.1.x” e il PC lo usa. Ma se i DHCP server in rete son due, chi assegnerà l’indirizzo? Il primo che capita. Quindi indirizzi duplicati in giro per tutta la rete.

Dove eravamo rimasti? Ah, sì, entrato con la password “admin”. Fatto accesso alle impostazioni di rete, cambiato l’indirizzo IP in uno completamente diverso tipo 192.168.252.15 e disabilitato il DHCP. Salvate le impostazioni e magicamente il server “PRODUZIONE” ha ripreso a funzionare.

L’idea di dare al server più importante dell’azienda l’indirizzo 192.168.1.1 non è stata proprio furba, ma se becco chi si è portato il proprio router di casa in azienda attaccandolo alla rete gli vorrei tanto riservare uno speciale trattamento.

 

L’ho comprato ed è mio. Invece no

Parliamo di materiale digitale ovviamente. la cosa mi sembra alquanto grave ed è bene sottolineare come si sta muovendo il mercato.

Nell’era pre-iTunes/amazon/etc se volevo compare musica, mi recavo in negozio, sceglievo il CD, pagavo e me lo portavo a casa. E’ mio! Che ci faccio se è mio? Lo ascolto milioni di volte, su qualunque dispositivo, anche lo stereo di un amico, lo posso prestare e in ogni caso, fino a quando non lo getterò via, il CD resterà nella mia collezione.

Adesso è più facile, basta aprire il programma, dare il numero di carta di credito e scegliere il CD (che non è più un CD) da scaricare. Pago, in pochi minuti lo scarico ed è mio! E invece… no. La “sottile differenza” è che non è mio, ma il venditore me ne concede l’uso in licenza, come se me lo noleggiasse a tempo indeterminato. ma se lo voglio prestare ad un amico non posso, non posso ascoltarlo in un dispositivo non registrato a nome mio e non potrò tenerlo per sempre nel mio scaffale digitale. perché se il venditore lo desidera, me ne può togliere il diritto d’uso ed io non lo avrò più. Senza avere i soldi indietro, ovviamente.

La stessa cosa vale per i libri, come venuto alla ribalta con il recente caso di Amazon che ha cancellato un account senza addurre motivazioni e, di fatto, cancellando tutti i libri comprati senza restituire i soldi spesi. Il caso in questione è fumoso e non chiarissimo, ma il concetto basilare è il seguente: Mi paghi, ti concedo di leggere il libro e, a mio insindacabile giudizio, posso toglierti il libro senza rimborso. E tu non potrai farci nulla.

E’ come dare le chiavi di casa al libraio, in modo che lui possa venire in qualsiasi momento in casa tua a riprendersi il libro. Paura?

Come fare per evitare tutto questo?

  1. Non compare più nulla di digitale e tornare al vecchio stile
  2. Comprare in digitale e togliere il DRM, che è il sistema che permette al venditore di riprendersi un file che ti ha ceduto in licenza.

Il secondo punto non è legale, che sia chiaro. Ma permette di mettersi al riparo dalla “restituzione forzata”