Alla scoperta del futuro - Codinglife.it
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
Alla scoperta del futuro
Una serra domotica per un’agricoltura migliore e più produttiva
Dopo anni di studio e di prove sono arrivato ad una parziale conclusione di questo progetto, che avrà
sicuramente un proseguo per quanto riguarda sia la struttura hardware che la parte software. Con il
passare degli anni ho appreso nuove abilità e diverse tecniche che mi hanno permesso di raggiungere
questo piccolo, ma grande obbiettivo. In questo semplicissimo foglio elettronico voglio illustrarvi e provare
ad insegnarvi qualche piccola nozione per realizzare dei progetti utili ad uno scopo.
Perché proprio l’agricoltura?
L’agricoltura e l’informatica sono da sempre due grandi passioni trasmesse dalla mia famiglia, in particolare
da mio nonno che fin da piccolo mi ha insegnato l’arte di amare la terra. Ho voluto sperimentare qualcosa
di nuovo e che possa servire, nel corso degli anni, a rendere questo settore più tecnologico in modo da
permettere un’agricoltura più sana e molto più produttiva.
In che modo più produttiva?
Partiamo dal presupposto che, ad oggi, sono presenti sul territorio italiano milioni di serre che permettono
alle colture di crescere in maniera molto rapida. Tutto questo avviene però utilizzando dei prodotti chimici
che sono, spesso e volentieri, nocivi per l’uomo. Il progetto “serra intelligente” vuole andare a creare, senza
l’utilizzo di sostante terze, il microclima perfetto che permette alle colture di nascere in maniera rapida e
quindi più produttiva senza intaccarne il gusto e le sostanze nutritive presenti all’interno delle colture.
Ma ogni pianta ha il suo microclima e va rispettato per una crescita regolare.
Ovviamente, prima di realizzare un progetto, devono essere valutate tutte le possibili variabili. Una serra
infatti può contenere diverse colture nel corso del tempo. Attraverso il sistema informatico realizzato e
gestito con l’impiego dei linguaggi:
• Di programmazione PHP e Python
• di sviluppo e realizzazione del sistema di gestione web Bootstrap, HTML e CSS
• di memorizzazione dei dati MySQL
permetto all’utente di selezionare la coltura presente all’interno della serra e al sistema di adattare il
microclima in maniera corretta e consona alla pianta che viene innestata.
Quali sono le variabili prese in considerazione per la creazione del microclima
corretto?
Pensiamo alla natura. Sole, temperatura, umidità e il terreno. Quattro variabili fondamentali per una
corretta crescita della pianta. La serra è dotata di diversi sensori che, attivando delle componenti come
delle ventole, dei led, una pompa per l’irrigazione e il riscaldamento, fanno si che la pianta raggiunga uno
stato di benessere tale da farla crescere rapidamente, andando ad aumentare la produttività, consolidando
il nostro obbiettivo.
In che modo avvengono i controlli all’interno della serra?
La mente che controlla tutto è il Raspberry Pi 4. Questo piccolo computer è in grado di funzionare in
maniera tale da gestire e regolare l’andamento della serra tramite uno script in Python. Attraverso il
programma andiamo ad effettuare tutti i controlli necessari, ogni tot minuti, in modo da analizzare, tramite
dei grafici, la crescita della pianta. Esso però ospita anche il nostro web server attraverso il quale
visualizzeremo i valori principali (temperatura, umidità e soil moisture) in diretta in modo da essere a
conoscenza della situazione interna della serra.
È necessario conoscere l’informatica e il mondo della programmazione?
Partiamo dal presupposto che per creare il sistema di gestione di una serra non è stato semplice, anzi. Il
percorso di studi mi ha aiutato molto sotto tutti i punti di vista, dalla creazione del web server fino alla
realizzazione della parte sotware di controllo, per intenderci lo script Python e la parte di PHP che, assieme
a Bootstrap formano il sito web. Col proseguo di questa piccola guida vi elencherò tutte le parti di codice
necessarie quindi più sarà la vostra volontà di imparare cose nuove e più questo tipo di applicazioni
saranno di facile creazione.
Come si struttura la serra?
La struttura della serra è stata progettata seguendo degli accorgimenti ben precisi:
• L’aria calda tende a restare nella parte superiore dello spazio quindi ho installato due ventole da pc
da 12 cm in modo che una di esse prelevi l’aria calda mentre l’altra permette il circolo dell’aria
esterna;
• Il sensore di temperatura è stato installato all’interno di una scatola di derivazione a circa metà
dell’altezza della serra in modo tale da prelevare il dato in corrispondenza della pianta;
• Tutta la componentistica, comprendente anche l’alimentatore a 12 v, è stata messa all’esterno
della serra in modo tale da evitare che l’acqua dell’impianto di irrigazione ne comprometta il
funzionamento;
• Tutti i componenti sono stati protetti da scatole di derivazione, protezioni e tubi adatti a svolgere
un corretto isolamento in modo tale da non creare corti circuiti che andrebbero a danneggiare la
scheda e i sensori;
• È stata installata una piccola ventola all’interno del Case di protezione del Raspberry Pi in modo da
contenere la temperatura della CPU.
Cosa si può trarre da questo tipo di progetto?
Creare progetti di questo tipo ci permette di sviluppare nuove abilità sia in ambito software e informatico,
sia nelle attività manuali come l’utilizzo di elettroutensili e strumenti che serviranno nel tempo.
Di cosa ho avuto bisogno?
Per realizzare la serra ho utilizzato una serie di componenti elettronici utili a raggiungere lo scopo finale del
progetto:
• Raspberry Pi – il cervello del nostro sistema automatizzato. All’interno di esso ho installato
Raspbian, un sistema operativo open source molto intuitivo da utilizzare;
• Dht11 – sensore di temperatura e umidità;
• Sensore di umidità del terreno;
• Fotoresistenza;
• Cavi per il collegamento dei vai dispositivi;
• Luci a led;
• Alimentatore 12v;
• Pompa per irrigazione;
• Ventole da PC;
Questi sono i principali componenti che costituiscono la serra.
Come faccio a costruire la serra?
Non realizzerò una guida specifica sulla creazione della serra. Questo perché la scelta dei materiali, la
grandezza della stessa e i vari dettagli che la compongono sono dettati dagli spazi e dalle opportunità che
ognuno di noi dispone. Avendo una stanza libera all’interno di casa mia ho potuto realizzare una piccola
serra dalla lunghezza di 1 metro e alta ben 70 cm. Con un po’ di ingegno e manualità sarete voi a creare la
vostra serra personalizzata. Non ci saranno problemi in caso avessimo un tipo di serra differente perchè la
componentistica rimane la stessa.
Installiamo Raspbian all’interno del nostro Raspberry
Dopo aver capito gli obbiettivi di questo progetto iniziamo a vedere come realizzarlo in maniera pratica.
Prima di tutto dobbiamo dare vita al nostro mini computer. Per fare ciò sarà necessario avere a
disposizione una scheda sd da almeno 8 gb sulla quale andrà installato il sistema operativo Raspbian.
L’immagine ISO la scarichiamo direttamente dal sito ufficiale e attraverso un programma come Balena
Etcher lo installiamo sulla sd. Una volta fatto ciò possiamo collegare il Raspberry alla corrente solo dopo
aver inserito la scheda sd all’interno dello slot corretto.
Realizziamo lo script Python
Per realizzare lo script Python che permetterà di avviare il tutto ho preferito scrivere le righe di codice non
via SSH come molti farebbero, quindi attraverso il comando nano (Linux Bash Shell), bensì caricare
successivamente il file via FTP direttamente al Raspberry tramite il programma Filezilla.
Lo script è composto da diverse righe di codice, esse infatti, servono per gestire la parte di caricamento dei
dati dalla serra al database MySQL. Attraverso il connettore al database messo a disposizione da Python è
possibile, dopo aver creato il database direttamente da interfaccia grafica PhpMyAdmin, collegarsi ad esso
e tramite query inserirevi i dati di temperatura, umidità e umidità del terreno.
Tutto ciò ci permetterà in seguito di estrapolare i dati e analizzarli tramite i grafici visibili sul nostro sito web
locale. Il file in Python inoltre ci permette di effettuare determinati controlli che condizioneranno o meno
l’avvio dei vari componenti che serviranno a creare il giusto microclima all’interno della serra.
1. #!/usr/bin/env python3
2. # -*- coding: utf-8 -*-
3.
4. ########## IMPORTIAMO LE LIBRERIE CORRETTE ##########
5. import sys
6. import urllib2
7. import Adafruit_DHT
8. import mysql.connector
9. import time
10. import Adafruit_GPIO.SPI as SPI
11. import Adafruit_MCP3008
12. import RPi.GPIO as GPIO
13. from numpy import interp
14.
15. ########## DEFINIAMO I PIN DI COLLEGAMENTO ##########
16.
17. pin_rele_ventole = 16
18. pin_rele_pompa = 26
19. pin_rele_luci = 27
20. pin_rele_riscaldamento = 6
21.
22. ########## QUERY PER DETERMINARE LE SOGLIE ##########
23. conn = mysql.connector.connect(user='root', password=’*****’, host='localhost', data-
base=’****’)
24. cursore = conn.cursor()
25.
26. cursore.execute("SELECT temp,hum,suolo FROM piante WHERE selected=1")
27.
28. row = cursore.fetchone()
29. temp = row[0]
30. hum = row[1]
31. soil = row[2]
32.
33. soglia_temp_max = temp + 5
34. soglia_temp_min = temp - 10
35. soglia_umidita_terreno = soil
36. soglia_minima_luci = 30
37.
38. ########## EFFETTUIAMO UN TEST DI CONNESSIONE ##########
39. def connessione_test():
40. try:
41. conn = mysql.connector.connect(user='root', password=’*****’, host='localho-
st', database=’****’)
42. except Exception as e:
43. print("Connessione al database fallita", e)
44.
45.
46. def inserimento_dati(data, temp, hum, suolo):
47. try:
48. conn = mysql.connector.connect(user='root', password=’*****’, host='localho-
st', database=’****’)
49. cursore = conn.cursor()
50. ########## QUERY INSERIMENTO DATI IN DATABSE#########
51. sql = " INSERT INTO dati (data, temp, hum, suolo) VALUES (%s, %s, %s, %s)"
52. ########## VALORI DA INSERIRE ###########
53. valori = (data, temp, hum, suolo)
54. cursore.execute(sql, valori)
55. print('Record inseriti correttamente')
56. conn.commit()
57.
58. except Exception as e:
59. print("Inserimento dati fallito", e)
60.
61.
62. def controllo_DHT():
63. sensor_DHT = Adafruit_DHT.DHT11
64. pin = 22
65.
66. humidity, temperature = Adafruit_DHT.read_retry(sensor_DHT, pin)
67.
68. if humidity is not None and temperature is not None:
69. print('temp={0:0.1f}*C Hum={1:0.1f}%'.format(temperature, humidity))
70.
71. ######### CONTROLLO CHE LA TEMPERATURA NON SUPERI LA SOGLIA ########
72. if temp > soglia_temp_max:
73. GPIO.output(pin_rele_ventole, GPIO.LOW)
74. ######## CONTROLLO CHE LA TEMPERATURA NON VADA AL DI SOTTO ########
75. elif temp < soglia_temp_min:
76. GPIO.output(pin_rele_riscaldamento, GPIO.LOW)
77.
78. return temperature, humidity
79.
80.
81. def controllo_SOIL():
82. SPI_PORT = 0
83. SPI_DEVICE = 0
84. mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
85. value = mcp.read_adc(0)
86.
87. terreno_umidita = conversione( value, 0, 1023, 100, 0)
88. print ('Umidita : {0}% '.format(terreno_umidita))
89.
90. if terreno_umidita < soglia_umidita_terreno:
91. GPIO.output(pin_rele_pompa, GPIO.LOW)
92. time.sleep(10)
93. GPIO.output(pin_rele_pompa, GPIO.HIGH)
94.
95. return terreno_umidita
96.
97.
98. ######## MAP DEI VALORI PER RENDERLI LEGGIBILI ########
99. def conversione(x, in_min, in_max, out_min, out_max):
100. return (x-in_min)*(out_max - out_min) / (in_max - in_min) + out_min
101.
102. def controllo_luce():
103. SPI_PORT = 0
104. SPI_DEVICE = 0
105. mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
106. valore_luce = mcp.read_adc(7)
107.
108. luce = conversione(valore_luce, 0, 1023, 0, 100)
109. print ('Luce: {0} '.format(luce))
110.
111. time.sleep(0.5)
112.
113. if luce < soglia_minima_luci:
114. GPIO.output(pin_rele_luci, GPIO.LOW)
115.
116.
117.
118.
119.
120.
121.
122.
123.
124. def lettura_sensori():
125. try:
126. timenow = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
127. time.sleep(0.5)
128. temperatura, umidità = controllo_DHT()
129. time.sleep(0.5)
130. terreno_umidita = controllo_SOIL()
131. time.sleep(0.5)
132. controllo_luce()
133.
134. inserimento_dati(timenow, temperatura, umidità, terreno_umidita)
135.
136. except:
137.
138. print('lettura fallita')
139.
140.
141. GPIO.setmode(GPIO.BCM)
142. GPIO.setwarnings(False)
143.
144. GPIO.setup(pin_rele_ventole, GPIO.OUT, initial=GPIO.HIGH)
145. GPIO.setup(pin_rele_pompa, GPIO.OUT, initial=GPIO.HIGH)
146. GPIO.setup(pin_rele_luci, GPIO.OUT, initial=GPIO.HIGH)
147.
148. connessione_test()
149. lettura_sensori()
Questo è lo script indentato e correttamente eseguito. Come è possibile notare ci sono diverse funzioni e
procedure che permettono di effettuare i controlli estrapolando i valori restituiti dai sensori presenti
all’interno della serra.
• Dalla riga 23 alla 31 : effettuiamo una connessione al database ed andiamo ad estrapolare i dati
dove la colonna selected è = 1. Questo perché, quando andiamo a selezionare il tipo di pianta
inserita all’interno della serra dal gestionale web, dobbiamo capire quali sono le soglie per creare il
giusto microclima.
• conn = mysql.connector.connect(user='root', password=’*****’, host='localhost', data-
base=’****’)
• cursore = conn.cursor()
•
• cursore.execute("SELECT temp,hum,suolo FROM piante WHERE selected=1")
•
• row = cursore.fetchone()
• temp = row[0]
• hum = row[1]
• soil = row[2]
Come vediamo dall’immagine sottostante, ho deciso di inserire un piccolo dropdown che permetta
di visualizzare tutte le possibili piante che possono essere piantate all’interno della serra. Ognuna di
esse avrà determinate soglie di temperatura, umidità e umidità del terreno da rispettare per un
corretto microclima. Al momento dell’avvio del gestionale tutte le piante assumono un valore
selected di 0. Selezionando la pianta desiderata essa assumerà valore selected 1 e sarà cosi
possibile estrapolarne i dati che serviranno successivamente per creare i grafici. Ovviamente, le
piante che possiamo selezionare, verranno inserite tramite form direttamente da noi.
• dalla riga 141 alla 149: attraverso la libreria GPIO messa a disposizione è possibile comandare i pin
della GPIO di Raspberry. Per un funzionamento corretto dobbiamo settare alcuni parametri. La
• GPIO.setmode(GPIO.BCM)
si riferisce ai numeri di canale sul Broadcom SOC. Esiste anche la modalità GPIO.BOARD. Per
verificare la numerazione corretta visita la pagina seguente.
• GPIO.setup(pin_rele_pompa, GPIO.OUT, initial=GPIO.HIGH)
Con il comando GPIO.setup invece è possibile inizializzare il pin di uscita con OUT e impostarlo ad
un valore HIGH o LOW (acceso o spento).
• GPIO.setmode(GPIO.BCM)
• GPIO.setwarnings(False)
•
• GPIO.setup(pin_rele_ventole, GPIO.OUT, initial=GPIO.HIGH)
• GPIO.setup(pin_rele_pompa, GPIO.OUT, initial=GPIO.HIGH)
• GPIO.setup(pin_rele_luci, GPIO.OUT, initial=GPIO.HIGH)
•
• connessione_test()
• lettura_sensori()
• dalla riga 124 alla 138: richiamiamo, all’interno della procedura lettura_sensori(), le varie funzioni
che servono a leggere i valori di temperatura, umidità e umidità del terreno per poi andarli ad
inserire all’interno di una specifica tabella del database.
150. def lettura_sensori():
151. try:
152. timenow = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
153. time.sleep(0.5)
154. temperatura, umidità = controllo_DHT()
155. time.sleep(0.5)
156. terreno_umidita = controllo_SOIL()
157. time.sleep(0.5)
158. controllo_luce()
159.
160. inserimento_dati(timenow, temperatura, umidità, terreno_umidita)
161.
162. except:
163.
164. print('lettura fallita')
La tabella dati del database è costituita da diversi campi:
• Id – identifica in maniera univoca una lettura
• Data – inseriamo la data e l’ora della lettura
• Temp, hum, suolo – tre colonne differenti dove vengono inseriti i valori dei sensori
Analizziamo ora questa sezione di codice :
165. def controllo_luce():
166. SPI_PORT = 0
167. SPI_DEVICE = 0
168. mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
169. valore_luce = mcp.read_adc(7)
170.
171. luce = conversione(valore_luce, 0, 1023, 0, 100)
172. print ('Luce: {0} '.format(luce))
173.
174. time.sleep(0.5)
175.
176. if luce < soglia_minima_luci:
177. GPIO.output(pin_rele_luci, GPIO.LOW)
178.
Attraverso la procedura controllo_luce() andiamo, appunto, ad controllare il livello di luce presente
all’interno della serra. Se la luce non fosse sufficiente verranno attivati i led installati sopra la serra.
179. SPI_PORT = 0
180. SPI_DEVICE = 0
181. mcp = Adafruit_MCP3008.MCP3008(spi=SPI.SpiDev(SPI_PORT, SPI_DEVICE))
182. valore_luce = mcp.read_adc(7)
Per leggere i valori analogici della fotoresistenza è necessario avere un convertitore di segnale. Nel
caso volessimo utilizzare la fotoresistenza direttamente con il Rasberry potremo solo sapere se la
luce è presente o meno all’interno della serra ma non il valore preciso. Ecco che ho installato il
MCP3008 che permette di convertire i segnali. Questo microcontrollore ha una specifica libreria che
ci aiuta nell’utilizzo essendo ricca di esempi e spiegazioni.
Analizziamo la pagina login.php del gestionale
1.
2.
3.
4. Serra Automatizzata
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23. Copyright ©document.write(new Date().getFul-
lYear()); All rights reserved | This template is made with by Color-
lib.com24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38. Toggle Menu
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52. Il Progetto - serra intelligente
53.
54.
55. Username
56.
57.
58.
59. Password
60.
61.
62.
63.
64.
65. Accedi alla da-
shboard di controllo
66.
67.
68.
69.
70.75. {
76. if(emptyempty($_POST["username"]) || emptyempty($_POST["password"]))
77. {
78. echo $message = "Attento ! I campi vanno compilati per accedere ";
79. }
80. else
81. {
82. $username = $_POST["username"];
83. $password = $_POST["password"];
84. $connect = mysqli_connect("localhost", "root", "******", "******");
85. $sql = "SELECT * FROM login WHERE username ='$username' AND pas-
sword = '$password'";
86. $result = mysqli_query($connect, $sql);
87.
88. if(mysqli_num_rows($result) == 1){
89. header("Location: index.php"); // Redirecting to other page
90. }
91. else
92. {
93. echo $error = "Username o Password non valide";
94. }
95. mysqli_close($connect); // Closing connection
96. }
97. }
98.
99. ?>
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.La pagina si compone di un semplice form creato con Bootstrap e PHP che permette di accedere alla pagina
index.php di gestione e controllo della serra. I campi username e password sono, ovviamente, campi
presenti all’interno di una tabella del database.
Per accedere al gestionale vengono confrontate le stringhe inserite nel form con le credenziali presenti
all’interno del database.
Analizziamo la pagina index.php
1.
16.
17.
18.
19. Serra Automatizzata
20.
21.
22.23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37. Home
38.
39.
40. Temperatura
41.
42.
43. Umidità
44.
45.
46. Umidità suolo
47.
48.
49. Inserisci nuova pianta
50.
51.
52.
53.
54. Copyright ©document.write(new Date().getFul-
lYear()); All rights reserved | This template is made with
55. by ilgiovaneinformatico.com
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69. Toggle Menu
70.
71.
72.
73.
74.
75.83.
84. if ($result->num_rows > 0) {
85. // output data of each row
86. while($row = mysqli_fetch_assoc($result)) {
87.
88. echo "" . $row['nome'] . "";
89.
90. }
91. }
92.
93. ?>
94.
95.
96.
97. Seleziona
98.
99.
100.
101.
102.
103.
104.
105.
106. Il Progetto - serra intelligente
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
127.
128.148. $verde_temp_neg = $temp_set - 5;
149. $giallo_temp_ = $temp_set + 10;
150.
151. $verde_hum_pos = $hum_set + 5;
152. $verde_hum_neg = $hum_set - 5;
153. $giallo_hum_ = $hum_set + 10;
154.
155. $verde_soil_pos = $soil_set ;
156.
157. ?>
158.
159.
164. ],
187.
188. ]);
189.
190. var options = {
191. width: 300, height: 300,
192. green-
From: , greenTo: ,
193. redFrom: , redTo: 100,
194. yellowFrom:, yel-
lowTo: ,
195. minorTicks: 5
196. };
197.
198. var chart = new google.visualization.Gauge(document.getEle-
mentById('chart_div_temp'));
199.
200. chart.draw(data, options);
201.
202. }
203.
204.
205. google.charts.load('current', {'packages':['gauge']});
206. google.charts.setOnLoadCallback(drawChart);
207.
208. function drawChart() {
209.
210. var data = google.visualization.arrayToDataTable([211. ['Label', 'Value'],
212. ['Umidità', ],
213.
214. ]);
215.
216. var options = {
217. width: 300, height: 300,
218. green-
From: , greenTo: ,
219. redFrom: , redTo: 100,
220. yellowFrom:, yel-
lowTo: ,
221. minorTicks: 5
222. };
223.
224. var chart = new google.visualization.Gauge(document.getEle-
mentById('chart_div_hum'));
225.
226. chart.draw(data, options);
227.
228. }
229.
230.
231. google.charts.load('current', {'packages':['gauge']});
232. google.charts.setOnLoadCallback(drawChart);
233.
234. function drawChart() {
235.
236. var data = google.visualization.arrayToDataTable([
237. ['Label', 'Value'],
238. ['Soil', ],
239.
240. ]);
241.
242. var options = {
243. width: 300, height: 300,
244. greenFrom: , greenTo: 100,
245. minorTicks: 5
246. };
247.
248. var chart = new google.visualization.Gauge(document.getEle-
mentById('chart_div_soil'));
249.
250. chart.draw(data, options);
251.
252. }
253.
254.
255.
256.
257.
All’interno della pagina principale (homepage) andiamo a selezionare il tipo di pianta inserita all’interno
della serra e di conseguenza, vengono creati i tre indicatori di temperatura, umidità e soil moisture con
relativi valori. Attraverso l’utilizzo di javascript ho creato le tre funzioni che permettono la visualizzazione
delle soglie all’interno dei tre indicatori.
1.
2. google.charts.load('current', {'packages':['gauge']});
3. google.charts.setOnLoadCallback(drawChart);
4.
5. function drawChart() {
6.
7. var data = google.visualization.arrayToDataTable([
8. ['Label', 'Value'],9. ['Umidità', ],
10.
11. ]);
12.
13. var options = {
14. width: 300, height: 300,
15. green-
From: , greenTo: ,
16. redFrom: , redTo: 100,
17. yellowFrom:, yel-
lowTo: ,
18. minorTicks: 5
19. };
20.
21. var chart = new google.visualization.Gauge(document.getEle-
mentById('chart_div_hum'));
22.
23. chart.draw(data, options);
24.
25. }
26.
Come vediamo dall’immagine sottostante l’interfaccia grafica è molto semplice e intuitiva ma ci mostra
tutto ciò di cui abbiamo bisogno per tenere sotto controllo la nostra serra. In alto a destra il selettore,
all’interno della sidebar il menù che ci permette di navigare all’interno del sito e infine i tre indicatori.
Analizziamo la pagina temperatura.php – grafico in javascript
La pagina temperatura.php, umidità.php e soil.php sono praticamente identiche. Esse infatti contengono i
grafici che analizzano l’andamento del microclima nel tempo. Lo script di inserimento dati all’interno del
database va fatto partire al momento della semina. Si potrà così osservare dall’inizio del ciclo vitale dalla
pianta come il microclima è mutato nel tempo. I grafici sono stati realizzati tramite la libreria CanvasJS e
popolati con i valori presi dal database tramite il linguaggio PHP.1. 17. 18. 19. 20. 21. Serra Automatizzata 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39.
63.
64.
65.
66.
67. Toggle Menu
68.
69.
70.
71.
72.
73.
74. Grafico della Temperatura
75.
76.
77.
78. Refresh Page
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91. window.onload = function () {
92.
93. var chart = new CanvasJS.Chart("chartContainer", {
94. animationEnabled: true,
95. zoomEnabled: true,
96. theme: "light2", // "light1", "light2", "dark1", "dark2"
97. axisX:{
98. valueFormatString: "DD MMM hh:mm TT",
99. intervalType: "mounth",
100.
101. },
102. data: [{
103. type: "spline",
104. xValueFormatString: "DD MMM hh:mm TT",
105. yValueFormatString: "C°#,##0.##",
106. xValueType: "dateTime",
107. markerColor: "green",
108. dataPoints:
109. }]
110. });
111. chart.render();
112. }
113.
114.
115.
116.
117.All’interno della libreria CanvasJS sono presenti molti grafici che possiamo utilizzare. Quello utilizzato da me, che migliora la grafica e l’analisi per l’obbiettivo prefissato, è sicuramente un grafico a linea con zoo disponibile per vedere in che momento della giornata il microclima ha subito un improvviso calo o una rapida impennata. Analizziamo la pagina inserisci_pianta.php Siamo arrivati alla conclusione e come ultimo ma non meno importante parliamo del form di inserimento di una nuova pianta all’interno del nostro database. Infatti, un gestionale deve disporre della possibilità di gestire più situazioni, nel nostro caso più piante e microclimi. Per ogni pianta inserita dovremmo indicare la data di semina e di raccolta, con i relativi dati medi che serviranno al sistema per creare il microclima corretto.
Osservazioni ed eventuali migliorie e modifiche
Bene ragazzi, siamo arrivati alla conclusione di questo semplice ma funzionale progetto. Il sistema è in
continuo aggiornamento perché le cose da imparare sono molte e nel corso del tempo aggiungerò delle
funzionalità che permettano al sistema di diventare “intelligente” e gestire da solo le varie situazioni.
Prendiamo in considerazione alcune migliorie che possono essere applicate:
• Creare un form di modifica e aggiornamento dei dati all’interno del database; (in lavorazione)
• Creazione di un dominio per gestione remota del sistema; (in lavorazione)
• Telegram application per richiedere in tempo reale le informazioni;
• Aggiunta di un sensore di PH;
• Aggiunta sensore Co2;
Per testare il prodotto ho seminato, il giorno 17/07/2020, all’interno della serra dell’insalata a taglio. Posso
rilevare alcune importanti situazioni che sono apparse:
• Il consumo di acqua è stato minimo, ho rilevato infatti una sola applicazione da parte della pompa;
• La serra è apparsa molto umida e ha permesso, dopo solo una notte, la nascita dei primi germogli;
• Grazie alla luce a led installata nella parte superiore della serra la pianta riesce ad avere una
produttività molto alta.
Il progetto è stato realizzato da Enzo Manuel - @copyright 2020 - ilgiovaneinformatico.comPuoi anche leggere
