LE TEMPERATURE LETTE DAL CLOCK-ALARM SUL WEB PARTE I
in questa prima parte mostrerò come configurare il raspberry per accedere dal web ai dati letti dalla sveglia e interrogare questi stessi dati. per arrivare a questo risultato ho seguito le istruzioni di questo sito:lo voglio segnalare, oltre che per questo progetto da cui ho tratto quanto segue (e ringrazio amichevolmente per la possibilità di utilizzare), anche per altri aspetti inerenti il raspberry (ma applicabili a tutto linux) che vengono spiegati in maniera veramente facile e dettagliata.
Questi sono gli step necessari:
1. creazione di un database in cui archiviare le letture della/delle temperature.
2. creazione di una interfaccia web accessibile dall'esterno per vedere ed interrogare il database. Per ottenere ciò si deve creare uno script CGI (common gateway interface), un programma che permette ad un web server di interfacciarsi con un'applicazione.
In previsione di rendere il raspy un web server, prima di tutto bisogna premunirsi di password. Il raspi una volta installato ha come utente pi e password raspberry. Bisogna quindi cambiare la password con una nostra ma non finisce qui. Infatti anche se cambiamo la password quando facciamo un sudo non ci viene chiesta. Ciò è dovuto al fatto che in /etc/sudoers c'è questa riga (in stretch è invece sudo nano /etc/sudoers.d/010_pi-nopasswd):
pi ALL=(ALL) NOPASSWD: ALL
con visudo (sudo visudo) bisogna cambiare questa riga con
pi ALL=(ALL) PASSWD: ALL
Inoltre conviene entrare come root (sudo su) e dare una password di root ($ passwd) visto che di default root non ha password.
1. Si comincia da apache2.
si può seguire la guida RPi Apache2 che è ben fatta.
si crea il gruppo www-data (non presente di default nelle prime versioni ma ora già presente):
sudo addgroup www-data
e si aggiunge www-data a questo gruppo.sudo adduser www-data www-data
quando si installa apache2 viene creata la dir /var/www ma assegnandola al group root, allora si consiglia di crearla in anticipo assegnandola a www-data:sudo mkdir /var/www
sudo chown -R www-data:www-data /var/www
adesso si può installare apache2:sudo apt-get update
(sempre prima di una installazione)sudo apt-get install apache2
adesso abbiamo apache2 sul raspi, facciamo un po di test e se tutto ok, passiamo al dbase.2. Ora si deve installare sqlite3
Si tratta di un dbase leggero e ottimo per il raspi:
sudo apt-get install sqlite3
poi si crea il nostro database, editandolo la prima volta:sqlite3 "miodbase".db
comparirà il prompt sqlite> dovrete scrivere maiuscolo:
BEGIN;
CREATE TABLE temps (timestamp DATETIME, temp NUMERIC);
COMMIT;
Per uscire si scrive:
.quit
Ora mettiamo il dbase in /var/www e rendiamo proprietario www-data:sudo cp weather.db /var/www/
Per dare i permessi di scrittura, prima:sudo chown www-data:www-data /var/www/weather.db
poisudo chmod 777 -R /var/www/, per permettere la scrittura.
a questo punto dobbiamo creare uno script che ad un intervallo scelto da noi, leggerà la temperatura e la metterà nel dbase con la data e ora. Useremo crontab.Ora creiamo lo script che chiamo "logger.py"
#!/usr/bin/env python
importo i moduli necessari:import sqlite3
lo script dovrà accedere a sqlite3import os
questo modulo è sempre presente, leggeremo una data e ora:import time
creiamo l'oggetto dbname a cui ci riferiremo:dbname ='/var/www/weather.db'
creiamo la funzione che ci connette al dbase e mette i valori letti in esso:def temp_store(temp):
conn=sqlite3.connect(dbname)
curs=conn.cursor()
curs.execute("INSERT INTO temps values(datetime('now','localtime'), (?))", (temp))
conn.commit()
conn.close()>
Questo invece serve solo a stampare il contenuto del dbase per un controllo:
def data():
conn=sqlite3.connect(dbname)
curs=conn.cursor()
for row in curs.execute("SELECT*FROM temps"):
print(str(row[0])+" "+str(row[1]))
conn.close()
base_dir = '/sys/bus/w1/devices/'
device1_folder = glob.glob(base_dir + '28*')[0]
device1_file = device1_folder + '/w1_slave'
def read_temp1_file():
f = open(device1_file, 'r')
lines = f.readlines()
f.close
return lines
def read_temp():
lines = read_temp1_file()
while lines[0].strip()[-3:] != 'YES':
time.sleep(2)
lines = read_temp1_files()
t_pos = lines[1].find('t')
if t_pos != -1:
temp1_string = lines[1][t_pos +2:]
temp1 = float(temp1_string)/1000
tnum = round(temp1, 1)
return tnum
ora che abbiamo messo le funzioni necessarie possiamo creare il main:
def main():
temperature = read_temp()
if temperature != None:
temp_store(temperature)
else:
time.sleep(20)
temperature = read_temp()
temp_store(temperature)
if __name__=="__main__":
main()
Leggiamo i dati, "temperature" è il risultato della funzione read_temp(). Se questo numero letto è diverso da None, mettiamolo nel dabase, se non esiste aspettiamo 20 secondi e rileggiamolo.
La funzione "data" serve per vedere cosa è scritto nel dbase, si può attivare all'occorrenza. Anche time.sleep non servirà se lanceremo questo script con crontab. In questa routine decideremo quale deve essere l'intervallo.
Facendo le prove si metteranno dei dati che non serviranno, soprattutto se fate le prove senza collegato realmente i sensori, come nel mio caso. allora per cancellare e ripulire il dabse:
sqlite> DELETE FROM temps;
3. Dobbiamo configurare apache2 per eseguire gli script cgi.
Questo comando serve ad abilitare il modulo del cgisudo a2enmod cgid
systemctl restart apache2 #(riparte Apache)
sudo nano /etc/apache2/conf-enabled/serve-cgi-bin.conf
< Directory "/usr/lib/cgi-bin" >
...
</Directory>
AddHandler cgi-script .py
controllate che sia presente il blocco:Require all granted
Order allow,deny
Allow from all
<Directory "/var/www/">
...
</Directory>
systemctl restart apache2
ora passiamo al crontab:$ sudo crontab -e
serve ad editare il crontab come user root in modo da non essere necessario mettere sudo nel comando di crontab.*/60 * * * * python3 /"directory"/logger.py
Aggiungiamo la riga sopra al file. io ho scelto l'esecuzione di logger.py ogni ora (60 minuti). Per provare però consiglio di mettere due minuti e vedere se scrive nel dbase. Dopo si può editare mettendo un'ora. Attenzione agli spazi tra gli asterischi!Salvare il crontab con ctrl+O + enter ed uscire da nano (è l'editor predefinito) come al solito.
Ora è tutto pronto per scrivere lo script che verrà lanciato dal cgi entrando in un browser. Vediamo a pagina due:
pagina 3 del talking alarm clock on the web