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:

http://raspberrywebserver.com

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;

Con CREATE TABLE creiamo la tabella del dbase "temps" che avrà due campi: timestamp di tipo data e ora e temp di tipo numerico (niente di diverso da un banale dbase).

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

poi

sudo 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 sqlite3

import 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()>

notare 'localtime': senza di esso legge l'ora UTC, quindi in italia dobbiamo aggiungere questo parametro.

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

questa è la funzione che legge i dati:

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

c'è una sola linea nel file quindi non serve un ciclo for.

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 cgi

sudo a2enmod cgid
systemctl restart apache2 #(riparte Apache)
sudo nano /etc/apache2/conf-enabled/serve-cgi-bin.conf

cercare questo blocco nel suddetto file:

< Directory "/usr/lib/cgi-bin" >

...

</Directory>

aggiungere qui quanto segue:

AddHandler cgi-script .py

controllate che sia presente il blocco:

Require all granted
Order allow,deny
Allow from all

Lo stesso per la directory /var/www se serve a lanciare i cgi da questa directory.

<Directory "/var/www/">

...

</Directory>

Ricaricare apache2:

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