I.T.T. Basilio Focaccia Relazione ProgettoControllo e casa domoticaIl co...
I.T.T. Basilio Focaccia
Relazione Progetto
Controllo e casa domotica
Il controllo e prefazione
Nella realizzazione di tale impresa ho utilizzato tutta la conoscenza archiviata in questi tre anni, cercando di sfruttare al massimo quelle che sono le materie “tecniche” del mio istituto.
Ma perché il controllo?
Ormai ci troviamo in un’epoca dominata dall’informatica, infatti essa ha un forte impatto in tutti gli ambiti e ci stiamo avvicinando sempre di più al cosiddetto “Internet of things”, dove anche una lavastoviglie può essere controllata attraverso un cellulare a chilometri e chilometri di distanza. Quindi l’uomo controlla, effettivamente, tutto ciò che possiede e con i giusti criteri di sicurezza si può creare una vera e propria cassaforte virtuale.
Il mio progetto è un abbozzo di questo complicato concetto, infatti, ci troviamo davanti a una miniatura di casa domotica, ma completamente controllabile in una rete LAN, oltre a ciò c’è la possibilità di sbloccare la porta 80 (http) tra le impostazioni del router e quindi si può accedere ad essa tramite l’indirizzo IP pubblico di una rete privata domestica, anche se a discapito della sicurezza (sql injection).
Introduzione
La casa è provvista di Arduino mega, una scheda programmabile made in Italy, che ci permette di scrivere e compilare i nostri sketch (o programmi) tramite un IDE.
Il linguaggio di programmazione utilizzato è il Wiring, un linguaggio simil C / C++.
Tale scheda è provvista di un Ethernet Shield, il quale ci permette di effettuare un collegamento con la nostra rete, ovviamente avendo a disposizione i dispositivi adatti (switch, access point, router, ecc…)
Per gestire al meglio la casa, ho affiancato ad essa un server web, gestito da XAMPP , una piattaforma software multipiattaforma con annessi alcuni applicativi e strumenti che ci permettono di gestire al meglio database e il linguaggio lato server (PHP).
interfaccia di controllo XAMPP
Questo server web ci serve per gestire al meglio i numerosi hardware connessi ad arduino, infatti troviamo diversi sensori (umidità, pioggia, temperatura, luce e movimento) che oltre a monitorare la casa e a svolgere alcune funzioni in automatico, (come ad esempio l’accensione di una ventola una volta superata la temperatura di 25°C) invia in automatico i dati di tali sensori al server, e tramite il nostro cellulare, una volta collegati al sito, possiamo osservare dei grafici che riportano i dati registrati nel database.
Un esempio dei grafici visibili sul sito
La casa è provvista di numerosi led, i quali hanno la funzione di illuminare la casa; per gestirli, abbiamo predisposto una sezione del sito dove possiamo trovare un elenco di tutte le luci e cliccando sull’immagine verrà inviato un comando che permetterà alla luce scelta di accendersi o spegnersi.
Ecco come si mostra l’elenco delle luci
La casa presenta anche diversi servo motori, il loro compito è quello di aprire e chiudere una serie di porte e finestre, che come per le luci, hanno una loro sezione nel sito, dalla quale possiamo controllarne l’apertura e la chiusura.
Come ogni villa che si rispetti troviamo anche un giardino, solo che in questo caso abbiamo 3 sensori di umidità e 3 pompe, l’utente, per poter gestire al meglio il frutto del suo operato, potrà scegliere tra due funzioni: l’innaffiamento automatico, il quale fa azionare le pompe solo quando il terreno ha raggiunto una secchezza elevata e l’innaffiamento manuale, dove si può controllare una tabella che riporta lo stato delle 3 aiuole e consente di poter azionare le pompe arbitrariamente.
Inoltre l’utente può anche azionare una fontana
Esempio delle due funzioni
Cosa è di fondamentale importanza per le case domotiche? Ovviamente l’allarme, infatti la casa monta un sensore di movimento (come già accennato), che una volta attivato sul sito e registrato un movimento sospetto, invia, tramite una scheda GSM (sim) un messaggio al proprietario, che verrà avvertito di un possibile furto nella sua abitazione.
Un ulteriore livello di sicurezza è stato aggiunto, l’admin potrà, tramite un semplice form presente sul sito, aggiungere ulteriori membri familiari, assegnando loro due livelli, “normal” e “admin”. Il livello admin consente l’accesso a tutte le sezioni del sito, mentre il livello normal limita tale accesso non consentendo all’utente di azionare l’allarme o di creare un nuovo utente
Form creazione utente
Admin a sinistra e normal a destra
Dopo aver dato questa breve spiegazione sul funzionamento della casa passerò a spiegare più tecnicamente, e in modo molto più approfondito, ciò che ho messo in pratica, materia per materia
Informatica
Normalmente un server web risiede su sistemi dedicati, ma grazie a software come Apache HTTP server, possiamo installare tale server anche su PC che di norma dovrebbero essere client, l’utilizzo di tali applicativi consente al programmatore di visionare e testare in locale il proprio sito web, ma può anche consentire l’accesso ai propri documenti da altri computer, sia tramite LAN che tramite internet.
XAMPP ci permette di utilizzare Phpmyadmin, ovvero un’applicazione che ci permette di gestire database (DBMS) tramite un normale browser e quindi oltre a essere un’alternativa piuttosto leggera abbiamo a disposizione diversi strumenti per controllare il corretto funzionamento del database, tramite grafici E/R e di eseguire delle query direttamente dal browser.
SQL (DDL)
Su tale applicativo ho realizzato tutto il database necessario per il corretto funzionamento della casa; adesso andremo ad analizzare gli statement dell’linguaggio sql con i quali ho realizzato il database e le sue tabelle.
Prima di tutto creiamo il database:
CREATE DATABASE `casa`;
E di seguito tutte le tabelle di cui abbiamo bisogno:
CREATE TABLE `gestore` (
`id_automatic` int(11) NOT NULL,
`automatico` tinyint(1) NOT NULL,
`pompa1` tinyint(1) NOT NULL,
`pompa2` tinyint(1) NOT NULL,
`pompa3` tinyint(1) NOT NULL,
`fontana` tinyint(1) NOT NULL,
`allarme` tinyint(1) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
CREATE TABLE `luci` (
`luce_ingresso` tinyint(1) NOT NULL,
`luce_garage` tinyint(1) NOT NULL,
`luce_bagno` tinyint(1) NOT NULL,
`luce_p_t` tinyint(1) NOT NULL,
`luce_p_p` tinyint(1) NOT NULL,
`luce_terrazza` tinyint(1) NOT NULL,
`id_luci` int(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
CREATE TABLE `port` (
`soggiornofin` tinyint(1) NOT NULL,
`garagefin` tinyint(1) NOT NULL,
`finestrabag` tinyint(1) NOT NULL,
`garagepo` tinyint(1) NOT NULL,
`principalepo` tinyint(1) NOT NULL,
`id_portfin` int(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
CREATE TABLE `sensori` (
`umidita` float NOT NULL,
`temperatura` float NOT NULL,
`luce` float NOT NULL,
`pioggia` float NOT NULL,
`id_sens` int(11) NOT NULL,
`allarme` tinyint(1) NOT NULL,
`aiuola1` int(11) NOT NULL,
`aiuola2` int(11) NOT NULL,
`aiuola3` int(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
CREATE TABLE `utente` (
`username` varchar(45) NOT NULL,
`password` varchar(25) NOT NULL,
`admin` tinyint(1) NOT NULL,
`email` varchar(64) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
Andiamo a dichiarare le chiavi primarie, utili per riconoscere e richiamare univocamente le istanze delle tabelle:
ALTER TABLE `gestore`
ADD PRIMARY KEY (`id_automatic`);
ALTER TABLE `luci`
ADD PRIMARY KEY (`id_luci`);
ALTER TABLE `port`
ADD PRIMARY KEY (`id_portfin`);
ALTER TABLE `sensori`
ADD PRIMARY KEY (`id_sens`);
ALTER TABLE `utente`
ADD PRIMARY KEY (`username`);
Dopo aver visto la struttura fondamentale del database, passerò a spiegare passo dopo passo, ma in generale, la sintassi e i comandi utilizzati; che almeno fino ad adesso sono comandi per la definizione della struttura dei dati e l’amministrazione del database anche detti Data Definition Language (DDL)
Innanzitutto il comando CREATE serve per creare database, tabelle, viste, indici, ecc… Per la creazione di una semplice tabella troviamo la seguente sintassi generica.
CREATE TABLE <nome tabella> (
<nome_campo_0> <tipo_di_dato> [<vincolo>]
<nome_campo_n> <tipo_di_dato> [<vincolo>]
);
L’SQL consente di gestire un’ingente numero di tipi di dato, che possiamo dividere in tre categorie fondamentali: numerici, date e orari e stringhe
Nelle mie tabelle non vengono mai utilizzati date o orari, però troviamo un’ingente quantità di tipi di dato numerici: tinyint( utilizzato in questo caso come bool), int e float.
Spesso e volentieri, come già prima si è potuto notare, ci siamo trovati spesso davanti al vincolo NOT NULL, esso indica che il campo dovrà avere sempre un valore e che quindi non potrà essere vuoto.
Un altro vincolo molto importante è il DEFAULT, esso indica quale valore dovrà inserire il DBMS nel caso in cui, durante l’inserimento, lasciamo tale campo vuoto.
Un’altra parola chiave molto importante, che ci permette di evitare l’eccessivo utilizzo del comando ALTER è il comando CONSTRAINT che ci permette di dichiarare le chiavi primarie e secondarie stesso nella sintassi della creazione di una tabella.
Il comando ALTER ci consente di modificare una tabella aggiungendo, togliendo o modificando un campo, una chiave, un indice, ecc…
La sua sintassi generale è la seguente:
ALTER TABLE <nome_tabella> <operazione_di_modifica>;
Le operazioni di modifica sono diverse, a parte la già vista ADD PRIMARY KEY, utile per dichiarare la chiave primaria, troviamo anche: change, add e modify
Altri comandi di tipo DDL sono: RENAME (consente di cambiare nome a una tabella esistente) e DROP (consente di eliminare qualsiasi oggetto).
PHP
Il PHP è la colonna portante di tutto il progetto, esso infatti mi ha permesso di fare da tramite tra la casa domotica e il database.
Il PHP è un linguaggio lato server, simil C, che grazie alle sue numerose librerie ci permette di realizzare, molto rapidamente, funzioni complesse.
Un’altra caratteristica molto importante di tale linguaggio è la possibilità di essere inserito all’interno di un codice HTML (grazie al suo tag di apertura <?php … ?>) e inotre può stampare codici HTML grazie al comando echo.
Adesso vi mostrerò e vi spiegherò passo, passo i codici utilizzati per creare l’applicazione web
Connessione al database:
<?php
$host="localhost";
$utente="root";
$password="";
$connessione=mysql_connect($host,$utente,$password) or die ("Impossibile effettuare la connessione");
$db_database="casa";
$database=mysql_select_db($db_database,$connessione) or die ("Impossibile effettuare la connessione");
?>
Tale script php è conservato all’interno di un file e verrà richiamato ogni volta che dobbiamo effettuare una connessione con il database.
Innanzitutto andiamo a dichiarare all’interno di alcune variabili i dati di accesso al DBMS (nome host, utente, password).
Successivamente si esegue la connessione grazie al comando mysql_select_db e, nel caso in cui la connessione non è andata a buon fine, con il comando or die si stampa un messaggio di errore.
Infine, con mysql_select_db, selezioniamo il database che andremo ad analizzare.
Form di login:
come si presenta graficamente il form
<form action="login.php" class="form" method="post">
<br />
<label id="usen"><span class="auto-style4">Username
<input name="usen" style="width: 18%; height: 10%" type="text" /><br />
Password </span></label>
<input name="pass" style="width: 18%; height: 10%" type="password" /><br />
<br />
<button class="auto-style5" name="Abutton1" style="width: 20%; background-color: #0066CC; text-align: center; text-indent: inherit; height: 41px; border-bottom-color: #FFFFFF; border-bottom-style: solid; border-color: #0000FF">
<div class="auto-style6">
OK</div>
</button>
</form>
Questo form, come possiamo vedere dal tag di apertura, utilizza il metodo POST; esso ci consente di inviare dati allo script PHP da noi dichiarato (nota, nel caso in cui il form e lo script in PHP si dovessero trovare nella medesima pagina, ci basterà inserire nell’action il carattere “#”) tramite le funzionalità del protocollo http, nascondendo le variabili inviate.
Un altro metodo è il GET, che invece sfrutta l’URL per inviare i dati.
Tra i vari campi del form possiamo utilizzare numerosi tag di scelta, tra i più importanti ricordiamo: input, textarea, select/option e servono rispettivamente per realizzare campi di testo e scelte alternative (sia singole che multiple)
Script di login in PHP:
<?php
session_start(); // avviamo la sessione
require ("config.php"); //richiediamo il file “config.php” che ci permette la connessione al database
$myusername=($_POST['usen']); // copiamo le variabili post in altre variabili
$mypassword=($_POST['pass']);
if ($myusername=="" or $mypassword=="") { // controllo delle due variabili, nel caso in cui una delle due è vuota restituisce un messaggio di errore
$messaggio="Inserisci tutti i campi
echo "<script language='javascript'>
alert('$messaggio');
</script>";
$conten="0;url=index.php";
echo"<meta http-equiv='refresh' content='$conten'>";
die();
}
$sql = "SELECT * FROM `utente` WHERE `username` LIKE '$myusername' AND `password` LIKE '$mypassword'";
$result = mysql_query($sql); //esecuzione query
$miaoh=mysql_num_rows($result);
if ($miaoh=='1') {
$count=mysql_num_rows($result);
$_SESSION['username'] = $myusername;
$_SESSION['password'] = $mypassword;
if($count==1){
//session_register("myusername");
//session_register("mypassword");
$messaggio="Benvenuto $myusername hai effettuato il login con successo";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
$conten="0;url=index.php";
echo"<meta http-equiv='refresh' content='$conten'>";
}
}
else
{
$messaggio="Credenziali non valide";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
header('Refresh:0.5; url= index.php');
}
?>
In questo caso abbiamo utilizzato la Session, un comando che permette di memorizzare determinati dati e variabili inseriti dal client, nel server e tramite un semplice richiamo possono essere utilizzati anche nelle altre pagine. Grazie al Session ho realizzato alcuni controlli di sicurezza che andrò a spiegare nelle pagine successive.
Un passaggio utile per avere un lavoro pulito e lineare è quello di copiare le variabili POST/GET in altre variabili, ma non è un elemento di necessaria importanza.
Comunque, dopo aver fatto i necessari controlli, siamo pronti a verificare che l’username e la password siano presenti nel nostro database e quindi facciamo una select (SELECT * FROM `utente` WHERE `username` LIKE '$myusername' AND `password` LIKE '$mypassword'") che andiamo a salvare in una variabile e successivamente eseguiremo tramite il comando mysql_query.
Il comando Select realizza un’interrogazione e restituisce una tabella virtuale avente come colonne i campi specificati dopo il Select
Ad esempio
“SELECT umidita, temperatura, luce
FROM sensori
WHERE pioggia = ‘1’;”
Restituisce:
UmiditàTemperaturaLuce
45230
45300
23231
11650
32120
Tramite il comando mysql_num_rows(<funzione>) possiamo conoscere quante righe restituisce la query, e quindi tramite ciò possiamo sapere se il nostro username e la password sono presenti nel database. Nel caso in cui il risultato delle righe è uguale a uno, tramite un alert verremo salutati dal sito e reindirizzati alla pagina principale grazie al comando header.
Controllo sull’utente:
Il Server controllerà “l’identità” del nostro navigante grazie alla session, nel caso in cui un malintenzionato voglia accedere a una determinata pagina tramite URL, verrà bloccato…
Il codice è il seguente:
<?php
require("config.php");
session_start();
$varcont=1;
$usern=$_SESSION['username'];
$passw=$_SESSION['password'];
$sql = "SELECT * FROM `utente` WHERE `username` LIKE '".$usern."'AND `password` LIKE '".$passw."' ";
$result = mysql_query($sql);
if( $usern=="" and $passw== "" or mysql_num_rows($result) == 0)
{
$messaggio="Non puoi accedere a questa pagina senza aver effettuato prima l'accesso";
echo "<script language='javascript'> alert('$messaggio'); </script>";
$conten="0;url=motorized_house.htm";
echo"<meta http-equiv='refresh' content='$conten'>";
$varcont=0;
}
if($varcont==1)
{ ?>
Una volta iniziata la sessione e copiate le variabili, il server si occuperà di fare una select e di eseguire un controllo su di essa e sulle variabili della session.
Nel caso in cui l’if non sarà soddisfatto, il client verrà rimandato sulla pagina di accesso e dovrà inserire i dati corretti o semplicemente allontanarsi dal sito
Invece, nel caso contrario, il codice HTML sarà inserito nell’if grazie alla chiusura del tag php e quindi visualizzeremo la nostra pagina senza problemi.
Logicamente bisogna ricordarsi di riaprire il tag PHP e di chiudere la parentesi graffa
<?php
}
?>
Attivazione/ Disattivazione dispositivi:
Per quanto riguarda il corretto funzionamento di luci, porte, finestre, attivazione allarme, ecc... I codici da me utilizzati sono simili e l’unica cosa che cambia è il numero di dispositivi utilizzati per sezione del sito; a seconda dello stato del dispositivo, un’immagine segnalerà lo stato corrispondente, ad esempio:
Se una determinata porta è aperta, riporterà la seguente immagine
Nel caso contrario verrà visualizzata questa immagine
Il codice per la scelta dell’immagine è il seguente:
<?php
require("config.php");
$sql01 = "SELECT * FROM `port` WHERE `finestrabag` = 1 AND `id_portfin`= 1";
$result01 = mysql_query($sql01);
if(mysql_num_rows($result01) == 1)
{
echo"<a href=\"portfines.php?P=2&P1=2&P2=0&P3=2&P4=2\"><img src=\"portaop.jpg\" alt=\"\" height=\"200\" width=\"150\" /></a>";
}
else
{
echo"<a href=\"portfines.php?P=2&P1=2&P2=1&P3=2&P4=2\"><img src=\"portacl.jpg\" alt=\"\" height=\"200\" width=\"150\" /></a>";
}
?>
Quindi, per verificare lo stato, verrà eseguita una query che cercherà la finestra/porta scelta in una sola istanza (id_portfin è una chiave primaria), il risultato verrà controllato da un if che a seconda delle righe stampate nella tabella virtuale cambierà immagine.
L’immagine, in entrambi i casi, è in realtà un collegamento ipertestuale con un indirizzo univoco che trasporta una serie di variabili, dove però, solo la variabile della porta scelta avrà un numero booleano (0 o 1)
“portfines.php?P=2&P1=2&P2=0&P3=2&P4=2”
La pagina verso la quale verremo reindirizzati avrà il seguente codice:
if($varcont==1)
{
if($_GET['P']==0)
{
$sql="UPDATE `casa`.`port`
SET `soggiornofin` = '0'
WHERE `port`.`id_portfin` = 1;";
mysql_query($sql);
echo"<iframe src=\"http://192.168.1.105/?P=0 \" ";
echo" width=\"0%\" height=\"0%\"> ";
echo"</iframe>";
}
if($_GET['P']==1)
{
$sql="UPDATE `casa`.`port`
SET `soggiornofin` = '1'
WHERE `port`.`id_portfin` = 1;";
mysql_query($sql);
echo"<iframe src=\"http://192.168.1.105/?P=1 \" ";
echo" width=\"0%\" height=\"0%\"> ";
echo"</iframe>";
}
header('Refresh:0.5; url=portf.php');
Come possiamo vedere, a seconda del valore booleano inviato tramite l’url, il server eseguirà una modifica dell’istanza assegnando l’accensione o lo spegnimento del dispositivo; il comando SQL utilizzato è l’update, che permette di modificare le istanze di una tabella, la sua forma generica è la seguente:
UPDATE <tabella> SET <campo> = <valore>
WHERE <condizione>
La condizione può anche essere omessa, dipende dalle nostre esigenze.
Una volta eseguita la query, tramite diversi echo, verrà istanziato un iframe, molto importante per inviare all’arduino il comando scelto.
Infine, una volta eseguita la connessione ad arduino, verremo reindirizzati sulla pagina precedente.
PHP registrazione dell’utente:
Come abbiamo già visto nell’introduzione, il sito permette all’utente di registrare, tramite un form, i membri familiari.
Il codice relativo al PHP è il seguente:
<?php
require("config.php");
$username=$_POST['username'];
$email=$_POST['email'];
$livello=$_POST['livello'];
$password=$_POST['password'];
if($livello=="Admin")
{
$liv=1;
}
else
{
$liv=0;
}
if($username==""||$email==""||$password=="")
{
if($username=="")
{
$messaggio="Impossibile creare un nuovo utente, si prega di inserire l'username";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
$conten="0;url=creanuovo.php";
echo"<meta http-equiv='refresh' content='$conten'>";
}
if($email=="")
{
$messaggio="Impossibile creare un nuovo utente, si prega di inserire l'email";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
$conten="0;url=creanuovo.php";
echo"<meta http-equiv='refresh' content='$conten'>";
}
if($password=="")
{
$messaggio="Impossibile creare un nuovo utente, si prega di inserire la password";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
$conten="0;url=creanuovo.php";
echo"<meta http-equiv='refresh' content='$conten'>";
}
}
else
{
$sql="SELECT * FROM `utente` WHERE `username` LIKE '".$username."' ";
$request=mysql_query($sql);
if(mysql_num_rows($request) > 0)
{
$messaggio="Username già presente nel database";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
$conten="0;url=creanuovo.php";
echo"<meta http-equiv='refresh' content='$conten'>";
}
else
{
$sql="INSERT INTO `utente` (`username`, `password`, `admin`, `email`)
VALUES ('".$username."', '".$password."', '".$liv."', '".$email."')";
mysql_query($sql);
$messaggio="Username creato con successo";
echo "<script language='javascript'>
alert('$messaggio');
</script>";
header('Refresh:0.5; url= creanuovo.php');
}
}
?>
Quindi, copiamo le variabili e il server verificherà se abbiamo scelto un livello Admin o Normale, assegnando a una variabile, di nome “liv”, un numero booleano, che nel primo caso sarà 1.
Dopo di che il server effettua i relativi controlli (campi vuoti, username già creato) passerà alla creazione dell’utente.
Per la query bisogna utilizzare il comando INSERT INTO che consente di inserire nuove istanze della tabella.
Le forme generali del comando sono le seguenti:
INSERT INTO <nome tabella> <lista campi> VALUES <lista valori>
La lista dei campi e quella dei valori devono essere ordinate per consentire il corretto funzionamento della query, come da esempio:
INSERT INTO `prova` (`giorni_settimana`, `mesi_in_anno`, `anno)
VALUES ('7', '12', '2016'').
Una volta eseguito l’inserimento verremo reindirizzati alla pagina di creazione nuovo utente.
Abbiamo quasi finito la parte relativa al PHP, manca solo una piccola riga di codice, relativa alla visualizzazione di alcuni elementi del menu.
Menu… Admin e Normale:
<?php
$sql1 = "SELECT * FROM `utente` WHERE `username` LIKE '".$usern."'AND `password` LIKE '".$passw."' AND `admin` = 1 ";
$result1 = mysql_query($sql1);
$admin = mysql_num_rows($result1);
if($admin == 1)
{ ?>
<li class="auto-style1"><span lang="it"><a href="creanuovo.php">
<span class="auto-style4">Nuovo utente</span></a></span></li>
<?php
}
?>
Il concetto è molto semplice, una volta che abbiamo verificato il livello dell’utente (tramite una query) e se è livello admin, stamperà una sezione del menù che per gli utenti normali è “nascosta”.
Arduino (Invio dei dati e GSM)
Nella seguente sezione mostrerò le righe di codice che ho utilizzato per permettere ad arduino di comunicare con il database e di attivare la scheda GSM con il relativo messaggio.
Invio stato dei sensori:
void UpdateTemp()
{
delay(1);
int cont2= cont2+1;
if(cont2==1000);
{
if(client.connect(ipserver,80))
{
strURL="GET /boh/temperatura.php?temperatura=";
strURL+= temperatura;
strURL+="&umidita=";
strURL+= umidita;
strURL+="&luce=";
strURL+= light;
strURL+="&pioggia=";
strURL+= pioggia;
strURL+="&aiuola1=";
strURL+= umi1;
strURL+="&aiuola2=";
strURL+= umi2;
strURL+="&aiuola3=";
strURL+= umi3;
if(alltot==false)
{
strURL+="&allarme=0";
}
else
{
strURL+="&allarme=1";
}
strURL+="HTTP/1.1";
client.println(strURL);
client.println("HOST: arduino");
client.println("Connection:close");
client.println();
client.stop();
}
Lo stato dei sensori viene inviato una volta al secondo a una pagina PHP presente sul nostro sito, in questo caso ho utilizzato diversi controlli per fare in modo che l’arduino non si fermi mai, e che quindi continui il suo ciclo di processi senza interrompersi.
Quindi, in una variabile, conto il passare di ogni millisecondo e una volta raggiunto il secondo eseguirà il codice per l’invio.
Il client quindi si connetterà all’ indirizzo IP del server sulla porta 80 (come vedremo per le successive materie, l’indirizzo IP sia del server che della casa sono statici)
“client.connect(ipserver,80)”
E quindi tramite un if ne verificherà la connessione, dopo ciò, Arduino crea la stringa che verrà inviata, tramite il metodo GET, al server e infine chiude la connessione ed esce dal sottoprogramma.
Lo script che ho realizzato per inserire i dati presi da arduino è molto semplice:
<?php
require("config.php");
$pioggia=$_GET['pioggia'];
$temp=$_GET['temperatura'];
$umidita=$_GET['umidita'];
$luce=$_GET['luce'];
$allarme=$_GET['allarme'];
$aiuola1=$_GET['aiuola1'];
$aiuola2=$_GET['aiuola2'];
$aiuola3=$_GET['aiuola3'];
$sql="INSERT INTO `sensori` (`umidita`, `temperatura`, `luce`, `pioggia`, `id_sens`, `allarme`,`aiuola1`, `aiuola2`, `aiuola3`) VALUES ('".$umidita."', '".$temp."', '".$luce."', '".$pioggia."', NULL, '".$allarme."','".$aiuola1."','".$aiuola2."','".$aiuola3."');";
$retval = mysql_query($sql, $connessione);
$sql1="SELECT * FROM `sensori` WHERE `id_sens` LIKE 15";
$result = mysql_query($sql1) ;
if(mysql_num_rows($result) != 0)
{
$elimina="TRUNCATE TABLE `sensori` ";
mysql_query($elimina);
}
?>
Infatti esso, dopo aver svolto le funzioni di spostamento delle variabili, semplicemente invierà i dati al database, creando una nuova istanza della tabella sensori, almeno fino a quando il database non conterà 15 istanze, infatti, una volta che “id_sens” sarà uguale a 15, tutte le istanze della tabella verranno cancellate con il comando TRUNCATE, questo per permettere alla base di dati di non essere riempita da troppe istanze e per avere dei grafici ben definiti e in un arco di tempo limitato.
Invio del messaggio a un numero tramite scheda GSM:
if(All==true && All1==true && bool==false)
{
serialSIM800.write("AT+CMGF=1\r\n");
delay(1000);
serialSIM800.write("AT+CMGS=\"3893108012\"\r\n");
delay(1000);
serialSIM800.write("SISTEMA IN ALLARME");
delay(1000);
serialSIM800.write((char)26);
delay(1000);
bool=true;
}
else
{
if(All==false || All1==false)
{
bool=false;
}
}
In questo caso ho dichiarato una variabile booleana, che verrà dichiarata come “false”, giusto per evitare che il nostro Arduino invii mille messaggi al nostro cellulare, nel primo if, oltre a controllare lo stato della variabile, si controlla anche che l’allarme sia attivo e che il movimento sia stato registrato.
Una volta dentro entrati nell’if troveremo numerosi “delay” (ritardo), essi servono per consentire un corretto “dialogo” tra l’Aduino e la scheda GSM.
Tramite alcuni comandi di stampa, consentiremo alla nostra scheda di registrare il nostro numero e di inviare il messaggio scelto, in questo caso “SISTEMA IN ALLARME”.
Nonostante l’invio non sia immediato, dato che comunque facciamo leva su un servizio esterno, è molto più immediato rispetto a un e-mail, infatti ci avviserà subito del problema e non avremo bisogno di accedere alla nostra casella di posta per controllare lo stato della casa.
Nel caso in cui il primo if non sia rispettato, nell’else, si effettuerà un altro controllo e nel caso in cui l’allarme sia disattivato, riporta lo stato di “bool” a “false” per consentire l’invio di un altro messaggio una volta che l’allarme viene riattivato e il sensore regista un movimento.
Elementi di Javascript
Per questo progetto non mi sono lasciato mancare nulla, infatti, nonostante il JS non sia presente in tutte le pagine del sito, almeno per quanto riguarda i grafici e per effettuare connessioni asincrone (e quindi velocizzare il caricamento del sito).
Il codice per permettere tale connessione asincrona è il seguente:
<script type="text/javascript">
(function() {
// creo un elemento di tipo script
var asjs = document.createElement('script');
// definisco il valore dell'attributo type
asjs.type = 'text/javascript';
// imposto il caricamento asincrono
asjs.async = true;
// imposto il valore dell'attributo src
asjs.src ='nell.php';
// accodo il tag script creato dinamicamente al tag head o body
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(asjs);
}());
</script>
Tale codice mi è stato molto utile per consentire una connessione più veloce all’Iframe dei grafici, la connessione alla pagina impiegava circa un minuto se eseguita tramite collegamento sincrono e ciò era dovuto non solo a una naturale lentezza del frame, ma anche alla pesantezza della pagina relativa ai grafici, che oltre a caricare lo script in PHP, deve occuparsi anche di caricare la libreria “chart.js”. Una libreria gratuita che consente di selezionare e utilizzare numerosissimi tipi di grafo.
Codice dei grafici:
<?php
$inp;
require("config.php");
$sql1="SELECT * FROM `sensori` WHERE `id_sens` = 14";
$resultc=mysql_query($sql1);
if(mysql_num_rows($resultc)< 1)
{
$Inp=0;
echo "<div class=\"auto-style2\" style=\"width:100% ;height: 100%\"> ";
echo "<img alt=\"loading\" src=\"loading.gif\" height=\"100%\" width=\"100%\">";
header("Refresh: 0.2; url=" . $_SERVER["PHP_SELF"]);
echo "</div>";
die();
}
else
{
$inp=1;
$sql01="SELECT * FROM `sensori` WHERE `id_sens` = 1";
$result01=mysql_query($sql01);
if(mysql_num_rows($result01)== 1)
{
while($row = mysql_fetch_array($result01))
{
$umidita1 = $row['umidita'];
$temperatura1 = $row['temperatura'];
$luce1=$row['luce'];
$pioggia1=$row['pioggia'];
$allarme1=$row['allarme'];
}
}
[…]
<div>
<hr style="height: 10px">
<p class="auto-style2">Umidità</p>
<hr>
<canvas id="umidita" height="300" width="600"></canvas>
<hr style="height: 10px">
</div>
[…]
<script>
var data1 = {
labels : ["01","02","03","04","05","06","07","08","09","10","11","12","13","14"],
datasets : [
{
label: "My First dataset",
fillColor : "#7887AB",
strokeColor : "rgba(0,0,255,0.3)",
pointColor : "#fff",
pointStrokeColor : "#4F628E",
pointHighlightFill : "#4F628E",
pointHighlightStroke : "rgba(220,220,220,1)",
data : [<?php echo $umidita1; ?> ,<?php echo $umidita2; ?>,<?php echo $umidita3; ?>,<?php echo $umidita4; ?>,<?php echo $umidita5; ?>,<?php echo $umidita6; ?>,<?php echo $umidita7; ?>,<?php echo $umidita8; ?>,<?php echo $umidita9; ?>,<?php echo $umidita10; ?>,<?php echo $umidita11; ?>,<?php echo $umidita12; ?>,<?php echo $umidita13; ?>,<?php echo $umidita14; ?>]
}
]
}
var ctx = document.getElementById("umidita").getContext("2d");
var myLine1 = new Chart(ctx).Line(data1, {
responsive: true
});
</script>
Lunghino nevvero? Infatti so benissimo che questa parte di codice non mi è riuscita benissimo, potevo ottimizzarla tantissimo, ma il tempo era poco e le cose da fare davvero tantissime, l’importante è che funzioni, giusto?
Comunque, nella prima parte di codice si verifica la quantità di istanze presenti nel database, se sono meno di 14, il php stamperà una gif di attesa e si autoricaricherà ogni 0.2 secondi grazie al comando “header”.
Completato l’inserimento di dati nel database, si eseguiranno dei passi fondamentali per la corretta riuscita dei grafici:
Innanzitutto si farà una query di tipo SELECT per ogni istanza e dopo di essa utilizzeremo un while che ci consentirà di scorrere l’istanza (grazie alla condizione “$row=mysql_fetch_array($result01)”) e quindi i dati di ogni istanza verranno salvati in alcune variabili.
Successivamente vado a dichiarare dei “canvas” ovvero dei contenitori dove gli script verranno eseguiti, in questo caso devo dichiarare un canvas a grafico
Infine aggiungo lo script, anche in questo caso uno a grafico, e tramite i parametri che la libreria JS mi obbliga a utilizzare, regolo il colore della linea in rgba (rgb con trasparenza) e inserisco i dati presi precedentemente in php all’interno di un array.
Ora non ci resta che dichiarare il canvas di destinazione e gustarci il risultato dei nostri sforzi
TPSIT, sistemi e reti
Come abbiamo potuto vedere fino ad adesso, il progetto, per funzionare come dovrebbe, deve instaurare una connessione tra almeno 2 client e il server.
Andiamo adesso a vedere le caratteristiche principali del modello client-server.
Server: il server è un host, che grazie ai suoi applicativi, riesce a fornire uno o più servizi ai diversi client. Il server, a sua volta, può essere un client, nel momento in cui richiede un servizio ad un’altra macchina (quindi ad un altro server).
Client: Il client può essere un normalissimo terminale, il cui compito è quello di richiedere risorse è servizi a un determinato server.
Servizio: Un servizio è un’entità astratta fornita da uno o più server che cooperano via rete.
Socket: Il socket serve per individuare una determinata applicazione di rete su un server specifico e quindi è formato dalla coppia <indirizzo IP: numero porta dell’applicativo>. Ad esempio, nel nostro caso, l’indirizzo IP del nostro server è “192.168.1.104” e la porta logica che l’applicativo, per gestire il sito, utilizza è “80”, quindi il nostro socket sarà “192.168.1.104:80”
Comunicazione unicast: Tale comunicazione fa sì che il server possa comunicare solo con un client alla volta
Comunicazione multicast: Questa è la comunicazione utilizzata nel nostro caso, infatti essa permette a più client di comunicare con il server. Tanto è vero che nel caso in cui la comunicazione tra il client e il server vada a buon fine, il server si occuperà di creare un thread per quel determinato client e di spostare la porta di accesso all’applicativo, in modo tale da garantire ulteriori comunicazioni ad altri client.
Ad esempio, un web server deve garantire tale comunicazione, infatti sul sito realizzato possono connettersi più cellulari o dispositivi contemporaneamente.
Il livello application del modello TCP/IP implementa vari protocolli, oltre al già visto HTTP, tra cui:
•FTP (Protocollo di trasferimento dati)
•POP3 (Protocollo di posta)
•SMTP (Semplice protocollo di invio email)
•DNS (Nome del dominio)
•SNMP(Protocollo per la gestione di reti semplici)
Ogni protocollo viene utilizzato da numerose applicazioni di rete, ad esempio:
•Apache: HTTP
•Firezilla: FTP
•Sendmail: SMTP
Oltre alle applicazioni generali esistono numerosissime applicazioni proprietarie, create per la gestione privata e sono delle applicazioni “su misura”
XAMPP, in particolare, è un applicativo che ci consente di utilizzare altri applicativi di rete, che a loro volta, sono costituiti da più programmi.
Web Server
Come abbiamo visto esso è un servizio che utilizza i protocolli HTTP e FTP, per rispondere alle richieste del client WEB in una rete TCP/IP.
Il client richiede una risorsa e invia la richiesta al server tramite un browser, il browser si occuperà di “tradurre” tale richiesta in un comando HTTP e un URL.
Il Server risponde a tale richiesta inviando un documento memorizzato staticamente sul file system, ma può anche generare dinamicamente tali file.
Non è affatto difficile creare un Web Server, per cui l’applicazione di rete più utilizzata è apache, che ci permette di avere numerosi strumenti e inoltre abbiamo moltissimi modi per configurarla.
Tramite i file .ini e .conf possiamo cambiare tutte le impostazioni predefinite, dalla porta logica utilizzata da socket fino alla cartella del file system dove il sito risiede.
Ciò ci permette di risolvere alcuni problemi, ad esempio, nel caso in cui sul nostro computer sia installato un altro applicativo che utilizza la porta 80, tramite una serie di passaggi che adesso vi mostrerò, sarà possibile utilizzare un’altra porta:
Innanzitutto apriamo il “XAMPP control panel” e da lì clicchiamo la voce “config” sulla riga di “apache”e successivamente selezioniamo la voce “Apache (httpd.conf)”
Si aprirà un documento di testo, tramite la voce “trova” del nostro blocco note dobbiamo cercare la voce Listen e modificare la porta a nostro piacimento:
Poi bisogna modificare anche la direttiva ServerName:
Infine riavviare apache.
Grazie a questo sono riuscito ad aggirare un servizio di Microsoft (IIS) che occupava la porta 80, dato che non conoscevo tale servizio, non sapevo come disattivarlo e l’intero progetto rischiava di andare in fumo, tale metodo mi è stato davvero molto utile.
Inoltre, dato che le sperimentazioni in questo campo non hanno mai fine, mostrerò come è possibile sbloccare la porta 80 sul router e quindi permettere l’accesso al nostro sito a chiunque volesse accedervi via internet, l’importante è utilizzare il nostro indirizzo IP pubblico, o meglio quello che ci viene offerto dal nostro ISP.
Innanzitutto bisogna conoscere l’indirizzo del gateway, per fare ciò basta aprire il cmd (o il terminale se siamo utenti linux) e digitare “ipconfig” (da linux “ifconfig”) e il risultato sarà più o meno questo:
In questo caso l’indirizzo del nostro gateway è “192.168.1.1”
Aperto il Browser digitiamo l’indirizzo e ci troveremo davanti alla schermata di configurazione del router che nel mio caso è Vodafone (quindi a meno che voi non abbiate lo stesso ISP la seguente guida potrebbe non essere molto utile, ma solo uno spunto)
Ci troveremo davanti a un menù, andiamo su “Avanzate” e dal sotto menù scegliamo “port forwading”, il servizio relativo all’ HTTP molto probabilmente sarà già presente, quindi, nel caso in cui abbiamo il numero della porta, dovremo rimuovere tale impostazione e riconfigurarla inserendo la porta interna corretta
Sistemi
Per quanto riguarda l’utenza, non ci troviamo davanti a un traffico vasto, tanto per tanto dopo un’analisi possiamo trovare i seguenti gruppi:
Tecnico: Tale figura non sarà presente in ogni caso, ma è una figura specializzata che potrà avere accesso alla rete solo nel caso di guasto.
Amministratore: In questo caso è il padrone della casa, non deve avere delle conoscenze elevate.
Utenti normali: Utente con accesso alla rete, ma con dei privilegi ridotti sulla casa
Ospiti: Non avranno accesso alla gestione della casa fino a quando l’amministratore non deciderà di promuoverli a utenti normali o ad amministratori
La nostra è una piccola LAN, lo scopo di tale rete e consentire al server, ad Arduino e i relativi dispositivi di comunicare tra di loro, inoltre è predisposta una connessione a internet per consentire agli utenti di poter usufruire di accedere ad altri servizi di uso comune, visto che in ogni caso stiamo parlando di una rete domestica.
Per la LAN si adotterà una soluzione cablata con una delle specifiche Ethernet 802.3, magari con un cablaggio in cat. 5e da 100Mb/s.
Alla rete LAN viene affiancato un Access Point, per consentire a dispositivi quali cellulari di potersi connettere al Server Web e alla relativa connessione a internet, quindi secondo specifiche IEEE 802.11n o superiori (che garantiscono un flusso di dati pari a un massimo di 300Mb/s)
Di solito le antenne di questi dispositivi permettono una copertura di circa 100 metri quadrati, ma nel caso in cui ci dovessimo trovare in un’abitazione più grande bisognerebbe prevedere l’utilizzo di ripetitori in punti strategici. L’accesso alla rete WLAN deve essere necessariamente bloccato da una chiave di accesso, magari con cifratura WPA2
Gli indirizzi IP forniti ai dispositivi mobili che si connettono alla rete WLAN della casa vengono gestiti dal DHCP (Dynamic Host Configuration Protocol), esso ci permette di assegnare dinamicamente gli indirizzi, senza causare conflitti e garantendo l’automazione dell’assegnazione, quindi l’amministratore non ha bisogno di inserire gli indirizzi manualmente.
Inoltre il DHCP ci permette di riutilizzare gli indirizzi, infatti l’IP, all’interno del DHCP server, non per forza deve essere collegato a un indirizzo MAC specifico, ma anzi, nel 90% dei casi il DHCP viene impostato per l’assegnazione dinamica e non automatica.
Per quanto riguarda i protocolli del livello application, trattandosi di una applicazione web, possiamo dire che il livello Trasporto farà riferimento al protocollo TCP.
In ogni caso, sia al Server Web, sia al client di Arduino sono stati impostati degli indirizzi IP statici per permettere lo scambio di dati.
Server Web: 192.168.1.104
Arduino: 192.168.1.105
I due non sono collegati direttamente, ma tramite uno switch.
GPOI
La casa domotica è un progetto il cui scopo è stato raggiunto, per il quale si è lavorato in team, dove ognuno aveva il proprio ruolo e il proprio incarico.
La definizione di progetto, secondo il PMI (project management institute) è la seguente: “uno sforzo temporaneo intrapreso per creare un prodotto, un servizio o un risultato con caratteristiche di unicità”
Quindi il nostro progetto deve rispettare 4 punti fondamentali:
•Ha uno scopo ben definito (dimostrare le nostre capacità)
•Svolto in un determinato arco di tempo
•Vincoli da rispettare e rischi da valutare
•Termina quando lo scopo è raggiunto
In questo caso parliamo della scuola come azienda, dato che i progetti non sono stati pochi e dovevano rientrare in un programma. Ad esempio il nostro progetto, l’aggiornamento della mappa della Minerva (scritta in JAVA e realizzata da me e Cristian Germino durante l’anno scolastico 2014/2015), “Salerno with you” e “L’App della Minerva”, dovevano essere completati entro il giorno 15 Aprile 2016, per essere quindi mostrati come un programma all’utenza dell’evento.
In questo caso non parliamo di un’azienda alla ricerca del profitto, dato che il 90% dei nostri progetti non può diventare facilmente un prodotto, almeno fin quando siamo in ambiti scolastici.
Quindi lo scopo principale del nostro istituto è farsi pubblicità, il che significa avere più iscritti per gli anni successivi, attraverso il programma, mentre tramite i progetti l’obbiettivo della scuola è quello di riuscire a darci una visione più ampia riguardo le nostre conoscenze lavorative.
Il nostro progetto ha avuto un particolare ciclo di vita.
L’avvio: (datato 15/01/2016) dove si è definita una tabella di marcia, si è fatto un preventivo sui componenti e sono state valutate le problematiche
L’esecuzione: (23/01/2016 fino a 10/04/2016) Realizzazione parte hardware, software e design della casa.
Chiusura: (11/04/2016 fino a 18/04/2016) Test generale, verifica del conseguimento degli obiettivi e visione del progetto al pubblico alla mostra della Minerva.
In genere, durante la fase di avvio, viene stilato un “Project Charter”, ovvero un documento in cui vengono delineate le caratteristiche fondamentali di un progetto:
Obiettivi: Ovvero ciò a cui punta il progetto; dove vuole arrivare? Quali sono i suoi scopi?
Deliverables: risultati parziali, ma che possono essere testati.
Milestones: risultati importanti del progetto.
Vincoli e dipendenze: Ad esempio il training o gli ambienti di sviluppo.
Tempistica Preliminare: Ovvero quanto tempo di lavoro è necessario per il raggiungimento dello scopo.
Risorse Principali e limiti di costo: Ciò che è di necessaria importanza per il conseguimento del progetto e quanti soldi posso essere spesi in totale.
Struttura organizzativa: Individuazione del Manager del progetto e del team.
Project Charter del nostro progetto:
Nome Progetto: Casa domoticaSponsor: I.T.T. Basilio Focaccia
Data: 17/01/2016Codice progetto: 000
Cliente: Mostra della minervaRevisione: 0
1.OBIETTIVI
L’OBIETTIVO PRINCIPALE DELLA CASA DOMOTICA È QUELLO DI MOSTRARE, IN PICCOLO, LA COSTANTE EVOLUZIONE DELLE TECNOLOGIE, E LA POSSIBILITÀ DI GESTIRE UNA CASA TRAMITE UN CELLULARE
2.PRINCIPALI DELIVERABLE
PROJECT MANAGEMENT: PIANIFICAZIONE
PROGETTAZIONE: SCELTA DESIGN CASA
PROGETTAZIONE: INTERFACCIA SITO
ESECUZIONE: AVVIO WEB SERVER
ESECUZIONE: COLLEGAMENTO DISPOSITIVI ALL’ARDUINO
ESECUZIONE: FUNZIONAMENTO DEI DISPOSITIVI
3.MILESTONE
APPLICAZIONE WEB
COMPLETAMENTO PARTE HARDWARE
FINE COSTRUZIONE DELLA CASA
4.VINCOLI E DIPENDENZE
LE RISORSE ESTERNE SONO:
•APPLICATIVI GESTIONE SITO WEB;
•IDE ARDUINO.
5.TEMPISTICA PRELIMINARE
IL PROGETTO INIZIA IL 17/01/2016 E DEVE CONCLUDERSI IL 15/04/2016
6.PRINCIPALI RISORSE E LIMITI DI COSTO
PER QUANTO RIGUARDA IL SOFTWARE SONO STATI UTILIZZATI DEI PROGRAMMI OPEN-SOURCE, MA IL COSTO RELATIVO ALL’HARDWARE È ONEROSO (450 EURO CIRCA).
LE RISORSE MATERIALI IMPEGNATE RIGUARDANO LE POSTAZIONI DI LAVORO E LA DISPONIBILITÀ DI UNA RETE LAN PER LO SVILUPPO E IL TESTING.
IL PROGETTO NON PORTERÀ UN RITORNO ECONOMICO
7.STRUTTURA ORGANIZZATIVA
I PROJECT MANAGER SONO: MATTEO TRIVISONE(SOFTWARE) E ANTONELLO AVELLA(HARDWARE)
IL TEAM È COMPOSTO DA ALTRE 3 PERSONE, GIOACCHINO SARACENO, GAETANO NOCERINO, FRANCESCO APICELLA
Un altro passo fondamentale per la pianificazione di un progetto è la Work Breakdown Structure, una rappresentazione grafica e gerarchica dove andremo a dichiarare tutti i processi che permetteranno al progetto di compiersi.
Una delle regole più importanti è la regola del 100%, ogni fase progettuale, di qualsiasi livello, deve essere dichiarata all’interno del grafico o nella lista delle attività.
Ecco la DWB del nostro progetto:
E qui invece la lista delle attività, che ricordiamo essere un’elaborazione della DWB, pensiamo alla DWB come un modello E/R e alla activity list come il suo modello logico:
Nome Progetto: Casa domoticaSponsor: I.T.T. Basilio Focaccia
Data: 17/01/2016Codice progetto: 000
Cliente: Mostra della minervaRevisione: 0
WBSDescrizioneDurata (gg)
1.1 AVVIO
1.1.1Acquisizione ambiente di sviluppo 3
1.1.2Training linguaggio Arduino 5
1.2 PIANIFICAZIONE
1.2.1Progettazione Hardware5
1.2.2Progettazione Software5
1.2.3Progettazione design della casa4
1.3 REALIZZAZIONE
1.3.1Software/Hardware Arduino20
1.3.2Database3
1.3.3Interfaccia e realizzazione sito 26
1.3.4Completamento struttura della casa25
1.4 CHIUSURA
1.4.1Mostra alla fiera della minerva3
Infine, nonostante i non pochi problemi, siamo riusciti a terminare il progetto riuscendo in tutti quelli che erano i processi o fasi che ci eravamo imposti, per il resto, a parte l’ansia, che anche adesso a pochi giorni dall’esame, si è fatta sentire, sono molto felice di averlo portato a termine, dato che ritenevo (detto molto sinceramente) sarebbe stato impossibile completare tutti gli obbiettivi.
Conclusione
Parte inutile allo scopo della relazione, essa contiene considerazioni che nulla hanno a che fare con il progetto o con le materie di studio.
Questi 5 anni sono passati in fretta e ogni anno ha segnato per me un cambiamento profondo e radicale. Pensare che in seconda, il primo e il secondo trimestre, avevo 1 in informatica e a stento sapevo la differenza tra GUI e CUI. Adesso, nonostante non sono un chissà quale esperto e conoscitore, ho dato le mie soddisfazioni alla scuola, garantendo una conoscenza, più che dal punto di vista teorico, dal punto di vista pratico.
Infatti non sono mai stato un grande studioso, anzi, se non fosse nata questa miracolosa passione, a quest’ora starei in un istituto d’arte a cercare di trasformare la tristezza del fallimento in note o meravigliose pagine che raccontano il nulla assoluto; al posto di combattere contro me stesso e gli altri per raggiungere un sogno, sarei stato come una zattera preda della tempesta, né timone, né ancora, né salvagente, solo 4 pezzi di legno circondati dall’acqua.
Ma ora sono qui, pronto sia a fallire che a superare questo esame (si intende anche psicologicamente).
"After 5 years you're still Max Caulfield."
Infatti, nonostante tutto, sono ancora Matteo Trivisone, il ragazzo che ama studiare solo ciò che ama, l’egoista che metterebbe a ferro e fuoco l’intero mondo solo per salvare chi veramente ha lottato per avere un posto nel suo cuore, quella persona superba e spesso testarda che crede di avere ragione in ogni caso e il ragazzo che brama vendetta per ogni torto subito. Ma con tutti i miei difetti, con tutto il male che ho potuto dare al prossimo, ho anche raggiunto dei risultati che persino io stento a credere, anche questo 10 in informatica, l’aver vinto un concorso di poesia, l’aver completato questa casa, l’aver realizzato una mappa in JAVA iniziando conoscendo solo la definizione di oggetto e infine avere un obiettivo e un sogno.
Forse non ci rivedremo molto spesso, certo vi verrò a trovare, ma i miei piani mi costringono a scappare da questa terra infelice e della quale io non mi sento né figlio, né schiavo.
Ma vi prometto che un giorno, sia esso vicino o lontano, ci rincontreremo su questa città baciata dal mare e protetta dalle montagne. Promettetemi di non cambiare, di rimanere come sempre siete stati, fari nella notte e aiutanti di giovani anime come le nostre. Promettetemi di aiutare altri studenti come avete fatto con me, non lasciate che prendano strade negative, educateli come avete fatto con noi, amateli come figli. Potete anche essere gli insegnati più colti di questo mondo, ma se perdete l’umanità non siete nulla, quindi continuate a insegnare, a ridere e a scherzare come sempre avete fatto, cercate di non creare asti fra colleghi, già bastiamo noi alunni con la nostra immaturità.
Fino a qualche mese fa odiavo quella prigione, mi sentivo stretto, la mia mente volava verso il futuro e verso l’Università, ma oggi conservo un ricordo di amore verso tutti voi, verso la mia classe e verso i miei professori.
“In a world without you I'll dream of you.”
Ho solo un’ultima considerazione da fare, quando entrai in questa scuola mi dissero: “qui al Focaccia non facciamo videogiochi” vi giuro, per quanto ci abbia provato non ci sono mai riuscito, è forse l’unica cosa che non sono mai riuscito a programmare, nonostante ci abbia passato intere notti. Non amo molto questa discriminazione, capisco che ci troviamo in un ambiente serio, dove si studia, ma bisogna anche capire la differenza tra ciò che si crea per conoscere e ciò che si fa per divertimento.
Si ringraziano le seguenti persone:
Armando e Mario: se trovare un amico equivale ad avere un tesoro io sono la persona più ricca del mondo.
I miei compagni di classe: grazie per avermi sopportato questi 3/5 anni
I miei professori: chi più chi meno, mi avete sempre sostenuto (“zitt a chi sap u juoc”)
Un abbraccio profondo a Tetsuya Nomura, Hideaki Anno, Toby Fox e Christian Divine: Quando l’informatica diventa arte il confine tra vita e sogno diventa quasi percettibile.
A mia madre: che mi ha sempre costretto a studiare, ti voglio bene
Dedico questa relazione a Sinot e Talesia Dascare: Sarete voi i miei eroi un giorno?
“Someday we will foresee obstacles through the blizzard”