Share
In questo tutorial, ho intenzione di sfruttare la suggestione di Raspberry Pi per costruire un sensore di umidità per un vaso. Sarai in grado di monitorare il sensore localmente sullo schermo LCD o da remoto, tramite ControlMyPi.com, e ricevere e-mail quotidiane se l'umidità scende al di sotto di un livello specificato.
Lungo la strada farò:
Per ottenere il massimo da questo tutorial, è consigliabile acquisire quanto segue:
Dopo aver aggiunto alcuni dollari per i cavi dei ponticelli, il costo totale del progetto si risolve all'incirca a $ 55 senza il display LCD e $ 82 con. Ricorda, però, che stai rifornendo il tuo kit di elettronica: tutte queste parti possono essere riutilizzate per altri progetti.
Se si utilizza il display LCD con l'intestazione di impilamento, collegarlo ora al Raspberry Pi. Le prime due fasi del software non usano il display LCD, ma in questo modo ti risparmieranno un po 'di tempo dopo se lo colleghi adesso.
Avvertenza: un cablaggio errato potrebbe danneggiare il tuo Raspberry Pi. Assicurati di ricontrollare attentamente tutte le connessioni prima di accenderlo.
A sinistra nella foto è possibile vedere i ponticelli rosso e nero che vanno ai binari + e - sulla breadboard. Per aiutare a descrivere le connessioni dall'intestazione, fare riferimento a questa tabella dei colori dei fili. Ogni cella nella tabella fa riferimento a un pin nell'intestazione Raspberry Pi. Il colore della cella corrisponde al colore del cavo jumper come mostrato nella foto:
Collegare il pin 1 alla guida positiva e il pin 6 alla barra di messa a terra.
Importante: il chip deve essere posizionato sopra la valle nella breadboard con l'indicatore pin 1, la rientranza, in alto a destra come nella foto.
Fare riferimento a questa tabella dei colori dei fili e alla scheda tecnica quando si collega questo chip:
Tutte le connessioni dalle rotaie e dalla testata al chip MCP3008 vanno ordinatamente lungo la fila inferiore del chip in questo orientamento. Innanzitutto collegare l'alimentazione e il terreno come mostrato nella foto sopra:
Quindi, collegare i pin dell'header Raspberry Pi SPI al chip:
Il cablaggio del sensore è semplice; ci sono tre connessioni da fare:
Infine, se hai il tuo vaso di piante a portata di mano, puoi inserire la sonda nel terreno ora. Assicurati di non spingerlo troppo in profondità, basta coprire i poli:
Questo progetto è stato realizzato utilizzando Occidentalis v0.2 da Adafruit, fornito con il driver hardware SPI pronto per l'uso. Segui le istruzioni sul sito di Adafruit per installarlo sul tuo Raspberry Pi.
Mancia: Se si utilizza il download Wheezy dal sito Raspberry Pi, sarà necessario trovare e seguire alcuni passaggi per abilitare il driver SPI da soli ...
git - Dovresti già averlo (prova a digitare idiota) in caso contrario, installarlo con: sudo apt-get install git
pip - installalo con: sudo apt-get install python-pip
Tutto il codice per questo progetto è scritto in Python. Abbiamo bisogno di un wrapper Python per il driver SPI in modo che possiamo leggere i valori dal sensore su SPI:
cd ~ git clone git: //github.com/doceme/py-spidev cd py-spidev / sudo python setup.py installa
Avrai già installato la libreria Adafruit durante l'assemblaggio e il test del tuo LCD. Assicurati di conoscere la posizione della libreria in quanto ciò sarà necessario dal codice del progetto.
ControlMyPi è un servizio per creare rapidamente e facilmente pannelli di controllo su Internet dagli script Python Raspberry Pi. Usa pip per installarlo:
sudo pip installa controlmypi
Tutto il codice di questo tutorial può essere scaricato in questo modo:
cd ~ mkdir py cd py git clone git: //github.com/jerbly/tutorials
Dovrai modificare alcuni di questi file per fornire nomi utente, password e percorsi di file. Questo è spiegato mentre andiamo.
L'MCP3008 converte la tensione di ingresso in un numero compreso tra 0 e 1023 (10 bit). È quindi possibile leggere questo valore su SPI (le connessioni verdi e bianche per l'intestazione sul Pi). Il pacchetto py-spidev ci consente di farlo da Python.
C'è una certa complicanza con la lettura di un numero a 10 bit in un sistema a 8 bit. Il driver SPI restituirà due parole a 8 bit e siamo interessati agli ultimi 2 bit della prima parola seguiti da tutti gli 8 bit della parola successiva. Per trasformarlo in un numero con cui possiamo lavorare dobbiamo mascherare e poi spostare a sinistra di 8 i 2 bit della prima parola prima di aggiungere la seconda parola.
Non ti devi preoccupare di scrivere questo codice, perché nel download ho incluso il modulo mcp3008.py per occuparmene. Puoi usare una shell Python interattiva per testare la tua configurazione SPI e il tuo cablaggio in questo modo:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python Python 2.7.3 (predefinito, 13 gennaio 2013, 11:20:46) [GCC 4.6.3] su linux2 Digitare "help", "copyright", "credits" o "licenza" per ulteriori informazioni. >>> import mcp3008 >>> mcp3008.readadc (5) 444
Importante: Devi eseguire Python con sudo in modo da poter accedere al driver del dispositivo SPI.
Se hai problemi, prima controlla il tuo cablaggio. Quindi ricontrollare i passaggi di installazione del software sopra. Se si utilizza il sensore di umidità Octopus, tenere i poli per fare un collegamento con la mano. Altrimenti, probabilmente leggerà solo zero.
Qui è possibile rimuovere il sensore dall'equazione collegando un ponticello dalla barra di alimentazione a, ad esempio, CH1 e quindi utilizzando readadc (1). Questo dovrebbe restituire 1023 (o vicino ad esso). Allo stesso modo, una connessione dal ground rail dovrebbe restituire 0.
Il primo programma estende semplicemente ciò che abbiamo praticato nella console interattiva per includere un ciclo in modo che il valore del sensore sia stampato continuamente:
dal momento dell'importazione importazione del sonno mcp3008 mentre True: m = mcp3008.readadc (5) stampa "Livello di umidità: :> 5" .format (m) sleep (.5)
Si noti che c'è un sonno di mezzo secondo nel ciclo. Questo è così il rendimento del programma; lascia il posto ad altri processi. Altrimenti consumerebbe un sacco di tempo della CPU e altri processi che si stanno eseguendo non si comporterebbero così bene. Una lettura due volte al secondo è probabilmente decisamente troppo, sicuramente per un sensore di umidità.
L'output dovrebbe essere così:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python umido_cmd.py Livello di umidità: 452 Livello di umidità: 486 Livello di umidità: 485 Livello di umidità: 483 Livello di umidità: 489 Livello di umidità: 491 Livello di umidità: 490 ^ CTraceback (chiamata più recente ultimo): file "umid_cmd.py", riga 7, insleep (.5) KeyboardInterrupt pi @ raspberrypi ~ / py / tutorial / umidità $
Basta premere Control-C quando hai finito e il programma uscirà come sopra.
Questo programma migliora la visualizzazione sulla console. Invece di stampare il valore sullo schermo in una finestra a scorrimento, questo script creerà un effetto dashboard. Ogni lettura del sensore è scritta sopra l'ultima, quindi la finestra non scorre.
Anche gli sfondi rossi, gialli e verdi sono usati come luci del semaforo. Quando il terreno è ben irrigato, lo sfondo sarà verde. Quando è troppo secco mostrerà il rosso.
Per ottenere questa colorazione, vengono usati speciali codici di escape ANSI per inviare comandi alla console. Ogni sequenza di codice di escape inizia con \ x1b [seguito dai codici di comando per produrre un effetto.
dal momento dell'importazione importazione del sonno mcp3008 # codici di escape ANSI PREVIOUS_LINE = "\ x1b [1F" RED_BACK = "\ x1b [41; 37m" GREEN_BACK = "\ x1b [42; 30m" YELLOW_BACK = "\ x1b [43; 30m" RESET = "\ x1b [0m" # Cancella lo schermo e posiziona il cursore nella parte superiore della stampa '\ x1b [2J \ x1b [H' print 'Sensore di umidità' stampa '=============== \ n 'while True: m = mcp3008.readadc (5) se m < 150: background = RED_BACK elif m < 500: background = YELLOW_BACK else: background = GREEN_BACK print PREVIOUS_LINE + background + "Moisture level: :>5 ".format (m) + RESET sleep (.5)
Il programma cancella lo schermo e visualizza un titolo. Passa quindi di nuovo nel ciclo perpetuo, ma questa volta utilizza le soglie per determinare il colore di sfondo. Infine, vengono stampate le sequenze di escape e il testo seguiti da a RESET sequenza per spegnere il colore. Il PREVIOUS_LINE il codice di escape viene utilizzato per spostare il cursore su una riga in modo da scrivere ogni volta il valore precedente.
Esegui questo esempio in questo modo:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python moist_ansi.py
L'output dovrebbe essere qualcosa del genere:
Ora ci sposteremo dalla console e visualizzeremo invece i dati del sensore sul display LCD. Prima di continuare con questo tutorial, assicurati di aver creato il tuo Adafruit LCD con l'intestazione di impilamento e lo hai testato seguendo il tutorial di Adafruit.
Il nostro programma utilizzerà la libreria Adafruit, quindi è necessario conoscere il percorso completo di Adafruit_CharLCDPlate directory. Creo semplicemente una directory py sotto la home dell'utente pi per mantenere tutto il codice Python in un posto, quindi sul mio Raspberry Pi il percorso è:
/ Home / PI / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate
Potrebbe essere necessario regolare il seguente script se il percorso è diverso.
Accentsconagua
import sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate') dall'importazione dell'immigrazione da Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 lcd = Adafruit_CharLCDPlate () mentre True: m = mcp3008 .readadc (5) provate: lcd.home () lcd.message ("Livello di umidità: \ n% d"% m) se m < 150: lcd.backlight(lcd.RED) elif m < 500: lcd.backlight(lcd.YELLOW) else: lcd.backlight(lcd.GREEN) except IOError as e: print e sleep(.5) Esegui il programma in questo modo:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python umido_lcd.py
Dovresti vedere la versione LCD del programma della console dei colori. Questa volta gli indicatori di soglia rossi, gialli e verdi utilizzano la retroilluminazione RGB.
In questa sezione useremo ControlMyPi per produrre un dashboard su Internet. Ecco come viene descritto il servizio dalle domande frequenti:
ControlMyPi fornisce un servizio basato sul web per consentire il controllo di semplici script Python da un pannello su Internet. Lo script Python definisce un layout di widget di etichette, pulsanti, indicatori di stato e altro per ControlMyPi da visualizzare. Quando si fa clic su un pulsante, lo script riceverà un messaggio. Se si dispone di uno stato da segnalare, lo script può inviarlo a ControlMyPi in qualsiasi momento e verrà inviato al browser Web.
Se non hai già installato il pacchetto Python, fallo ora. Avrai anche bisogno di un account XMPP. Consiglierei un account Gmail di Google poiché funziona correttamente e verrà utilizzato anche in futuro, quando desideriamo che il nostro script invii un'email. Seguire le istruzioni sul sito Web ControlMyPi per iniziare e testare la connessione.
La prima iterazione della dashboard mostrerà semplicemente un singolo indicatore con la lettura del sensore. Spingeremo una nuova lettura su ControlMyPi ogni 30 secondi per produrre questo:
Lo script per produrre questo è ancora relativamente semplice:
dal momento dell'importazione importazione del sonno mcp3008 da controlmypi import ControlMyPi importazione logging def on_msg (conn, key, value): pass logging.basicConfig (level = logging.INFO) p = [['G', 'umido', 'livello', 0,0,1023]],] conn = ControlMyPi ('[email protected] ',' password ',' umidità ',' Moisture monitor ', p, on_msg) se conn.start_control (): try: while True: m = mcp3008.readadc (5) conn.update_status ('umid': m) sleep (30) infine: conn.stop_control () Nella parte superiore, stiamo ora importando la classe ControlMyPi e il modulo di registrazione. Se è necessario eseguire il debug di qualsiasi problema di connessione XMPP, modificare il livello di registro in DEBUG.
Il funzione on_msg è ciò che verrebbe chiamato se abbiamo definito pulsanti o altri input nel layout del nostro widget. Dato che abbiamo solo un indicatore non c'è input e quindi questa funzione non fa nulla.
L'elenco, p, è dove è definito il layout del widget. Ogni voce nell'elenco definisce una riga di widget da visualizzare sul dashboard. Abbiamo una singola riga con un singolo widget, l'indicatore. Umido è il nome del widget, il livello è l'etichetta da visualizzare sul misuratore, 0 è il livello iniziale, 0 è il livello minimo e 1023 è il massimo.
Lo script crea quindi un oggetto ControlMyPi e si avvia. Qui dovrai fornire il tuo indirizzo Gmail e la tua password.
Mancia: Questa è una connessione sicura ai server di Google; la password non è condivisa con nessun altro servizio. Se sei preoccupato, imposta semplicemente un altro account. In effetti, un account separato è molto utile, soprattutto quando si desidera avere e-mail automatizzate inviate dal proprio Raspberry Pi.
Infine, il loop principale prende il sensore come al solito, ma invece di stamparlo sulla console o sullo schermo LCD, spinge il nuovo valore su ControlMyPi. Gli aggiornamenti sono inviati in una mappa di nome / valore del widget.
Esegui lo script usando sudo come al solito:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python umido_cmp.pia
Alcune informazioni di connessione verranno stampate sulla console, seguito da "Registered with controlmypi". Ora vai su ControlMyPi.com e inserisci il tuo indirizzo Gmail nel modulo:
Clic Trova pannelli per mostrare un elenco di pannelli di controllo associati al tuo indirizzo Gmail. Ce ne dovrebbe essere uno nella lista, Monitor dell'umidità. Fai clic qui per avviare il pannello e vedere i dati in tempo reale inviati dal tuo Raspberry Pi.
Ogni 30 secondi, quando viene eseguita una nuova lettura del sensore, questo valore viene trasferito attraverso la connessione XMPP a ControlMyPi. Spinge quindi questi dati a tutti gli spettatori del tuo pannello (solo tu al momento). Vedrai il calibro muoversi davanti ai tuoi occhi! Se lo desideri, puoi copiare / incollare l'url lungo e inviarlo a un amico per mostrare il tuo monitor dell'umidità. Ora gli aggiornamenti verranno inviati a te e ai tuoi amici.
ControlMyPi ha un numero di widget disponibili per l'uso sulla dashboard. Uno dei più utili per visualizzare i dati è il grafico a linee. Il programma in questa sezione aggiunge un semplice grafico a linee per tracciare le variazioni nel livello di umidità nel tempo. Per iniziare, tracciamo un nuovo punto sul grafico ogni trenta secondi quando prendiamo una lettura.
dal momento dell'importazione importazione del sonno importazione mcp3008 da controlmypi importazione ControlMyPi importazione registrazione importazione datetime def on_msg (conn, chiave, valore): pass def append_chart_point (grafico, punto): se len (grafico)> = 10: del grafico [0] chart.append (point) return chart logging.basicConfig (level = logging.INFO) p = [[[G ',' umido ','% livello ', 0,0,100], [' LC ',' grafico1 ',' Tempo ' , 'Valore', 0,100]],] c1 = [] conn = ControlMyPi ('[email protected] ',' password ',' moistcmp2 ',' Moisture monitor 2 ', p, on_msg) se conn.start_control () : prova: while True: dt = datetime.datetime.now (). strftime ('% H:% M:% S') m = mcp3008.read_pct (5) c1 = append_chart_point (c1, [dt, m]) conn .update_status ('umid': m, 'chart1': c1) sleep (30) infine: conn.stop_control () Nel layout del widget, p, puoi vedere la definizione del widget del grafico a linee dopo il calibro. Il nome del widget è chart1, il asse x è il tempo, il asse y è valore e il max e min i valori sono impostati su 0 e 100.
Mancia: Ho modificato la scala dall'intervallo del sensore grezzo (da 0 a 1023) a un valore percentuale più significativo. Il modulo mcp3008 fornisce una funzione read_pct () per restituire un intero punto percentuale invece del valore grezzo.
Per aggiornare il grafico sul dashboard, è sufficiente inviare un elenco di punti dati a ControlMyPi. I punti dati sono contenuti nell'elenco c1 del programma e ogni punto è costituito da un tempo e un valore. La funzione append_chart_point () è usato per mantenere una lista a rotazione degli ultimi dieci punti, così come ogni nuovo valore arriva il più vecchio viene cancellato. Senza questo il grafico sarebbe cresciuto per sempre.
Esegui lo script usando sudo come al solito:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python umido_cmp2.py
Questo script migliora la versione precedente di:
import sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate') dall'importazione dell'immigrazione da Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 da controlmypi import ControlMyPi import logging import dall'origine datetime import pickle da genericpath import exists lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, chiave, valore): passa def append_chart_point (grafico, punto): se len (grafico)> = 48: del chart [0] chart.append (point) return chart def save (dati): output = open (PICKLE_FILE, 'wb') pickle.dump (dati, output) output.close () def carico (predefinito): se non esiste (PICKLE_FILE): return default pkl_file = open (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () restituisce dati def update_lcd (m): try: lcd.home () lcd.message ("Livello di umidità: \ n% d %%"% m) se m < 15: lcd.backlight(lcd.RED) elif m < 50: lcd.backlight(lcd.YELLOW) else: lcd.backlight(lcd.GREEN) except IOError as e: print e logging.basicConfig(level=logging.INFO) p = [ [ ['G','moist','% level',0,0,100], ['LC','chart1','Time','Value',0,100] ], ] c1 = load([]) readings = [] conn = ControlMyPi('[email protected]', 'password', 'moisture3', 'Moisture monitor 3', p, on_msg) delta = datetime.timedelta(minutes=30) next_time = datetime.datetime.now() if conn.start_control(): try: while True: dt = datetime.datetime.now() m = mcp3008.read_pct(5) readings.append(m) update_lcd(m) to_update = 'moist':m if dt > next_time: # Prendi la media dall'elenco delle letture per arrotondare leggermente il grafico avg = int (round (letture) / len (letture))) readings = [] c1 = append_chart_point (c1, [dt.strftime ('% H:% M '), avg]) save (c1) next_time = dt + delta to_update [' chart1 '] = c1 conn.update_status (to_update) sleep (30) finally: conn.stop_control () Dovresti riconoscere il contenuto del update_lcd () funzione dal programma precedente. Questa funzione è ora chiamata dal loop principale per aggiornare il display LCD su ogni iterazione.
Mancia: Se non hai il display LCD, elimina semplicemente questa funzione e la linea che la chiama. Rimuovi anche il percorso e importa dalla cima e dalla linea lcd = Adafruit_CharLCDPlate ().
Per registrare 24 ore di dati sul grafico a linee, faremo una lettura ogni 30 minuti e mostreremo 48 punti sul grafico. Il append_chart_point () la funzione è stata aggiornata per mantenere 48 punti dati. Nel ciclo principale ora ci sono 30 minuti in futuro nella variabile la prossima volta.
Ogni ciclo controlliamo il tempo corrente contro il la prossima volta. Se siamo passati la prossima volta un punto dati è aggiunto al grafico e la prossima volta viene spostato in avanti di 30 minuti nuovamente. L'uso dell'orologio è un ottimo modo per eseguire azioni in diverse granularità temporali senza dover contare più contatori che contano i loop e così via. Useremo di nuovo questa tecnica nel programma finale per inviare un'e-mail giornaliera.
Come avrai notato, la lettura dal sensore oscilla un po '. Altri tipi di sensori non lo faranno necessariamente, ma questo lo fa. Quindi, invece di prendere una singola lettura e tracciare quella sul grafico ogni mezz'ora, tracciamo la media di tutte le letture effettuate nell'ultima mezz'ora. L'elenco delle letture è utilizzato per contenere tutte le letture, int (round (sum (letture) / len (letture))) calcola la media sul numero intero più vicino. Questo viene quindi tracciato sul grafico.
Il modulo pickle di Python viene utilizzato per salvare e caricare i dati del grafico in un file. Questo semplicemente memorizza la lista c1 nel caso in cui dobbiamo fermare il programma e avviarlo di nuovo. Ad esempio, un riavvio per una sostituzione della batteria. Il salvare() la funzione viene chiamata ogni volta che aggiorniamo il grafico e il caricare() la funzione viene chiamata ogni volta che si avvia il programma.
Esegui lo script usando sudo come al solito:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python umido_cmp3_lcd.py
Lo screenshot mostra ora un grafico molto più fluido:
Per concludere questo progetto, aggiungeremo un ultimo passaggio: email. Possiamo monitorare il sensore dall'LCD e guardare la lettura e la cronologia attuali sul web, ma potremmo dimenticarci di controllarlo dopo un po '. Per coprire questo, avremo il programma per inviare una e-mail una volta al giorno ogni volta che la lettura del sensore è inferiore a un valore specificato.
import sys.path.append ('/ home / pi / py / Adafruit-Raspberry-Pi-Python-Code / Adafruit_CharLCDPlate') dall'importazione dell'immigrazione da Adafruit_CharLCDPlate import Adafruit_CharLCDPlate import mcp3008 da controlmypi import ControlMyPi import logging import dall'origine datetime import pickle da genericpath import esiste import smtplib lcd = Adafruit_CharLCDPlate () PICKLE_FILE = '/home/pi/py/moisture/moist.pkl' def on_msg (conn, chiave, valore): passa def append_chart_point (grafico, punto): se len (grafico) > = 48: del chart [0] chart.append (point) restituisce chart def save (dati): output = open (PICKLE_FILE, 'wb') pickle.dump (dati, output) output.close () def carico (default ): se non esiste (PICKLE_FILE): return default pkl_file = open (PICKLE_FILE, 'rb') data = pickle.load (pkl_file) pkl_file.close () restituisce dati def update_lcd (m): prova: lcd.home () lcd .message ("Livello di umidità: \ n% d %%"% m) se m < 15: lcd.backlight(lcd.RED) elif m < 50: lcd.backlight(lcd.YELLOW) else: lcd.backlight(lcd.GREEN) except IOError as e: print e def send_gmail(from_name, sender, password, recipient, subject, body):"Send an email using a GMail account."senddate=datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d') msg="Date: %s\r\nFrom: %s <%s>\ r \ nA:% s \ r \ nSoggetto:% s \ r \ nX-Mailer: My-Mail \ r \ n \ r \ n "% (senddate, from_name, mittente, destinatario, oggetto) server = smtplib.SMTP ('smtp.gmail.com:587') server.starttls () server.login (mittente, password) server.sendmail (mittente, destinatario, msg + corpo) server.quit () logging.basicConfig (level = logging.INFO ) p = [[[G ',' umido ',' livello ', 0,0,100], [' LC ',' grafico1 ',' Tempo ',' Valore ', 0,100]],] c1 = carico ([ ]) readings = [] conn = ControlMyPi ('[email protected] ',' password ',' umidità ',' Moisture monitor ', p, on_msg) delta = datetime.timedelta (minuti = 30) next_time = datetime.datetime .now () delta_email = datetime.timedelta (days = 1) next_email_time = datetime.datetime.now () se conn.start_control (): try: while True: dt = datetime.datetime.now () m = mcp3008.read_pct () 5) readings.append (m) update_lcd (m) to_update = 'moist': m # Aggiorna il grafico? If dt> next_time: # Prendi la media dall'elenco delle letture per arrotondare leggermente il grafico avg = int (rotondo) (somma (letture) / len (letture))) letture = [] c1 = append_chart_po int (c1, [dt.strftime ('% H:% M'), avg]) save (c1) next_time = dt + delta to_update ['chart1'] = c1 conn.update_status (to_update) #Invia una email? se dt> next_email_time: next_email_time = dt + delta_email se m < 40: send_gmail('Your Name', '[email protected]', 'password', '[email protected]', 'Moisture sensor level', 'The level is now: %s' % m) sleep(30) finally: conn.stop_control() Il send_gmail () la funzione si occupa dell'invio dell'e-mail. Nel ciclo principale, stiamo usando la tecnica di controllo dell'orologio per determinare se è trascorso un giorno dall'ultima volta in cui abbiamo inviato un'e-mail. Se è così, ci imbattiamo in questa volta di un giorno per il prossimo controllo. Successivamente, se il valore di umidità è inferiore a 40, inviamo l'e-mail.
Questo è il programma completo! Eseguilo usando sudo come di solito:
pi @ raspberrypi ~ / py / tutorial / umidità $ sudo python moist_final.py
C'è un'ultima cosa da fare: avviare automaticamente il programma all'avvio. Questo ti permetterà di far girare il tuo Raspberry Pi senza testa. Per fare questo modifica il /etc/rc.local/ file come questo:
pi @ raspberrypi ~ $ sudo pico /etc/rc.local
Aggiungi questa linea al file e salvala:
python /home/pi/py/tutorials/moisture/moist_final.py &
Ora puoi spegnere il tuo Raspberry Pi, spostarlo nell'impianto che stai monitorando, accenderlo e il programma inizierà per te.
In questo tutorial, hai imparato come impostare e utilizzare SPI sul tuo Raspberry Pi per l'uso con un convertitore da analogico a digitale. Quindi hai usato un sensore per monitorare il livello di umidità del terreno in un vaso. Il software ci permette di vedere questo sensore leggendo sulla console, su un LCD, su un indicatore e un grafico su Internet e attraverso una e-mail giornaliera.
C'era molto da imparare, ma ora puoi usare queste tecniche per tutti i tipi di sensori diversi per misurare la temperatura, l'umidità, l'intensità della luce e così via. Potresti collegarlo anche a un accelerometro oa un sensore di distanza a infrarossi. Divertiti!
