connette ad Internet con la Shield Ethernet ufficiale

Транскрипт

1 Lezione 13: Arduino si connette ad Internet con la Shield Ethernet ufficiale In questo tredicesimo capitolo introdurremo un dispositivo, che forse, è il più importante che viene collegato ad Arduino: Ethernet Shield. Questa scheda, infatti, permette di collegare Arduino alla rete, per poter recuperare e caricare dati e risorse da/a Internet. Il successo che ha avuto Internet nel corso degli ultimi anni, è dovuto alla sua semplicità di utilizzo; esso permette di

2 recuperare facilmente informazioni, come ad esempio il meteo dei prossimi giorni, news e sopratutto per la comunicazione. Infatti basta una semplice connessione ADSL oppure 3G, per poter accedere a questa grande risorsa, che prende il nome di WWW (World Wide Web). Inoltre, recentemente, sta spopolando l Internet delle cose, meglio noto con il nome Inglese Internet of Things. Ecco una breve definizione tratta da Wikipedia: In telecomunicazioni Internet delle cose (o, più propriamente, Internet degli oggetti o IoT, acronimo dell inglese Internet of Things) è un neologismo riferito all estensione di Internet al mondo degli oggetti e dei luoghi concreti. Il suo primo utilizzo ebbe luogo probabilmente nel 1999 [1] presso l Auto-ID Center, un consorzio di ricerca con sede al MIT [2]. Il concetto fu in seguito sviluppato dall agenzia di ricerca Gartner[3][4][5]. In poche parole, attraverso l Internet delle cose, è possibile trasformare oggetti semplici, come ad esempio sensori PIR, termistori etc in oggetti in grado di poter comunicare attraverso la rete. Vedremo tanti progetti a riguardo nei prossimi capitoli.

3 Per prima cosa dobbiamo parlare un po di che cos è Internet, come funziona, quali sono i suoi protocolli. Si può definire Internet, come una grande rete, fatta da tantissimi piccole reti, connesse tra di loro. Dal punto di vista tecnico, si parla di pila protocollare di Internet, in quanto per il corretto funzionamento delle varie reti presenti, ci sono 5 livelli, ognuno con un preciso compito da svolgere: 1. Strato Fisico (PDU-1) 2. Strato Collegamento (frame) 3. Strato di Rete (datagram) 4. Strato di Trasporto (segmento) 5. Strato di Applicazione (messaggio) Lo strato di applicazione è responsabile del supporto delle applicazioni della rete. Per esempio i protocolli più importanti sono HTTP e HTTPS, con i quali è possibile vedere le pagine web, il SMTP, con il quale è possibile inviare e tantissimi altri. Lo strato di trasporto fornisce il servizio di trasmissione del messaggio alla rete. Per esempio in questo messaggio è presente il testo della nostra che abbiamo inviato ad un

4 nostro amico, oppure la richiesta di vedere una determinata pagina web. In questo strato ci sono due protocolli importanti; TCP (Trasmission Control Protocol) UDP (User Datagram Protocol) Senza entrare troppo nel dettaglio, si può riassumere i due protocolli in questo modo; il TCP è un grado di garantire la corretta ricezione da parte di un dispositivo del messaggio che è stato inviato, dispone di un controllo del flusso e della congestione, mentre l UDP non fornisce nessuna garanzia. Il TCP viene usato quasi sempre, quando cioè non si vuole perdere i dati che vengono trasmessi, come ad esempio posta elettronica etc L UDP viene usato, per esempio, quando si trasmettono dei filmati, i quali dispongono degli algoritmi che permettono di tollerare la perdita di qualche pacchetto. Inoltre l UDP non limita la velocità con un cui un host, può inviare i pacchetti, mentre il TCP limita. Lo strato di rete è responsabile dell instradamento di un datagram tra due host connessi alla rete. Inoltre, vengono implementati degli algoritmi di instradamento, per ridurre il tempo impiegato per far comunicare due dispositivi. Lo strato di collegamento viene delegato dallo strato di rete, per collegare due o più commutatori, ad esempio router. Lo strato fisico è responsabile a gestire il trasporto di bit tra diversi host. Per esempio lo strato fisico è la nostra connessione ADSL. Riassumiamo con un esempio quanto spiegato precedentemente. Per esempio, il mio PC è connesso via Ethernet con indirizzo IP al router ADSL che ha IP Dopo aver aperto il browser, viene fatta una ricerca sul WEB e aprendo un sito, viene utilizzato il DNS (che sfrutta il protocollo

5 UDP). Il DNS ha il compito di trasformare il sito Google.com, nel suo indirizzo IP. Questo viene fatto perché è più semplice ricordare il nome google.com, che il suo indirizzo IP pubblico. La richiesta di apertura del sito Google.com, viene fatta sfruttando il TCP/IP, utilizzando il protocollo applicativo HTTPS. La richiesta viene fatta attraverso un GET (vedremo spesso questo nome all interno dei codici di Arduino) e il nostro router invierà il pacchetto all indirizzo del server dove è presente la pagina web che abbiamo richiesto. Nel processo di ritorno della pagina web, il nostro router svolgerà il ruolo di NAT, cioè quello di consegnare il pacchetto al dispositivo che ha richiesto. Ora che abbiamo completata la parte di teoria sui meccanismi con cui funziona Internet, parliamo più dettagliatamente della scheda ufficiale di Arduino. Il nome è W150, che corrisponde a quello del controllore presente sulla scheda.

6 Per chi fosse interessato al datasheet del dispositivo, è possibile scaricarlo da questo link W5100_Datasheet_v Come si può notare la scheda è dotata di una porta RJ-45, con la quale è possibile collegare Arduino ad Internet, di uno slot per le memoria micro-sd e dei medesimi PIN disponibili in Arduino. L installazione, dal punto di vista hardware è davvero semplice, in quanto occorre posizionarla sopra Arduino Uno, inserendo i PIN in modo corretto. Sarà possibile comunque usare i PIN per i nostri progetti, dal momento che esiste un contatto tra la scheda Ethernet e Arduino Uno. Ora verranno presentati i primi programmi che utilizzano la Shield Ethernet di Arduino, che sono tratti dalla libreria ufficiale, già presente nell IDE di Arduino. 1 Programma: Hello Webserver Questo prima programma, permette di effettuare una richiesta HTTP al server di Google (google.com). Il risultato della richiesta, viene mostrato nel seriale di Arduino. /* Web client This sketch connects to a website ( using an Arduino Wiznet Ethernet shield. Circuit: * Ethernet shield attached to pins 10, 11, 12, 13 created 18 Dec 2009 by David A. Mellis modified 9 Apr 2012 by Tom Igoe, based on work by Adrian McEwen */ #include <SPI.h>

7 #include <Ethernet.h> // Enter a MAC address for your controller below. // Newer Ethernet shields have a MAC address printed on a sticker on the shield byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; // if you don't want to use DNS (and reduce your sketch size) // use the numeric IP instead of the name for the server: //IPAddress server(74,125,232,128); // numeric IP for Google (no DNS) char server[] = " // name address for Google (using DNS) // Set the static IP address to use if the DHCP fails to assign IPAddress ip(192,168,0,177); // Initialize the Ethernet client library // with the IP address and port of the server // that you want to connect to (port 80 is default for HTTP): EthernetClient client; void setup() { // Open serial communications and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only // start the Ethernet connection: if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); // no point in carrying on, so do nothing forevermore: // try to congifure using IP address instead of DHCP: Ethernet.begin(mac, ip); // give the Ethernet shield a second to initialize: delay(1000); Serial.println("connecting...");

8 // if you get a connection, report back via serial: if (client.connect(server, 80)) { Serial.println("connected"); // Make a HTTP request: client.println("get /search?q=arduino HTTP/1.1"); client.println("host: client.println("connection: close"); client.println(); else { // kf you didn't get a connection to the server: Serial.println("connection failed"); void { // // if loop() if there are incoming bytes available from the server, read them and print them: (client.available()) { char c = client.read(); Serial.print(c); // if the server's disconnected, stop the client: if (!client.connected()) { Serial.println(); Serial.println("disconnecting."); client.stop(); // do nothing forevermore: while(true); Sebbene i commenti del codice siano in Inglese, è davvero semplice capire cosa compiono le varie funzioni presenti. La più importante è Ethernet.begin(mac), che permette di far ottenere l indirizzo IP ad Arduino, utilizzando il DHCP. Per

9 maggiori informazioni riguardo alle funzioni presenti nella libreria Ethernet ufficiale di Arduino, è possibile andare al seguente link 2 Programma: Otteniamo l indirizzo IP via DHCP Il DHCP è strumento/servizio davvero utile nella attuali reti, dal momento che permette di configurare rapidamente il proprio dispositivo, qualora dovesse collegarsi a router diversi. In questo secondo esempio, vedremo come sia possibile ottenere l indirizzo IP con il DHCP e mostrato sul seriale. /* DHCP-based IP printer This sketch uses the DHCP extensions to the Ethernet library to get an IP address via DHCP and print the address obtained. using an Arduino Wiznet Ethernet shield. Circuit: * Ethernet shield attached to pins 10, 11, 12, 13 created 12 April 2011 modified 9 Apr 2012 by Tom Igoe */ #include <SPI.h> #include <Ethernet.h> // Enter a MAC address for your controller below. // Newer Ethernet shields have a MAC address printed on a sticker on the shield byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02 ; // Initialize the Ethernet client library // with the IP address and port of the server // that you want to connect to (port 80 is default for HTTP): EthernetClient client;

10 void setup() { // Open serial communications and wait for port to open: Serial.begin(9600); // this check is only needed on the Leonardo: while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only // start the Ethernet connection: if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); // no point in carrying on, so do nothing forevermore: for(;;) ; // print your local IP address: Serial.print("My IP address: "); for (byte thisbyte = 0; thisbyte < 4; thisbyte++) { // print the value of each byte of the IP address: Serial.print(Ethernet.localIP()[thisByte], DEC); Serial.print("."); Serial.println(); void loop() { 3 Programma: Mostriamo i valori dei PIN in una pagina WEB Uno dei motivi principali per cui poter è necessario utilizzare la Shield Ethernet, è quella di poter caricare dati, che vengono ricavati da sensori connessi ad Arduino Uno. In questo terzo esempio, vedremo come sia semplice scrivere in una pagina WEB i valori registrati dalla porte analogico di Arduino. /* Web Server

11 A simple web server that shows the value of the analog input pins. using an Arduino Wiznet Ethernet shield. Circuit: * Ethernet shield attached to pins 10, 11, 12, 13 * Analog inputs attached to pins A0 through A5 (optional) created 18 Dec 2009 by David A. Mellis modified 9 Apr 2012 by Tom Igoe */ #include <SPI.h> #include <Ethernet.h> // Enter a MAC address and IP address for your controller below. // The IP address will be dependent on your local network: byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; IPAddress ip(192,168,1,177); // Initialize the Ethernet server library // with the IP address and port you want to use // (port 80 is default for HTTP): EthernetServer server(80); void setup() { // Open serial communications and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only // start the Ethernet connection and the server: Ethernet.begin(mac, ip); server.begin();

12 Serial.print("server is at "); Serial.println(Ethernet.localIP()); void loop() { // listen for incoming clients EthernetClient client = server.available(); if (client) { Serial.println("new client"); // an http request ends with a blank line boolean currentlineisblank = true; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); // if you've gotten to the end of the line (received a newline // character) and the line is blank, the http request has ended, // so you can send a reply if (c == '\n' && currentlineisblank) { // send a standard http response header client.println("http/ OK"); client.println("content-type: text/html"); client.println("connection: close"); // the connection will be closed after completion of the response client.println("refresh: 5"); // refresh the page automatically every 5 sec client.println(); client.println("<!doctype HTML>"); client.println("<html>"); // output the value of each analog input pin for (int analogchannel = 0; analogchannel < 6; analogchannel++) { int sensorreading = analogread(analogchannel); client.print("analog input "); client.print(analogchannel); client.print(" is "); client.print(sensorreading); client.println("<br />");

13 client.println("</html>"); break; if (c == '\n') { // you're starting a new line currentlineisblank = true; else if (c!= '\r') { // you've gotten a character on the current line currentlineisblank = false; // give the web browser time to receive the data delay(1); // close the connection: client.stop(); Serial.println("client disconnected"); 4 Programma: Come ricevere pacchetti UDP con Arduino Come discusso nella parte teoria di introduzione al meccanismo di funzionamento di Internet, l UDP è meccanismo semplice di trasmissione, dal momento che non offre nessuna garanzia di trasmissione. In questo quarto programma, vedremo come poter ricevere in Arduino, un pacchetto UDP, che è stato inviato da un altro dispositivo. Per esempio questo dispositivo contiene le informazioni riguardo alla temperatura, oppure un messaggio etc /* UDPSendReceive.pde: This sketch receives UDP message strings, prints them to the serial port and sends an "acknowledge" string back to the sender A Processing sketch is included at the end of file that can be used to send and received messages for testing with a computer.

14 created 21 Aug 2010 by Michael Margolis This code is in the public domain. */ #include <SPI.h> // needed for Arduino versions later than 0018 #include <Ethernet.h> #include <EthernetUdp.h> // UDP library from: 12/30/2008 // Enter a MAC address below. // The IP address will be byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, IPAddress ip(192, 168, 1, and IP address for your controller dependent on your local network: 0xFE, 0xED ; 177); unsigned int localport = 8888; // local port to listen on // buffers for receiving and sending data char packetbuffer[udp_tx_packet_max_size]; //buffer to hold incoming packet, char ReplyBuffer[] = "acknowledged"; // a string to send back // An EthernetUDP instance to let us send and receive packets over UDP EthernetUDP Udp; void setup() { // start the Ethernet and UDP: Ethernet.begin(mac,ip); Udp.begin(localPort); Serial.begin(9600); void loop() { // if there's data available, read a packet

15 int packetsize = Udp.parsePacket(); if(packetsize) { Serial.print("Received packet of size "); Serial.println(packetSize); Serial.print("From "); IPAddress remote = Udp.remoteIP(); for (int i =0; i < 4; i++) { Serial.print(remote[i], DEC); if (i < 3) { Serial.print("."); Serial.print(", port "); Serial.println(Udp.remotePort()); // read the packet into packetbufffer Udp.read(packetBuffer,UDP_TX_PACKET_MAX_SIZE); Serial.println("Contents:"); Serial.println(packetBuffer); // send a reply, to the IP address and port that sent us the packet we received Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); Udp.write(ReplyBuffer); Udp.endPacket(); delay(10); /* Processing sketch to run with this example ===================================================== // Processing UDP example to send and receive string data from Arduino // press any key to send the "Hello Arduino" message import hypermedia.net.*;

16 UDP udp; // define the UDP object void setup() { udp = new UDP( this, 6000 ); // create a new datagram connection on port 6000 //udp.log( true ); // <-- printout the connection activity udp.listen( true ); // and wait for incoming message void draw() { void keypressed() { String ip = " "; address int port = 8888; port udp.send("hello World", ip, port ); // the remote IP // the destination // the message to send void receive( byte[] data ) { // <-- default handler //void receive( byte[] data, String ip, int port ) { // <-extended handler for(int i=0; i < data.length; i++) print(char(data[i])); println(); */ 5 Programma: Ricevere l ora, sfruttando Internet Come discusso nei precedenti capitoli, Arduino non dispone di un modulo RTC in grado di poter mantenere in memoria l ora, anche quando il dispositivo non è accesso. Per ovviare a

17 questo problema, ci viene incontro la rete, sfruttando i server NTC e l UDP. Vediamo il funzionamento di reperimento dell ora da Internet, in questo programma: /* Udp NTP Client Get the time from a Network Time Protocol (NTP) time server Demonstrates use of UDP sendpacket and ReceivePacket For more on NTP time servers and the messages needed to communicate with them, see Warning: NTP Servers are subject to temporary failure or IP address change. Plese check if the time server used in the example didn't work. created 4 Sep 2010 by Michael Margolis modified 9 Apr 2012 by Tom Igoe This code is in the public domain. */ #include <SPI.h> #include <Ethernet.h> #include <EthernetUdp.h> // Enter a MAC address for your controller below. // Newer Ethernet shields have a MAC address printed on a sticker on the shield byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ;

18 unsigned int localport = 8888; for UDP packets // local port to listen IPAddress timeserver(132, 163, 4, 101); // timea.timefreq.bldrdoc.gov NTP server // IPAddress timeserver(132, 163, 4, 102); // timeb.timefreq.bldrdoc.gov NTP server // IPAddress timeserver(132, 163, 4, 103); // timec.timefreq.bldrdoc.gov NTP server const int NTP_PACKET_SIZE= 48; // NTP time stamp is in the first 48 bytes of the message byte packetbuffer[ NTP_PACKET_SIZE]; //buffer to hold incoming and outgoing packets // A UDP instance to let us send and receive packets over UDP EthernetUDP Udp; void setup() { // Open serial communications and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for Leonardo only // start Ethernet and UDP if (Ethernet.begin(mac) == 0) { Serial.println("Failed to configure Ethernet using DHCP"); // no point in carrying on, so do nothing forevermore: for(;;) ; Udp.begin(localPort); void loop() { sendntppacket(timeserver); // send an NTP packet to a time

19 server // wait to see if a reply is available delay(1000); if ( Udp.parsePacket() ) { // We've received a packet, read the data from it Udp.read(packetBuffer,NTP_PACKET_SIZE); // read the packet into the buffer //the timestamp starts at byte 40 of the received packet and is four bytes, // or two words, long. First, esxtract the two words: unsigned long highword = word(packetbuffer[40], packetbuffer[41]); unsigned long lowword = word(packetbuffer[42], packetbuffer[43]); // combine the four bytes (two words) into a long integer // this is NTP time (seconds since Jan ): unsigned long secssince1900 = highword << 16 lowword; Serial.print("Seconds since Jan = " ); Serial.println(secsSince1900); // now convert NTP time into everyday time: Serial.print("Unix time = "); // Unix time starts on Jan In seconds, that's : const unsigned long seventyyears = UL; // subtract seventy years: unsigned long epoch = secssince seventyyears; // print Unix time: Serial.println(epoch); // print the hour, minute and second: Serial.print("The UTC time is "); // UTC is the time at Greenwich Meridian (GMT) Serial.print((epoch % 86400L) / 3600); // print the hour (86400 equals secs per day) Serial.print(':'); if ( ((epoch % 3600) / 60) < 10 ) { // In the first 10 minutes of each hour, we'll want a

20 leading '0' Serial.print('0'); Serial.print((epoch % 3600) / 60); // print the minute (3600 equals secs per minute) Serial.print(':'); if ( (epoch % 60) < 10 ) { // In the first 10 seconds of each minute, we'll want a leading '0' Serial.print('0'); Serial.println(epoch %60); // print the second // wait ten seconds before asking for the time again delay(10000); // send an NTP request to the time server at the given address unsigned long sendntppacket(ipaddress& address) { // set all bytes in the buffer to 0 memset(packetbuffer, 0, NTP_PACKET_SIZE); // Initialize values needed to form NTP request // (see URL above for details on the packets) packetbuffer[0] = 0b ; // LI, Version, Mode packetbuffer[1] = 0; // Stratum, or type of clock packetbuffer[2] = 6; // Polling Interval packetbuffer[3] = 0xEC; // Peer Clock Precision // 8 bytes of zero for Root Delay & Root Dispersion packetbuffer[12] = 49; packetbuffer[13] = 0x4E; packetbuffer[14] = 49; packetbuffer[15] = 52; // all NTP fields have been given values, now // you can send a packet requesting a timestamp: Udp.beginPacket(address, 123); //NTP requests are to port 123 Udp.write(packetBuffer,NTP_PACKET_SIZE); Udp.endPacket();

21 Questo codice sarà molto utile, quando nei nostri progetti avremmo bisogno di conoscere l ora e potremmo recuperare tale valore, sfruttando Internet, senza ricorrere ai moduli RTC. 6 Programma: Come inserire del codice HTML all interno del webserver In questo sesto programma vedremo come sia facile inserire del codice HTML all interno della pagina web che è presente nel webserver di Arduino. In questo modo potremmo inserire dei messaggi testuali, immagini e tanto altro. /** Questo programma mostra come sia possibile inserire del codice HTML all'interno della pagina web del webserver di Arduino*/ #include <SPI.h> #include <Ethernet.h> // Mac Address di Arduino byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ; // Viene inizializzata la libreria Ethernet di Arduino e il webserver gira sulla porta 80 EthernetServer server(80); void setup() { Serial.begin(9600); // Viene inilizzato il webserver e la connessione di rete Ethernet.begin(mac); server.begin(); Serial.print("server is at "); Serial.println(Ethernet.localIP()); void loop() { // Vengono ascoltati nuovi client EthernetClient client = server.available();

22 if (client) { Serial.println("new client"); // Finisce una richiesta HTTP boolean currentlineisblank = true; while (client.connected()) { if (client.available()) { char c = client.read(); Serial.write(c); // Se viene completato l'invio della richiesta HTTP, allora il server invia la risposta if (c == '\n' && currentlineisblank) { // Viene fatta una risposta HTTP, in pratica viene creata una pagina WEB in HTML client.println("http/ OK"); client.println("content-type: text/html"); client.println("connection: close"); // Dopo la risposta la connessione si interrompe //client.println("refresh: 5"); Ogni 5 secondi in automatico si aggiorna la pagina web client.println(); client.println("<meta charset=utf-8>"); // serve per inserire i caretteri speciali client.println("<!doctype HTML>"); client.println("<html>"); client.println("<head> <TITLE>Arduino</TITLE> </head>"); // Viene creato il Titolo client.println("<body> <h1> Benvenuto nel Webserver Arduino </h1>"); // Viene inserito del testo client.println("<h3> In questa pagina è possibile inserire il codice HTML che vuoi </h3>"); // Viene inserita una immagine, presente in un determinato server client.println("<img src = \" s/2013/06/arduinowifishield_front_450px.jpg\"alt = \"Arduino\""); client.println("</body>"); client.println("</html>"); break; if (c == '\n') {

23 currentlineisblank = true; else if (c!= '\r') { currentlineisblank = false; delay(1); // Viene chiusta la connessione client.stop(); Serial.println("client disconnected"); Il codice HTML è abbastanza semplice da usare, dal momento che esso utilizza dei tag per rappresentare delle funzioni, come ad esempio la creazione di un titolo. Vediamo gli esempi di HTML riportati nel codice di Arduino: "<head> <TITLE>Arduino</TITLE> </head>" Questa sintassi permette di creare il Titolo, che verrò mostrato nella pagina web dal Browser. <body> <h1> Benvenuto nel Webserver Arduino </h1> <h3> In questa pagina è possibile inserire il codice HTML che vuoi </h3> Attraverso questa sintassi è possibile inserire del testo, con un certa formattazione. Ad esempio il tag <h1> significa che la porzione del testo che viene scritta, è un titolo, mentre <h3> rappresenta un blocco di testo. <img src = \" s/2013/06/arduinowifishield_front_450px.jpg\"alt = \"Arduino\" Per poter inserire una immagine che si trova nel web, all interno del nostro webserver, basterà inserire il link dell immagine dopo il carattere = del codice presente. Per maggiori informazioni sul linguaggio HTML è possibile

24 leggere la pagina web di Wikipedia a riguardo. Per avere una sorta di manuale completo sui TAG di HTML, è possibile vedere i tantissimi esempi presenti su questo sito Nei prossimi capitoli vedremo come utilizzare la scheda Shield per i nostri progetti, che richiedono una connessione ad Internet. Lezione 12: Comunicazioni wireless low cost con Arduino In questa dodicesima puntata, vedremo come poter inviare tra diversi dispositivi dati in maniera wireless a bassissimo costo. Le comunicazioni wireless ( senza fili ) sono diventante ormai uno standard ben consolidato nei vari dispositivi che si dispone, come Smartphone, PC, telecomandi etc La comodità di poter navigare su Internet per casa o in giro senza avere un cavo dati collegato è davvero senza paragoni! Sul mercato è possibile trovare tantissimi modelli per far comunicare vari Arduino e dispositivi tra di loro. Per esempio, in questo articolo, verrà trattato il modulo wireless low-cost che funziona sulle frequenze 433 MHz. Il suo nome è MX-05V e MX-FS-03V,

25 Il kit può essere acquistato su Ebay, oppure direttamente sul sito Ecco gli schemi circuitali dei kit wireless: MX-05V schema:

26 MX-FS-03V schema: Receiver module parameters from uino/ 1. Product Model: MX-05V 2. Operating voltage: DC5V 3. Quiescent Current: 4mA 4. Receiving frequency:315mhz 5. Receiver sensitivity:-105db 6. Size: 30 * 14 * 7mm 1. Product Model: MX-FS-03V 2. Launch distance : different results) meters (different voltage,

27 3. Operating voltage :3.5-12V 4. Dimensions: 19 * 19mm 5. Operating mode: AM 6. Transfer rate: 4KB / S 7. Transmitting power: 10mW 8. Transmitting frequency: 315Mhz 9. An external antenna: 25cm ordinary multi-core or singlecore line 10. Pinout from left right: (DATA; VCC; GND) See more at: #sthash.tdeerzrm.dpuf See more at: #sthash.tdeerzrm.dpuf Facciamo qualche piccolo esempio di utilizzo di dispositivi wireless per comunicazioni con Arduino; 1 Progetto: Stazione meteo La prima idea che mi viene in mente sull utilizzo di questo modulo wireless è quello di creare una piccola stazione meteo, composta da un Arduino connesso ad Internet e un altro Arduino posto fuori casa, con collegato il sensore per rilevare la temperatura, per esempio il DHT22. Per poter trasmettere la lettura del valore della temperatura, è possibile usare il modulo wireless riportato nelle righe precedente.

28 Introduzione del progetto in formato PDF 2 Progetto: Relè comandati a distanza Un altro interessante utilizzo, può essere quello di azionare delle prese elettriche comandate da un relè, a distanza, attraverso il modulo wireless. Per esempio potremmo avere un unica base, con Arduino, modulo TX e webserver, che comanda vari RX.

29 3 Progetto: Sistema di sicurezza con sensori PIR Un altro esempio di utilizzo dei moduli di comunicazioni è quello di creare un sistema di allarme con i sensori PIR sparsi per la casa, e collegati ad un unità centrale, che rileva tutti i movimenti e li registra in qualche modo.

30 4 Progetto: Apertura del garage di casa Un ultimo interessante progetto, può essere aprire il garage di casa, sfruttando Arduino, Internet e i moduli wireless, che funzionano sulle frequenze 443 MHz.

31 Questi progetti, verranno trattati nei prossimi capitoli, quando verranno introdotti altri dispositivi importantissimi con Arduino, come ad esempio la Shield Ethernet, che permette di collegare il micro controllore alla rete. 1 Programma: Hello wireless In questo programma, verrà mostrato come poter inviare una stringa tra il TX e RX e mostrata sul seriale di quest ultimo. Per poter far mandare in esecuzione il programma, occorre disporre di 2 Arduino. I collegamenti sono riportati in queste due immagini:

32 Tx MODULE CONNECTIONS: PIN 1 DESCRIPTION GND ARDUINO PIN GND 2 3 VCC (3.5-12V) TX DATA VCC D2 Rx MODULE CONNECTIONS: PIN DESCRIPTION ARDUINO PIN GND RX DATA RX DATA VCC (5V) GND D2 N/A VCC Codice per TX /** Questo programma va caricato sul TX e permette di inviare una stringa ad un altro Arduino */

33 #include <VirtualWire.h> void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); vw_set_tx_pin(2); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec void loop() { const char *msg = "hello"; digitalwrite(13, true); // Flash a light to show transmitting vw_send((uint8_t *)msg, strlen(msg)); vw_wait_tx(); // Wait until the whole message is gone digitalwrite(13, false); delay(200); Mentre sul RX: /** Questo programma va caricato sul RX e permette di ricevere una stringa che è stata inviata da un altro Arduino */ #include <VirtualWire.h> void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); vw_set_rx_pin(2); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running

34 void loop() { uint8_t buf[vw_max_message_len]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) // Non-blocking { int i; digitalwrite(13, true); // Flash a light to show received good message // Message with a good checksum received, dump it. Serial.print("Got: "); for (i = 0; i < buflen; i++) { Serial.print(buf[i], HEX); Serial.print(" "); Serial.println(""); digitalwrite(13, false); 2 Programma: Inviare un valore di un segnale analogico In questo secondo programma, vedremo come inviare il valore di un segnale analogico (A0), tra i due dispositivi. Anche in questo caso, vanno caricati due differenti programmi, uno sul TX e uno sul RX. Codice TX /* FILE: MXFS03V_433MHZ_MODULE_HCMODU0007_TRANSMIT_EXAMPLE.pde DATE: 03/03/13 VERSION: 0.1 AUTHOR: Andrew Davies

35 This is an example of how to use the 433MHz wireless transmitter module (HCMODU0007) which is the Tx part of the tranmitter and receiver module pair. This example makes use of the VirtualWire library written by Mike McCauley. The sketch will read a value from the analogue input A0 and transmit it as 2 bytes to the receiver module once every second. Tx MODULE CONNECTIONS: PIN DESCRIPTION GND VCC (3.5-12V) TX DATA ARDUINO PIN GND VCC D2 You may copy, alter and reuse this code in any way you like, but please leave reference to HobbyComponents.com in your comments if you redistribute this code. THIS SOFTWARE IS PROVIDED "AS IS". HOBBY COMPONENTS LTD MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ACCURACY OR LACK OF NEGLIGENCE. HOBBY COMPONENTS SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON WHATSOEVER. */ /*Include the VirtualWire library */ #include <VirtualWire.h> /* Digital IO pin that will be used for sending data to the transmitter */ const int TX_DIO_Pin = 2;

36 void setup() { pinmode(13, OUTPUT); /* Initialises the DIO pin used to send data to the Tx module */ vw_set_tx_pin(tx_dio_pin); /* Set the transmit logic level (LOW = transmit for this version of module)*/ vw_set_ptt_inverted(true); /* Transmit at 2000 bits per second */ vw_setup(2000); // Bits per sec /* Main program */ void loop() { /* Temporarily holds the value read from analogue input A0 */ unsigned int Data; /* The transmit buffer that will hold the data to be transmitted. */ byte TxBuffer[2]; /* Read the analogue input A0... */ Data = analogread(a0); /*...and store it as high and low bytes in the transmit buffer */ TxBuffer[0] = Data >> 8; TxBuffer[1] = Data; /* Turn on the LED on pin 13 to indicate that we are about to transmit data */ digitalwrite(13, HIGH); /* Send the data (2 bytes) */ vw_send((byte *)TxBuffer, 2); /* Wait until the data has been sent */ vw_wait_tx(); /* Turn off the LED on pin 13 to indicate that we have now sent the data */

37 digitalwrite(13, LOW); /* Do nothing for a second. Lower this delay to send data quicker */ delay(1000); Codice RX /** Questo programma va caricato sul RX e permette di ricevere una stringa che è stata inviata da un altro Arduino */ #include <virtualwire.h> void setup() { Serial.begin(9600); // Debugging only Serial.println("setup"); vw_set_rx_pin(2); // Initialise the IO and ISR vw_set_ptt_inverted(true); // Required for DR3100 vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver PLL running void loop() { uint8_t buf[vw_max_message_len]; uint8_t buflen = VW_MAX_MESSAGE_LEN; if (vw_get_message(buf, &buflen)) // Non-blocking { int i; digitalwrite(13, true); // Flash a light to show received good message // Message with a good checksum received, dump it. Serial.print("Got: "); for (i = 0; i < buflen; i++)

38 { Serial.print(buf[i], HEX); Serial.print(" "); Serial.println(""); digitalwrite(13, false); 3 Programma: Inviamo la lettura delle temperatura esterna In questo terzo programma, vedremo come poter poter inviare il valore delle temperatura e dell umidità che c è fuori casa, sfruttando il DHT22 (vedi lezione a riguardo) e il modulo wireless che stiamo discutendo. TX codice: /** Questo programma permette di inviare diversi valori in maniera wireless tra due Arduino. In questo caso verrà inviato il valore delle temperatura e dell'umidità, sfruttando il trasduttore DHT22 */ #include <VirtualWire.h> #include "DHT.h" #define DHTPIN 2 // Il pin a cui è collegato il sensore #define DHTTYPE DHT22 // DHT 22 (AM2302) int ledpin = 13; char Sensor1CharMsg[21];// The string that we are going to send trought rf DHT dht(dhtpin, DHTTYPE); void setup() { // LED pinmode(ledpin,output); dht.begin(); // VirtualWire setup vw_setup(2000); // Bits per sec vw_set_tx_pin(12);// Set the Tx pin. Default is 12

39 void loop() { float h = dht.readhumidity(); float t = dht.readtemperature(); sprintf(sensor1charmsg, "%f,%f,", t, h); // Turn on a light to show transmitting vw_send((uint8_t *)Sensor1CharMsg, strlen(sensor1charmsg)); vw_wait_tx(); // Wait until the whole message is gone // Turn off a light after transmission delay(40); RX codice /** Questo programma, caricato sul RX, permette di ricevere il valore della temperatura e dell'umidità che vengono inviate da un Arduino, attraverso il modulo wireless, sfruttando il DHT22, come trasduttore */ #include <VirtualWire.h> char StringReceived[22]; void setup() { // VirtualWire // Initialise the IO and ISR // Required for DR3100 // Bits per sec vw_setup(2000); vw_set_rx_pin(11); // Start the receiver PLL running vw_rx_start(); // END void setup void loop(){

40 float t; float h; uint8_t buf[vw_max_message_len]; uint8_t buflen = VW_MAX_MESSAGE_LEN; //Taking the data from the control base if (vw_get_message(buf, &buflen)) { int i; // Message with a good checksum received, dump it. for (i = 0; i < buflen; i++) { // Fill Sensor1CharMsg Char array with corresponding // chars from buffer. StringReceived[i] = char(buf[i]); sscanf(stringreceived, "%f,%f",&t, &h); // Converts a string to an array // Turn off light to and await next message memset( StringReceived, 0, sizeof( StringReceived));// This line is for reset the StringReceived Lezione 11: Come utilizzare il RFID reader per carte magnetiche [Aggiornato con la nuova libreria, per risolvere i problemi di compilazione]

41 In questa puntata vedremo come un utilizzare un componente abbastanza interessante, che verrà ripreso successivamente, quando verranno introdotte le varie Shield per Arduino per connetterlo ad Internet. Questo dispositivo si chiama RFID reader è permette di poter leggere facilmente le varie tessere magnetiche con Arduino. Requisiti per il progetto

42 Arduino Uno RFID Reader con tessere magnetiche LED e cavi flessibili Per quanto riguardo il RFID reader sono disponibili diversi modelli; tuttavia, per il nostro programma, conviene utilizzare il modulo mifare RC522, disponibile su Ebay per qualche Euro. Per avere maggiori dettagli tecnici, riguardo al funzionamento del RFID reader, potete dare un occhiata al datasheet:

43 Arduino RFID collegamenti reader e i suoi Il collegamento da effettuare dal dispositivo di letture delle tessere ed Arduino è abbastanza semplice, basta collegare i PIN come riportato nella seguente tabella: RC522 MODULE SDA SCK MOSI MISO IRQ GND RST 3.3V Uno/Nano D10 D13 D11 D12 N/A GND D9 3.3V Il tipo di collegamento offerto dal modulo, purtroppo non è dei migliori; infatti capita spesso che i contatti tra i fili e il dispositivo non siano stabili e l alimentazione viene meglio. Per questo motivo, è necessario cercare di fissare bene i collegamenti, in modo da non avere discontinuità nel funzionamento. Per il corretto funzionamento del RFID reader con i prossimi codici, è necessario scaricare la libreria ufficiale del dispositivo:

44 1 Programma: Mostriamo nel seriale la tessere letta Con questo programma, sarà possibile leggere il codice delle tessera magnetica, che viene passato sopra il dispositivo. /* FILE: RC522_RFID_Module_Example DATE: 24/07/13 VERSION: 0.1 REVISIONS: 24/07/13 Created version 0.1 This is an example of how to use the RC522 RFID module. The module allows reading and writing to various types of RFID devices and can be found in our MFRC-522 (HCMODU0016) and Ultimate RFID (HCARDU0068) kits. This example Arduino sketch uses the RFID library written by Miguel Balboa to read the preprogrammed serial number from RFID cards and tags supplied with our RFID kits. Snapshots and links to the library are available on our support forum. PINOUT: RC522 MODULE Uno/Nano SDA D10 SCK D13 MOSI D11 MISO D12

45 IRQ N/A GND GND RST D9 3.3V 3.3V You may copy, alter and reuse this code in any way you like, but please leave reference to HobbyComponents.com in your comments if you redistribute this code. This software may not be used directly for the purpose of selling products that directly compete with Hobby Components Ltd's own range of products. THIS SOFTWARE IS PROVIDED "AS IS". HOBBY COMPONENTS MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ACCURACY OR LACK OF NEGLIGENCE. HOBBY COMPONENTS SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON WHATSOEVER. */ #include <SPI.h> #include <RFID.h> /* Vengono definiti PIN del RFID reader*/ #define SDA_DIO 10 // 53 per Mega #define RESET_DIO 9 #define delayread 1000 // Time of delay /* Viene creata una istanza della RFID libreria */ RFID RC522(SDA_DIO, RESET_DIO); void setup() { Serial.begin(9600); /* Abilita SPI*/

46 SPI.begin(); /* Viene inizilizzato RFID reader */ RC522.init(); Serial.println("Setup"); void loop() { /* Temporary loop counter */ byte i; // Se viene letta una tessera if (RC522.isCard()) { // Viene letto il suo codice RC522.readCardSerial(); String codiceletto =""; Serial.println("Codice delle tessera letto:"); // Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) { codiceletto+= String (RC522.serNum[i],HEX); codiceletto.touppercase(); Serial.println(codiceLetto); delay(delayread); Serial.println(); Serial.println(); Il codice riportato precedentemente è abbastanza semplice da capire, sopratutto con i commenti presenti. Nel loop(), viene effettuato un controllo, sulla presenza di una tessera magnetica sopra il dispositivo; se il risultato è true, viene caricato in una stringa, il codice delle tessera magnetica e mostrato successivamente nel seriale. Ed ecco il risultato:

47 2 Programma: Verifichiamo l identità di una tessera In questo programma, vedremo come poter stabilire se una tessera è abilitata a compiere una certe azione, ad esempio accendere una luce, oppure aprire una porta (nei prossimi capitoli vedremo esempi pratici). /* Questo programma permette effettuare la lettura di una tessera magnetica e stabilire se quest'ultima è stata autorizzata. PINOUT: RC522 MODULE Uno/Nano SDA D10 SCK D13 MOSI D11 MISO D12 IRQ N/A GND GND RST D9 3.3V 3.3V Autore Giacomo Bellazzi Versione 1.0 */

48 #include <SPI.h> #include <RFID.h> /* Vengono definiti PIN del RFID reader*/ #define SDA_DIO 10 // 53 per Mega #define RESET_DIO 9 #define delayread 1000 // Time of delay #define delayled 2000 #define ledverde 3 #define ledrosso 4 /* Viene creata una istanza della RFID libreria */ RFID RC522(SDA_DIO, RESET_DIO); String codiceautorizzato = "EC40E03478"; void setup() { Serial.begin(9600); /* Abilita SPI*/ SPI.begin(); /* Viene inizilizzato RFID reader */ RC522.init(); Serial.println("Setup"); pinmode(ledverde,output); pinmode(ledrosso,output); void loop() { /* Temporary loop counter */ byte i; // Se viene letta una tessera if (RC522.isCard()) { // Viene letto il suo codice RC522.readCardSerial(); String codiceletto =""; Serial.println("Codice delle tessera letto:"); // Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++)

49 { codiceletto+= String (RC522.serNum[i],HEX); codiceletto.touppercase(); Serial.println(codiceLetto); if(verificacodice(codiceletto)){ Serial.println("Tessera autorizzata"); accendiled(ledverde); else{ Serial.println("Tessera non autorizzata"); accendiled(ledrosso); delay(delayread); // Questa funzione verifica se il codice Letto è autorizzato boolean verificacodice(string codiceletto){ if(codiceletto.equals(codiceautorizzato)){ return true; else{ return false; // Questa funzione permette di accendere un LED per un determinato periodo void accendiled(int ledpin){ digitalwrite(ledpin,high); delay(delayled); digitalwrite(ledpin,low); Il metodo verificacodice, non fa altre che prendere il codice delle tessera che viene letta e confrontato con quello salvato in memoria. Se la tessera è autorizzata, viene accesso un LED verde, mentre se la tessera non è autorizzata, viene accesso il LED rosso. Ecco un video che mostra l esecuzione del programma su Arduino Uno:

50 3 Programma: Versione 2.0 lettore di autorizzazioni del Come avete potuto notare precedentemente, il codice è stato realizzato per la lettura di una sola tessera autorizzata; ma come possiamo fare per avere un numero maggiore di tessere abilitate? In questo versione 2.0, verrà fatta una prima soluzione; in pratica i codici letti verranno trasformati in interi e sommati. La somma del codice, dovrebbe rappresentare il codice vero e proprio, ma potrebbe capitare che ci sono posso essere due tessere diverse, con la stessa somma di cifre. Comunque i codici autorizzati sono inseriti in un array di interi. Vediamo il codice: /* Questo programma permette effettuare la lettura di una tessera magnetica e stabilire se quest'ultima è stata autorizzata. PINOUT: RC522 MODULE SDA SCK Uno/Nano D10 D13

51 MOSI D11 MISO D12 IRQ N/A GND GND RST D9 3.3V 3.3V Autore Giacomo Bellazzi Versione 2.0 Novità: *Possibilità di inserire più di una tessera autorizzata */ #include <SPI.h> #include <RFID.h> /* Vengono definiti PIN del RFID reader*/ #define SDA_DIO 10 // 53 per Mega #define RESET_DIO 9 #define delayread 1000 // Time of delay #define delayled 2000 #define ledverde 3 #define ledrosso 4 /* Viene creata una istanza della RFID libreria */ RFID RC522(SDA_DIO, RESET_DIO); long uno = 696; // rappresenta la somma delle 4 cifre int due = 450; int codiciautorizzati[] ={uno,due; // contiene i codici autorizzati void setup() { Serial.begin(9600); /* Abilita SPI*/ SPI.begin(); /* Viene inizilizzato RFID reader */ RC522.init(); Serial.println("Setup"); pinmode(ledverde,output); pinmode(ledrosso,output); void loop()

52 { /* Temporary loop counter */ byte i; // Se viene letta una tessera if (RC522.isCard()) { // Viene letto il suo codice RC522.readCardSerial(); int codiceletto = 0; Serial.println("Codice delle tessera letto:"); // Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) { codiceletto+=rc522.sernum[i]; Serial.println(codiceLetto); if(verificacodice(codiceletto)){ Serial.println("Tessera autorizzata"); accendiled(ledverde); else{ Serial.println("Tessera non autorizzata"); accendiled(ledrosso); delay(delayread); // Questa funzione verifica se il codice Letto è autorizzato boolean verificacodice(int codiceletto){ boolean autorizzato = false; for(int i = 0; i < sizeof(codiciautorizzati) ; i++){ if(codiceletto==codiciautorizzati[i]){ autorizzato = true; return autorizzato; // Questa funzione permette di accendere un LED per un determinato periodo void accendiled(int ledpin){

53 digitalwrite(ledpin,high); delay(delayled); digitalwrite(ledpin,low); 4 Programma: utilizzare più codici autorizzati nello stesso programma In questo quarto e ultimo programma vedremo come inserire diversi codice pre-autorizzati all interno del nostro programma, per verificare a run-time se il codice letto è effettivamente autorizzato: /* Questo programma permette effettuare la lettura di una tessera magnetica e stabilire se quest'ultima è stata autorizzata. PINOUT: RC522 MODULE Uno/Nano SDA D10 SCK D13 MOSI D11 MISO D12 IRQ N/A GND GND RST D9 3.3V 3.3V Autore Giacomo Bellazzi Versione 1.0 */ #include <SPI.h> #include <RFID.h> /* Vengono definiti PIN del RFID reader*/ #define SDA_DIO 10 // 53 per Mega #define RESET_DIO 9 #define delayread 1000 // Time of delay #define delayled 2000 #define ledverde 3

54 #define ledrosso 4 /* Viene creata una istanza della RFID libreria */ RFID RC522(SDA_DIO, RESET_DIO); String codiceautorizzato1 = "EC40E03478"; String codiceautorizzato2 = "EC40E03479"; String codiceautorizzato3 = "EC40E03480"; void setup() { Serial.begin(9600); /* Abilita SPI*/ SPI.begin(); /* Viene inizilizzato RFID reader */ RC522.init(); Serial.println("Setup"); pinmode(ledverde,output); pinmode(ledrosso,output); void loop() { /* Temporary loop counter */ byte i; // Se viene letta una tessera if (RC522.isCard()) { // Viene letto il suo codice RC522.readCardSerial(); String codiceletto =""; Serial.println("Codice delle tessera letto:"); // Viene caricato il codice della tessera, all'interno di una Stringa for(i = 0; i <= 4; i++) { codiceletto+= String (RC522.serNum[i],HEX); codiceletto.touppercase(); Serial.println(codiceLetto); if(verificacodice(codiceletto,codiceautorizzato1) verificacod

55 ice(codiceletto,codiceautorizzato2) verificacodice(codiceletto,codiceautorizzato3)){ Serial.println("Tessera autorizzata"); accendiled(ledverde); else{ Serial.println("Tessera non autorizzata"); accendiled(ledrosso); delay(delayread); // Questa funzione verifica se il codice Letto è autorizzato boolean verificacodice(string codiceletto, String codiceautorizzato){ if(codiceletto.equals(codiceautorizzato)){ return true; else{ return false; // Questa funzione permette di accendere un LED per un determinato periodo void accendiled(int ledpin){ digitalwrite(ledpin,high); delay(delayled); digitalwrite(ledpin,low); La chiave del programma è quella di utilizzare una funzione che verifica se due strings sono uguali, cioè se due codici delle tessere magnetiche sono uguali e l operatore logico or. Per entrare nell if, basterà che almeno uno dei tre codici sia uguale. I codici riportati in questo capitolo, sono elementi basi per costruire progetti più interessanti, come sistemi di antifurto, controllo di accessi e uscite in un luogo etc.. Vedremo come questi progetti nei prossimi capitoli. I codici dei programmi presenti in questo capitolo, sono scaricabili dalla repo di Github:

56 Come comandare il condizionatore di casa con Arduino, anche da remoto! Arduino permette davvero di fare tantissime cose riguardo all Internet of things, basta avere un po di voglia e intuizione, per realizzare qualsiasi tipo di progetto. In questo post vedremo come comandare da remoto il proprio condizionatore di casa, attraverso Arduino, che è connesso ad Internet. Si avete proprio letto bene!

57 Requisiti hardware 1 x Arduino Uno + 1 x Arduino Mega oppure 2 x Arduino Uno Ricevitore ad infrarossi TSOP1738 IR Led 1 x Resistenza da 330 Ohm Qualche cavo flessibile Requisiti software Libreria IRemote Arduino Programmi disponibili nella mia repo di Github Come funziona il sistema? Come molti sapranno, il meccanismo di regolazione delle varie impostazioni tra utente e condizionatore, avviene attraverso un telecomando, che è basato sull invio di segnali ad infrarosso. Per approfondire il funzionamento di questi segnali, vi consiglio di guardare il post in riferimento al Capitolo 10 di Arduino progettare diventa semplice. Ovviamente, i codici di un condizionatore, variano in base al

58 modello e in base al costruttore. Per questo motivo, come prima fase dal lavoro, è necessario fare il procedimento che prende il nome di reverse engineering, ovvero di ottenere i codici per il proprio dispositivo, sfruttando il trasduttore TSOP1738. Una volta che sono stati ottenuti i codici per il proprio condizionatore, ci siamo quasi a completare l opera. Occorre utilizzare un piccolo programma che semplifichi l impostazione del codice da inserire in Arduino e sarà possibile inviare le varie codifiche. Queste codifiche potranno essere impostate dall utente, attraverso una semplice pagina web, con o senza protezione. Come avete potuto leggere nella sezione requisiti hardware, ho scritto che sono necessari due Arduino; il motivo principale è quello che le sequenze di bit da inviare al condizionatori occupano troppo spazio per poter essere contenute in un solo dispositivo, che tra l altro dovrà occuparsi anche della parte di gestione dei comandi che verranno trasmessi via Internet. In pratica ci sarà un dispositivo che si preoccuperà della parte webserver e l altro di inviare i segnali IR. L altro motivo che mi ha spinto a realizzare questo progetto con due dispositivo, è che si può utilizzare tranquillamente Raspberry PI per la gestione del webserver, in modo da migliorare sicuramente l aspetto grafico della pagina web. Come impostare i vari dati Come specificato nelle righe precedenti, è necessario ottenere le codifiche del nostro telecomando, per poterle ritrasmettere da Arduino. Per farlo faremo uso della libreria IRemote per Arduino, in particolare di questo codice:

59

60 /** Modified by Chris Targett* Now includes more protocols* Novemeber * IRremote: IRrecvDump dump details of IR codes with IRrecv * An IR detector/demodulator must be connected to the input RECV_PIN. * Version 0.1 July, 2009 * Copyright 2009 Ken Shirriff * * * Modified by Chris Targett to speed up the process of collecting * IR (HEX and DEC) codes from a remote (to put into and.h file) * */ #include <IRremote.h> int RECV_PIN = 11; IRrecv irrecv(recv_pin); decode_results results; void setup() { Serial.begin(9600); irrecv.enableirin(); // Start the receiver // Dumps out the decode_results structure. // Call this after IRrecv::decode() // void * to work around compiler issue //void dump(void *v) { // decode_results *results = (decode_results *)v void dump(decode_results *results) { int count = results->rawlen; if (results->decode_type == UNKNOWN) { Serial.print( Unknown encoding: ); else if (results->decode_type == NEC) { Serial.print( Decoded NEC: ); else if (results->decode_type == SONY) { Serial.print( Decoded SONY: ); else if (results->decode_type == RC5) { Serial.print( Decoded RC5: ); else if (results->decode_type == RC6) { Serial.print( Decoded RC6: ); else if (results->decode_type == SAMSUNG) { Serial.print( Decoded SAMSUNG: ); else if (results->decode_type == JVC) { Serial.print( Decoded JVC: ); else if (results->decode_type == PANASONIC) { Serial.print( Decoded Panasonic: ); Serial.print(results->value, HEX); Serial.print( ( ); Serial.print(results->bits, DEC); Serial.println( bits) ); Serial.print( #define Something_DEC ); Serial.println(results->value, DEC); Serial.print( #define Something_HEX ); Serial.println(results->value, HEX); Serial.print( Raw ( ); Serial.print(count, DEC); Serial.print( ): ); for (int i = 0; i < count; i++) { if ((i % 2) == 1) { Serial.print(results->rawbuf[i]*USECPERTICK, DEC); else { Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC); Serial.print( ); Serial.println( ); void loop() { if (irrecv.decode(&results)) { dump(&results); irrecv.resume(); // Receive the next value

61 Il collegamento è riportato nell immagine qui sottostante: Dopo aver caricato il codice su Arduino, dovremmo premere i vari pulsanti presenti sul telecomando e copiare da qualche parte i risultati mostrati dal seriale. Nel mio caso, ho ottenuto la seguente sequenza di codifiche: Accensione 20 C Caldo Raw (150):

62 Spegnimento Raw (150): Accensione 23 C Freddo 2 FAN Raw (150): Accensione 20 C Caldo e Swing Raw (150):

63 Accensione 23 C Freddo 2 FAN e Swing Raw (150): Come riportato nella libreria IRemote, per poter ritrasmettere questi dati, occorre effettuare alcune modifiche; in particolare occorre sostituire i segni meno, eliminare il primo valore e porre, tra i vari valori, una virgola, dal momento che nel codice di Arduino, verranno inseriti in un vettore di interi.

64 Per facilitare questa operazione, ho realizzato un piccolo programma in Java, in grado di fare queste operazioni in automatico: Anche questo programma, è disponibile nella repo di Github e si chiama AcToolArduino. In questa prima versione, il programma automatizza la procedura, inserendo i dati nella TextField. Nella prossima versione, sarà possibile caricare da file, i risultati ottenuti dal seriale di Arduino. Attraverso il prossimo programma, potremo verificare il corretto funzionamento dell invio di segnali IR da Arduino: #include "IRremote.h" IRsend irsend; void setup() { Serial.begin(9600);

65 int khz=38; //NB Change this default value as neccessary to the correct modulation frequency // ON and 2O C with 1 FAN heat unsigned heat[] = {3000,3000,3000,4400,550,1600,600,550,550,1650,550,550,550,550,550,1650,550,550,550,1650,500,550,550,1650,550,550,550,500,60 0,500,600,550,550,550,550,1650,500,550,550,600,500,1700,500,55 0,550,550,550,550,550,600,500,550,550,550,550,550,550,550,550, 1650,550,1650,550,1650,500,1650,550,1650,550,550,550,550,550,5 50,550,550,550,1650,550,1650,550,500,550,550,550,1700,500,1650,550,550,550,500,600,550,550,550,550,550,550,550,550,550,550,1 650,500,1700,500,550,550,550,550,550,550,550,550,550,550,600,5 00,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,1650,550,500,550,1700,500,550,550,550,550,550,550,1650,55 0; // OFF the A/C unsigned OFF[] = {3100,2900,2950,4400,700,1500,700,400,700,1500,700,400,650,450,550,1650,550,550,650,1500,600,500,600,1600,600,500,600,500,60 0,450,650,450,600,550,550,550,550,550,550,600,500,1600,600,500,600,500,600,550,550,500,600,500,600,550,550,550,550,1600,600, 500,600,500,600,500,550,1650,550,1600,600,500,600,500,600,550, 550,550,550,1600,600,1600,550,550,550,550,550,1650,550,1600,60 0,550,550,500,600,500,600,550,550,550,550,500,600,500,600,1600,600,1600,550,550,550,550,550,550,550,550,550,550,550,550,550, 550,550,550,550,500,600,550,550,550,550,500,600,500,600,500,60 0,1600,600,500,600,1600,550,550,550,1600,600,550,550,550,550; // ON and 23 with 2 FAN cold unsigned cold[] = {3050,3000,3000,4400,550,1600,600,550,550,1650,550,550,550,550,550,1650,550,500,600,1600,550,550,550,1650,550,1650,550,1650, 550,550,550,550,550,500,600,1600,550,550,550,550,550,1650,550, 550,550,550,550,550,550,550,550,550,550,550,550,500,600,1650,5

66 00,550,550,600,500,1700,500,550,550,550,550,550,550,550,550,55 0,550,550,550,1650,550,1650,550,550,550,500,550,1650,550,550,5 50,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,1650,550,550,550,550,550,550,550,550,550,500,550,550,550, 550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,55 0,550,550,550,550,550,550,550,550,1650,550,1600,600,550,550; // ON and 20 C with 1 FAN heat and SWING unsigned heat_with_swing[] = {3000,3000,3000,4400,550,1650,550,500,600,1600,600,500,600,500,600,1600,550,550,550,1650,550,500,600,1600,600,550,550,550,55 0,550,550,1600,600,500,600,500,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,1650,550, 550,550,1600,550,550,550,600,500,550,550,550,550,550,550,550,5 50,550,550,1650,550,1650,550,550,550,550,550,1600,550,1650,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,1650, 550,1650,550,550,550,550,550,550,550,550,500,550,550,550,550,5 50,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,1650,550,1650,550,1650,500,1650,550,550,550,1700,500 ; // ON and 23 with 2 FAN cold and SWING unsigned cold_with_sqwing[] = {2950,3050,2950,4400,550,1600,600,550,550,1650,550,550,550,550,550,1600,600,500,600,1600,550,500,600,1650,550,1650,550,1600, 600,500,600,1600,600,500,600,500,550,550,550,550,550,550,550,5 50,550,550,550,550,550,550,550,500,600,550,550,500,600,1650,55 0,550,550,1600,600,500,600,1600,550,1600,600,500,600,500,600,5 50,550,500,600,1650,550,1600,600,500,600,500,550,1650,550,550, 550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,55 0,550,1650,550,500,600,500,600,500,600,500,600,500,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,1650, 550,1650,550,1600,600,1600,550,550,600,500,550,550,550,550,550 ; void loop() { irsend.sendraw(heat, sizeof(heat)/sizeof(int), khz);

67 delay(10000); irsend.sendraw(off, sizeof(off)/sizeof(int),khz); delay(10000); Se siamo usciti ad azionare il condizionatore di casa, siamo a buon punto per poter completare il progetto! Come indicato precedentemente, è necessario utilizzare due Arduino, uno che gestisce la parte webserver, l altro che gestisce la comunicazione con il condizionatore. Per collegare i due Arduino in maniera corretta, occorre prestare attenzione all immagine successiva. Sul dispositivo collegato con la Shield Ethernet è necessario caricare il programma che prende il nome di AC_Webpage_Controller.ino, mentre nell Arduino che invierà i comandi IR, occorre caricare il programma che prende il nome di AC_Sender_Code.ino. Ora che abbiamo completato la procedura di caricamento, non ci resta che fare alcune operazioni per perfezionare il progetto; quella più utile, è quella di rendere accessibile il webserver

68 anche da remoto. Per farlo dovremmo aprire le porte del nostro router, per instradare correttamente le richieste che vengono fatte al di fuori della nostra rete locale. Occorre precisare, che nella versione del codice riportata su Github, non è presente una protezione a livello di password, per semplificare un po il progetto. Tuttavia, con alcune modifiche al codice AC_Webpage_Controller.ino, sarà possibile implementare anche questa caratteristica. L operazione di inoltro delle porte, varia da router a router; tuttavia, in generale, si può procedere così: Individuare l IP del webserver di Arduino Individuare l IP del gateway Aprire il browser e digitare l IP del nostro router e inserire le credenziali Aprire la sezione di inoltro delle porte e inserire come dati, l IP di Arduino e come porta la 80. Ora potremmo accedere anche al di fuori della nostra rete locale, semplicemente aprendo una pagina web, con l IP pubblico della propria connessione ADSL (per recuperare questo valore, basterà semplicemente digitare su Google.com my ip ). Ora potremmo finalmente testare il nostro progetto!

69

70 Spero che questo progetto, sia utile per capire come è possibile realizzare qualcosa di davvero carino con Arduino, con un po di pazienza e soprattutto con un po di teoria! Ecco il video del risultato finale:

71 Lezione 10: scopriamo infrarossi con Arduino gli In questa lezione, vedremo come vengono usati in Arduino i segnali infrarossi. Chi di noi non ha un telecomando in casa, come ad esempio quello per accendere e spegnere la TV? Bene oggi capiremo come il nostro TV è in grado di stabilire il tasto premuto dal nostro telecomando. I supporti hardare richiesti per questi programmi sono davvero pochi. Infatti oltre allo stesso Arduino, dovremo procurarci su Ebay un ricevente IR, con il relativo telecomando e un LED ad infrarossi, in grado di inviare i segnali. Ecco una lista di possibili prodotti, acquistabili su ebay:

72 Il costo di questi dispositivi è davvero poco e si aggira intorno ai 5 Euro. Dal punto di vista software è necessario scaricare la libreria ufficiale per Arduino, da questo link:

73 Come funziona una trasmissione ad infrarossi? Il meccanismo di funzionamento di una trasmissione ad infrarossi è abbastanza semplice ; un fascio luminoso, ad elevata frequenza 38 KHz (per i telecomandi tipici per la TV) viene proiettato contro un ricevente. Questo fascio luminoso non è altro che una sequenza di bit (0 e 1) che vengono codificati dal ricevente, attraverso la polarizzazione di photo-transistor. Facciamo questo semplice caso; nel nostro telecomando, vengono codificati i vari pulsati con varie sequenze bit e per esempio il tasto on/off vale: Il ricevente avrà un segnale in ricezione molto simile, se non uguale a quello inviato e in base alla corrispondenza che ha

74 il memoria, sarà in grado di come ad esempio accendere la inviato dal telecomando, non nudo perché ha una frequenza svolgere la richiesta effettiva, TV! Il fascio luminoso che viene è possibile vederlo ad occhio troppo veloce per noi! Tuttavia, ci sono diversi codifiche; tipicamente ogni produttore di dispositivi tecnologici, ha una propria codifica, come ad esempio Sony, NEC, Samsung etc.. Tuttavia, è possibile stabilire la sequenza di bit di qualsiasi segnale ad infrarosso, calcolando il tempo in cui il segnale è alto e il tempo in cui il segnale è basso. Questo tipo di codifica si chiama RAW. Passiamo ai codici per Arduino Come per ogni libreria nuova in Arduino, dobbiamo installarla, copiandola semplicemente nella cartella Libraries, che tipicamente si trova nei propri documenti. Qualora utilizzassimo il dispositivo TSOP1738, il collegamento è davvero semplice; basterà alimentare il segnale con i 5 V di Arduino, collegarlo a massa e collegare il pin di output al pin 11.

75 TSOP1738 Datasheet Per quanto riguardo altri dispositivi presenti su Ebay, basterà collegare il pin di output sempre al pin 11 di Arduino. 1 Programma decodifichiamo un generico segnale Nome programma Decode_generic_IR /* * Modified by Chris Targett * Now includes more protocols * Novemeber 2011 * IRremote: IRrecvDump - dump details of IR codes with IRrecv * An IR detector/demodulator must be connected to the input RECV_PIN. * Version 0.1 July, 2009 * Copyright 2009 Ken Shirriff * * * Modified by Chris Targett to speed up the process of collecting * IR (HEX and DEC) codes from a remote (to put into and.h

76 file) * */ #include <IRremote.h> int RECV_PIN = 11; IRrecv irrecv(recv_pin); decode_results results; void setup() { Serial.begin(9600); irrecv.enableirin(); // Start the receiver // Dumps out the decode_results structure. // Call this after IRrecv::decode() // void * to work around compiler issue //void dump(void *v) { // decode_results *results = (decode_results *)v void dump(decode_results *results) { int count = results->rawlen; if (results->decode_type == UNKNOWN) { Serial.print("Unknown encoding: "); else if (results->decode_type == NEC) { Serial.print("Decoded NEC: "); else if (results->decode_type == SONY) { Serial.print("Decoded SONY: "); else if (results->decode_type == RC5) { Serial.print("Decoded RC5: "); else if (results->decode_type == RC6) { Serial.print("Decoded RC6: "); else if (results->decode_type == SAMSUNG) {

77 Serial.print("Decoded SAMSUNG: "); else if (results->decode_type == JVC) { Serial.print("Decoded JVC: "); else if (results->decode_type == PANASONIC) { Serial.print("Decoded Panasonic: "); Serial.print(results->value, HEX); Serial.print("("); Serial.print(results->bits, DEC); Serial.println(" bits)"); Serial.print("#define Something_DEC "); Serial.println(results->value, DEC); Serial.print("#define Something_HEX "); Serial.println(results->value, HEX); Serial.print("Raw ("); Serial.print(count, DEC); Serial.print("): "); for (int i = 0; i < count; i++) { if ((i % 2) == 1) { Serial.print(results->rawbuf[i]*USECPERTICK, DEC); else { Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC); Serial.print(" "); Serial.println(""); void loop() { if (irrecv.decode(&results)) { dump(&results); irrecv.resume(); // Receive the next value Il programma qui presente mostra sul seriale la codifica del segnale ad infrarosso che viene ricevuto dal ricevitore,

78 collegato al pin 11 di Arduino. Il meccanismo è davvero abbastanza chiara, grazie ai commenti presenti nel codice, tratto dalla libreria ufficiale. 2 Programma per Arduino: Accendiamo una lampada con qualsiasi segnale ad Infrarosso /** Questo programme permette di accendere una lampada, attraverso un relay, con un telecomando ad infrarossi. Questa versione non permette di modificare il codice a run time Autore Giacomo Bellazzi */ #include <IRremote.h> int RECV_PIN = 11; int RELAY_PIN = 13; int codice = ; // codice dec del telecomando IRrecv irrecv(recv_pin); decode_results results; void setup() { pinmode(relay_pin, OUTPUT); Serial.begin(9600); irrecv.enableirin(); // Start the receiver int on = 0; unsigned long last = millis(); void loop() { if (irrecv.decode(&results)){ // If it's been at least 1/4 second since the last // IR received, toggle the relay

79 if (millis() - last > 250 && results.value==codice ) { on =!on; digitalwrite(relay_pin, on? HIGH : LOW); //dump(&results); last = millis(); irrecv.resume(); // Receive the next value Questo codice permette di accendere una lampada connessa ad un relè, premendo un telecomando ad infrarossi. La codifica del telecomando che si vuole usare, può essere ottenuta con il codice del primo programma e inserita all inizio di questo codice. Tuttavia, il codice non è modificabile a run time. 3 Programma: telecomando Accendiamo una lampada con un qualsiasi /* Questo progetto permette di utilizzare Arduno e un telecomando IR, per accendere un carico collegato al Relay sul PIN 13. Inoltre è possibile modificare il code del telecomando, attraverso il pushbutton di RESET AUTHOR: Giacomo Bellazzi VERSION: 1.0 */

80 #include <IRremote.h> int RECV_PIN = 11; int RELAY_PIN = 13; int pushbutton = 3; unsigned long code; IRrecv irrecv(recv_pin); decode_results results; void setup() { pinmode(relay_pin, OUTPUT); pinmode(pushbutton,input); irrecv.enableirin(); Serial.begin(9600); int on = 0; unsigned long last = millis(); void loop() { int buttonstate = digitalread(pushbutton); delay(100); if ( buttonstate == HIGH) { Serial.println("Settings..."); if (irrecv.decode(&results) && millis() - last > 250){ code = results.value; Serial.println("New code setting..."); Serial.println(code); Serial.println(results.value); last = millis(); irrecv.resume(); if (irrecv.decode(&results)){ if (millis() - last > 250 && results.value==code ) { on =!on; digitalwrite(relay_pin, on? HIGH : LOW); last = millis(); irrecv.resume();

81 Questo programma, a differenza di quello precedente, permette di modificare il codice IR che permette di azionare un relè, anche in fase di run time, impostandolo attraverso un push button collegato ad Arduino. L operazione è davvero semplice ed è mostrata nel video: 4 Programma: accendiamo la TV Samsung di casa con Arduino Questo programma permette di accendere una TV Samsung con il nostro piccolo Arduino. Il primo passaggio è quello di usare di ricavarsi il codice RAW del segnale emesso dal nostro telecomando, attraverso il programma che è stato precedentemente discusso precedentemente, Ora dobbiamo prendere il codice RAW, cancellare il primo valore, convertire i segni con degli spazi e mettere le virgole tra i vari valori ,4450,4400,600,1650,600,1600,600,1650,600,500,600,550,550,550,600,500,600,550,550,1600,650,1600,600,1650,600,550,550,55 0,550,550,600,550,550,550,600,500,600,1600,600,550,600,550,550,550,550,550,600,500,600,550,600,1600,600,550,550,1650,600,160 0,600,1650,600,1600,600,1650,600,1600,600, Il codice per Arduino che serve per inviare il segnale alla TV

82 è il seguente: #include "IRremote.h" IRsend irsend; void setup() { Serial.begin(9600); unsigned int ON[68]={4450,4400,600,1650,600,1600,600,1650,600,500,600,550,5 50,550, 600,500,600,550,550,1600,650,1600,600,1650,600,550,550,550,550,550, 600,550,550,550,600,500,600,1600,600,550,600,550,550,550,550,5 50,600, 500,600,550,600,1600,600,550,550,1650,600,1600,600,1650,600,16 00,600,1650,600,1600,600,; void loop() { irsend.sendraw(on,68,38); Serial.println("Accendo la TV Samsung"); delay(10000); Il LED ad infrarossi va collegato al pin 3, con una resistenza di almeno 100 Ohm in serie. Il valore della resistenza è proporzionale al raggio d azione del telecomando di Arduino. Come per le lezioni precedenti, i codici di questi programmi sono presenti nella mia repo di Github.

83 Atletica & Arduino: come utilizzare il microcontrollore negli allenamenti Atletica & Arduino: come utilizzare il microcontrollore negli allenamenti Nell atletica, lo scopo principale, è quello di fare la prestazione cronometrica migliore, cercando di abbassare il proprio personale ogni volta che si corre. L elettronica, nel corso degli anni, è sicuramente entrata in questo sport; durante le gare, il tempo viene preso elettronicamente e i dati vengono caricati entro poche ore sui database della FIDAL, l ente che regole le attività a livello nazionale. Tuttavia, il tempo preso manualmente, viene ancora usato, ma ha diversi svantaggi; il primo è quello che è meno preciso

84 rispetto a quello elettrico e secondo richiede la presenza di un altra persona, sopratutto per la velocità, dal momento che auto cronometrarsi per distanze brevi, falsa abbastanza il tempo. Ma per chi vuole utilizzare la tecnologia del tempo elettrico, anche durante i propri allenamenti, senza spendere troppo come può farlo? La risposta è Arduino! Questo fantastico controllore, dal costo contenuto, può infatti permette di tenere traccia dei propri tempi durante l allenamento e addirittura, se si possiede una connessione ad Internet, caricare i dati in un proprio database SQL per compare le prestazioni, anche in diverse giornate. Ma coma funziona esattamente? Prima di rispondere vediamo cosa è necessario per il nostro progetto:

85 Requisiti Hardware x x x x x x x Arduino Uno Buzzer Piezo HC-S004 Sensore ad ultrasuoni Led Interruttore a pulsate Resistenza da 1 kohm Cavi flessibili Requisiti Software Arduino IDE I miei codici La libreria MySQL per Arduino Cosa succede in gara Le gare di velocità, fino ai 400 metri, hanno tutte una partenza dai blocchi e ad ognuno dei corridori è assegnata una corsia, nella quale deve rimanere per evitare squalifiche. La procedura della partenza dei blocchi è così strutturata: Fase 1: Gli atleti hanno già posizionato il proprio blocco e si trovano dietro di esso Fase 2: Il giudice chiama gli atleti con la frase ai vostri posti Fase 3: Una volta che il giudice ha verificato tutti gli

86 atleti si trovano sui blocchi nella posizione corretta, dice la frase pronti, nella quale gli atleti si devono mettere nella posizione di partenza Fase 4: Attraverso uno sparo viene impartito il via. Dal punto di vista cronometrico, il tempo parte effettivamente nello sparo, ma la partenza dell atleta parte con un ritardo di secondi, dovuto alla lentezza del nostro apparato nervoso Fase 5: Corsa nei percorso stabilito Fase 6: Arrivo. Il tempo viene fermato quando atleta supera con il petto la linea del traguardo Ora che sappiamo come effettivamente funziona una gara di atletica, possiamo passare al nostro Arduino. Il nostro microcontrollore viene posizionato all arrivo, sulla riga del traguardo ad un altezza pari a circa 1.50 metro. La procedura di partenza, viene riprodotta in questo modo; l atleta preme il pulsante, con il quale si da il via ad un conto alla rovescia. Infatti c è un tempo di recupero, nel quale l atleta dovrà posizionarsi sulla linea di partenza. Al primo beep, l atleta dovrà già essere sui blocchi e dovrà mettersi nella posizione di pronti. Al secondo beep, partirà effettivamente il tempo e quindi il corridori. Il cronometro viene fermato, quando il ragazzo passerà davanti al sensore ad ultrasuoni. Questo trasduttore, riesce a percepire il passaggio della persona, perché la distanza che precedentemente misurava, è cambiata. L utente potrà vedere il proprio tempo sul seriale di Arduino. In alternativa, è possibile sfruttare la connessione ad Internet, per caricare i dati su un server SQL, per salvare i dati. Tutto chiaro? Spero proprio di si! Il codice, che prende il nome di Atletica_Tempo_ECHO, è possibile scaricarlo dalla mia repo su GitHub, dal seguente link

87 In questa repo è possibile vedere altri codici di programmi che vanno ancora testati. Per esempio il codice che permette di caricare i propri dati su un server SQL, è perfettamente funzionante, ma per ora funziona solo un atleta, nel senso che i tempi vengono caricati unicamente per quella persona. Tuttavia un codice simile a quello riportato si chiama Atletica_Tempo_Easy. In questo caso non sarà possibile calcolare il tempo impiegato, ma un led luminoso è in grado di farci capire se il tempo effettuato è inferiore a quello desiderato. Trattiamo un po più da vicino i programmi presenti: Atletica_Tempo_Echo Questo programma, permette all atleta di prendere il relativo tempo, attraverso un segnale di beep, che indica il via, mentre per quanto riguarda lo stop del tempo, viene fatto attraverso un sensore ad ultrasuoni, che in grado di verificare la differenza di misura di distanza, che dunque permette di stabilire il passaggio della persona. Il programma, è funzionante, ha un piccolo problema; il beep viene fatto partire all arrivo e questo può non essere sentito dallo sportivo. Inoltre, c è un fatto fisico da tenere in considerazione. Il suono viaggia ad una velocità pari a circa 300 m/s e quindi c è un leggero ritardo tra quando la persona sente il beep e quando parte il tempo. Questo è facilmente

88 modificabile in due modi: 1. Si può aggiungere un delay all interno del codice 2. Utilizzare due Arduino Uno, uno posto alla partenza e uno posto all arrivo, dove il primo invio in segnale e viene inserito qui il beep, mentre il secondo stabilisce il tempo (la luce viaggia ad una velocità pari a km/s e quindi è trascurabile questo ritardo!) Nelle prossime versioni, saranno introdotto queste feature, per migliorare il funzionamento. Atletica_Tempo_Echo_MySQL Questo programma è simile a quello precedentemente, con la differenza che i dati vengono caricati su un server con presente un DB. Sul DB, è presente questo Schema Logico: Atleta(IDAtleta, Cognome, Nome, Anno) Risultato(IDAtleta, Tempo, Data, Ora) IDAtleta di Atleta è chiave esterne per Risultato. Questo schema presuppone che i tempi registrati, vengano fatte su una distanza pre-stabilita. In realtà, con poche variazioni, è possibile renderlo utilizzabili su tutte le misure. Per renderlo funzionante il codice, occorre modificare i dati all inizio del codice, inserendo i dati dei propri

89 dispositivi, quali server_ip, nome utente e password della propria installazione MySQL. Atletica_Tempo_Easy Questo programma, presuppone che l atleta voglia fare una prestazione inferiore ad un certo tempo stabilito. Questo avviene attraverso un LED luminoso, posto sull arrivo. I restanti due programmi, hanno lo stesso funzionamento, con la differenza che annullano il problema del ritardo del suono. A breve verrano caricati i video dimostrativi, che spiegano come funzionano i programmi. Qualsiasi commento/feedback è ben accettato, attraverso un commento. Guida scaricabile in formato PDF Lezione 9: Come associare un modulo RTC ad Arduino Per chi ha avuto modo di usare Arduino, si sarà accorto che non è presente un modulo RTC all interno della scheda. Questo

90 significa che Arduino non è in grado da solo si sapere l ora attuale; l unica operazione che è in grado di fare è quello di contare i millisecondi che sono passati dall accensione del dispositivo, ma non niente di più. Come fare per poter utilizzare l ora, nei nostri progetti con il dispositivo? A questa domanda ci sono ben 3 soluzioni: Utilizzare delle librerie speciali di Arduino, che permettono di sfruttare la funzione di calcolo dei millisecondi presenti nel microcontrollore Utilizzare un modulo separato RTC, in grado di essere supportato da Arduino Sfruttare il web, con i relativi server NTC, per ricevere l ora attuale In questo post vedremo le prime due soluzioni, mentre la terza verrà mostrata, quando introdurremo le schield per connettere Arduino al web. 1 Metodo: Librerie software per Arduino Per il donwload della libreria, occorre andare al seguente link /* This file is part of swrtc library. Please check the README file and the notes inside the swrtc.h file to get more info This example will print the time every second to the computer through the serial port using the format HH:MM or HH:MM:SS Written by Leonardo Miliani <leonardo AT leonardomiliani DOT com> This library is free software; you can redistribute it and/or modify it under the terms of the GNU General Public

91 License as published by the Free Software Foundation; either version 3.0 of the License, or (at your option) any later version. */ #include <swrtc.h> swrtc rtc; //create a new istance of the lib const byte WITHOUT_SECONDS = 0; const byte WITH_SECONDS = 1; void setup() { rtc.stoprtc(); //stop the RTC rtc.settime(12,0,0); //set the time here rtc.setdate(4,6,2012); //set the date here rtc.startrtc(); //start the RTC Serial.begin(19200); //choose the serial speed here delay(2000); //delay to let the user opens the serial monitor void loop() { printtime(without_seconds); printtime(with_seconds); Serial.println(""); delay(1000); void printtime(byte withseconds) { sendnumber(rtc.gethours()); Serial.print(":"); sendnumber(rtc.getminutes()); if (withseconds) { Serial.print(":"); sendnumber(rtc.getseconds()); Serial.println(""); void sendnumber(byte number) { byte temp;

92 if (number>9) { temp=int(number/10); Serial.print(char(temp+48)); number-=(temp*10); else { Serial.print("0"); Serial.print(char(number+48)); Come si può notare dal codice del programma, all interno della funzione void setup(), è possibile impostare la data attuale, in modo che Arduino si in grado di calcolarsela, sfruttando il contatore presente nel dispositivo. Ovviamente, qualora Arduino venisse spento, durante la fase di riavvio, verrebbe ricaricato il programma presente in memoria, con l ora che non è più aggiornata, quindi occorre prestare attenzione per questa soluzione. 2 Metodo : Utilizzare un RTC hardware esterno Per questa seconda soluzione è necessario utilizzare un dispositivo esterno Arduino. Sul web se ne trovano tanti disponibili. Per questo programma ho scelto il DS1302.

93 Ecco la documentazione del dispositivo: Ecco il codice per utilizzare questo modulo RTC con Arduino: /* Questo programma permette di utilizzare il modulo RTC DS1302 con Arduino, in modo da poter utilizzare le funzionalità

94 dell'ora e data nei vari progetti */ // Vengono definiti i PIN a cui è connesso il modulo #define SCK_PIN 4 #define IO_PIN 3 #define RST_PIN 2 #include <DS1302.h> // Viene inizializzata la libreria DS1302 rtc(rst_pin, IO_PIN, SCK_PIN); void setup() { rtc.halt(false); // Viene disattiva la protezione alla scrittura rtc.writeprotect(false); Serial.begin(9600); /* Main program */ void loop() { /* Qui è necesario impostare l'ora e la data. Durante la fase di impostazione occorre togleire via i commenti laterali e compilare una prima volta. Successivamente occorre commentare le tre righe di codice e compilare. In questo modo qualora Arduino dovesse riavviarsi, non verrano impostati i dati precedenti (sbagliati) */ // rtc.setdow(tuesday); //rtc.settime(12,03,0); //rtc.setdate(21, 01, 2014); /* Read the time and date once every second */ while(1) { Serial.print("It is "); Serial.print(rtc.getDOWStr()); Serial.print(" ");

95 Serial.print(rtc.getDateStr()); Serial.print(" "); Serial.print("and the time is: "); Serial.println(rtc.getTimeStr()); delay (1000); Per un corretto funzionamento del programma, è necessario leggere quanto spiegato tra i commenti. Riassumendo occorre impostare una volta i dati relativi all ora e alla data, compilare. Dopo aver fato ciò, occorre commentare le righe di codice che permettono di impostare i dati e compilare ancora. In questo modo, un eventuale riavvio di Arduino, non farà impostare i dati sbagliati! Ed ecco il risultato finale:

96 Come sempre i codici dei programmi riportati in questo post sono scaricabili dal seguente link. Albero di Natale comandato con Arduino In questo periodo di feste, quasi tutti hanno fatto il proprio albero di Natale in casa, piccolo o grande che sia. In questo post, vedremo come creare un albero di Natale con pochi, sfruttando Arduino. Attraverso questo microcontrollore, sarà possibile scegliere tra vari profili diversi, che permettono di far cantare e illuminare il nostro albero. Cosa serve?

97 Arduino Uno LED Telecomando ad infrarossi Buzzer Scatola di Pandore/Panettone

98 Pennarelli oppure acquerelli Spiegazione del progetto Alla base del progetto, ci sono vari componenti ognuno con un preciso obiettivo: LED I LED non sono altro che dei diodi, che si accendono quando c è un passaggio corrente, tipicamente di qualche decina di ma. La caduta di potenziale tra anodo e catodo è tipicamente di qualche volt BUZZER Questo dispositivo permette di far suonare Arduino, attraverso un passaggio di corrente all interno del dispositivo. Attraverso il calcolo del periodo di una particolare nota, è possibile riprodurla con il proprio dispositivo. Ecco la lista completa:

99 Note_Musicali_Arduino (file.docx) Note_Musicali_Arduino (file.pdf) Telecomando ad infrarossi

100 Questo dispositivo ha il compito di far decidere all utente che tipo di canzone riprodurre. Premendo uno dei tasti sul telecomando, il ricevitore posto a qualche metro, è in grado di inviare una codifica binaria ad Arduino, che stabilisce il punto del codice di Arduino da far eseguire. Ecco una lista dei codice del telecomando per Arduino : Lista_Codici_IR_Arduino (file.docx) Lista_Codici_IR_Arduino (file.pdf) Passaggi per la realizzazione Prendere un cartone di un Pandore/Panettone Dipingerlo con un colore di verde Disporre i LED attorno alla scatola Collegare anche il Buzzer all esterno Collegare il ricevitore IR all interno del pandoro Collegare anodo e catodo dei vari LED, rispettivamente al PIN scelto e al GROUND 7. Caricare il programma su Arduino

101 Ecco il video del risultato finale Lezione 8: Utilizziamo KeyPad con Arduino il In questa ottava puntata su Arduino, introdurremo un nuovo strumento, utile per tanti diversi progetti: il KeyPad.

102 Il meccanismo di funzionamento è davvero semplice. Esso è formato da 7 cavi, che rappresentano 4 righe e 3 colonne. Attraverso la pressione di un tasto, c è una variazione di tensione sul Pin collegato ad Arduino e quest ultimo è in grado di rilevare il relativo valore. Attraverso questo device è davvero possibile fare tantissimi progetti, come ad esempio una simulazione di un piccolo Bancomat, proteggere una porta d entrata e tanto altro. Vediamo qualche esempio per Arduino. Esempi di programmazione del KeyPad Requisiti Hardware:

103 Arduino KeyPad LED Relay Servo

104 Requisiti Software: Libreria keypad 1 Programma: Hello KeyPad In questo piccolo programma, vedremo come mostrare su seriale il tasto premuto sul KeyPad Alexander Demonstrates the simplest use of the matrix Keypad library. # */ #include <Keypad.h> const byte ROWS = 4; //four rows const byte COLS = 3; //three columns char keys[rows][cols] = { {'1','2','3', {'4','5','6', {'7','8','9', {'*','0','#' ; byte rowpins[rows] = {8,7,6,5; //connect to the row pinouts of the keypad byte colpins[cols] = {4,3,2; //connect to the column pinouts of the keypad Keypad keypad = Keypad( makekeymap(keys), rowpins, colpins, ROWS, COLS ); void setup(){ Serial.begin(9600); void loop(){

105 char key = keypad.getkey(); if (key){ Serial.println(key); Il funzionamento del programma dal punto di vista hardware è già stato spiegato precedentemente. Dal punto di vista software, la situazione è davvero semplice. Sfruttando le librerie già presenti sul sito di Arduino, il loop() è davvero immediato da capire: una volta che viene premuto qualcosa, si entra in if, che stampa sul seriale il relativo valore, semplice no? Il collegamento del KeyPad con Arduino è semplice, basta guardare la seguente foto. In pratica, prendendo il KeyPad dal lato frontale, basta collegare i cavi in modo parallelo, partendo dal Pin 8 fino al Pin 2.

106 Ecco il video che mostra il KeyPad in azione con Arduino: 2 Programma: KeyPad che permette di proteggere qualcosa Questo secondo programma può essere modificato dall utente. In pratica, questo codice, non fa altro che permette di inserire un codice con il KeyPad, verificarlo tramite Arduino e se tale codice è corretto, accende un LED. In realtà è possibile fare qualsiasi cosa, come ad esempio accendere una lampada, aprire una porta con un servo. Lascio questo codice, in modo che chiunque possa implementarlo a suo piacimento. /** Questo programma permette di far inserire da un utente un codice con il KeyPad. Qualora il codice inserito sia corretto, viene accesso un LED. Per inviare il codice, una volta digitato interamente è necessario premere *. Mentre per spegnere il LED, oppure redigitare il codice è necessario premere # Autore Giacomo Bellazzi Versione 1.0 */ #include <Keypad.h> #define LED 13 const byte ROWS = 4; //quattro righe const byte COLS = 3; //tre colonne char keyinsert[6]; // Queste variabili servono come verifica del corretto inserimento del codice int i = 0; int j = 0; int s = 0; int x = 0; // Codice segreto char code[7]= "112233"; char keys[rows][cols] = { {'1','2','3', {'4','5','6', {'7','8','9', {'*','0','#'

107 ; byte rowpins[rows] = {8,7,6,5; //i Pin a cui sono connesse le righe del KeyPad byte colpins[cols] = {4,3,2; // i Pin a cui sono connesse le colonne del KeyPad Keypad keypad = Keypad( makekeymap(keys), rowpins, colpins, ROWS, COLS ); void setup(){ Serial.begin(9600); pinmode(led,output); void loop(){ char key = keypad.getkey(); if (i==0){ Serial.println("Insert PIN to verify..."); i++; if (key!= NO_KEY && j<6){ Serial.print("*"); //Serial.println(key); keyinsert[j]=key; j++; if(key == '*') { Serial.println(); Serial.println("Verifyng the code..."); delay(1000); for(s=0; s<6;s++){ if(keyinsert[s]==code[s]){ x++; if(x==6){ Serial.println("The code is correct"); digitalwrite(led,high); //TODO possibili ulteriori implementazioni else{ Serial.println("The code is incorrect, please

108 retry"); delay(2000); x=0; i=0; j=0; if(key == '#'){ x=0; i=0; j=0; digitalwrite(led,low); Il codice risultato essere leggermente un po più complesso del primo, tuttavia attraverso i commenti presenti è facile intuire il meccanismo di funzionamento dei vari blocchi di codice. In pratica vengono letti i valori inseriti attraverso il KeyPad. Una volta terminata l immissione dei 6 caratteri, si preme il comando * e Arduino valuta se il codice inserito è lo stesso di quello presente in memoria. Questo avviene attraverso un ciclo for e un if che verificano se i 6 valori sono uguali. Ecco il video che mostra il funzionamento del programma : 3 Programma: Utilizziamo il OTP e il KeyPad Questo programma è stato realizzato da Luca Dentella, un appassionato di Arduino. Questo programma si basa sull utilizzo del metodo di sicurezza OTP, che viene usato da chi ha un Online Banking. Per chi non sapesse cosa sia l OTP, ecco una definizione tratta da Wikiepdia: Una One-Time Password (password usata una sola volta) è una password che è valida solo per una singola sessione di accesso

109 o una transazione. La OTP evita una serie di carenze associate all uso della tradizionale password (statica). Il più importante problema che viene risolto da OTP è che, al contrario della password statica, esso non è vulnerabile agli attacchi con replica. Ciò significa che, se un potenziale intruso riesce ad intercettare una OTP che è stata già utilizzata per accedere a un servizio o eseguire una transazione, non sarà in grado di riutilizzarla, in quanto non sarà più valida. D altra parte, una OTP non può essere memorizzata da una persona. Essa richiede quindi una tecnologia supplementare per poter essere utilizzata. [ 1 ] Come vengono generate le password OTP? Gli algoritmi di generazione delle OTP in genere fanno uso di numeri casuali. Ciò è necessario perché altrimenti sarebbe facile prevedere l OTP futuro osservando i precedenti. Gli algoritmi OTP che sono stati realizzati sono abbastanza diversi tra loro. I vari approcci per la generazione di OTP sono elencati di seguito. Algoritmi basati sulla sincronizzazione temporale tra server di autenticazione e client che fornisce la password (le OTP sono valide solo per un breve periodo di tempo) Algoritmi matematici che generano una nuova password in base alla password precedente (le OTP sono, di fatto, una catena di password legate tra loro, e devono essere utilizzate in un ordine predefinito) Algoritmi matematici dove la password è basata su una sfida (per esempio, un numero casuale scelto dal server di autenticazione o dai dettagli della transazione) e/o su un contatore. Ci sono anche diversi modi per rendere note all utente le successive OTP da usare. Alcuni sistemi elettronici prevedono l uso di speciali token che l utente porta con sé, che generano le OTP e le mostrano utilizzando un piccolo display.

110 Altri sistemi sono costituiti da un software che gira sul telefono cellulare dell utente. Altri sistemi generano le OTP sul lato server e le trasmettono all utente su un canale fuori banda, come ad esempio un canale di messaggistica SMS. Infine, in alcuni sistemi le OTP sono stampate su carta, che l utente è tenuto a portare con sé. In pratica l OTP si basa su un calcolo di codice, che è formato da una password one time e da un algoritmo che proviene dall attuale ora. Per il calcolo del codice, viene incontro una semplice applicazione di Google. Per il download della parte di Arduino, trovato tutto il materiale sul post dell autore del codice Per prima cosa, è necessario inserire hmackey all interno del codice di Arduino; questo valore di ricava inserendo la password di default, all interno di questo script, realizzato sempre da Luca Dentella

111 Una volta copiato il codice nello Sketch per Arduino, basterà compilare e per quanto riguarda la parte legata ad Arduino, abbiamo finito. Ora è necessario installare il programma per il calcolo del codice OTP sul nostro Smartphone: Google Authenticator. Ora che abbiamo installato il programma lo apriamo e attraverso la fotocamera, puntiamo lo smartphone sul codice QR che è stato generato in precedenza. Ora abbiamo finito e possiamo testare il programma, attraverso il seriale con Arduino. Ecco un video che mostra l utilizzo del programma: KeyPad 4 4

112 Sul web è possibile trovare una versione del KeyPad con 16 caratteri, cioè con i numeri dallo zero al nove e le lettere AB,C,D. Il meccanismo di funzionamento è lo stesso, il codice varia leggermente. Ecco due esempi come mostrano l utilizzo del KeyPad nella sua versione più grande : 4 Programma con KeyPad 4 4: HelloKeyPad 4 4 /*Questo programma mostra come usare la tastiera KeyPad 4x4 con Arduino Uno. Il testo che viene premuto sulla KeyPad viene mostrato nel seriale */ #include <Keypad.h> const byte ROWS = 4; //quattro righe const byte COLS = 4; //quattro colonne byte colpins[4] = {5,4,3,2; // Pin colonne byte rowpins[4] = {9,8,7,6; // Pin righe char Keys[4][4]= //creo la matrice dei { {'1','2','3','A', {'4','5','6','B', {'7','8','9','C', {'*','0','#','D' ; Keypad keyp = Keypad(makeKeymap(Keys), void setup(){ Serial.begin(9600); void loop(){ char key = keyp.getkey(); if (key){ Serial.println(key); a cui sono connesse le a cui sono connesse le tasti della tastiera. rowpins, colpins,4,4);

113 5 Programma con KeyPad 4 4: Codice Segreto con lettere /** Questo programma permette di far inserire da un utente un codice con il KeyPad. Qualora il codice inserito sia corretto, viene accesso un LED. Per inviare il codice, una volta digitato interamente è necessario premere *. Mentre per spegnere il LED, oppure redigitare il codice è necessario premere # Autore Giacomo Bellazzi Versione 1.0 */ #include <Keypad.h> #define LED 13 const byte ROWS = 4; //quattro righe const byte COLS = 4; //quattro colonne char keyinsert[6]; // Queste variabili servono come verifica del corretto inserimento del codice int i = 0; int j = 0; int s = 0; int x = 0; // Codice segreto char code[7]= "11ABCD"; char Keys[ROWS][COLS]= //creo la matrice dei tasti della tastiera. { {'1','2','3','A', {'4','5','6','B', {'7','8','9','C', {'*','0','#','D' ; byte colpins[4] = {5,4,3,2; // Pin a cui sono connesse le colonne byte rowpins[4] = {9,8,7,6; // Pin a cui sono connesse le righe Keypad keypad = Keypad( makekeymap(keys), rowpins, colpins, ROWS, COLS); void setup(){

114 Serial.begin(9600); pinmode(led,output); void loop(){ char key = keypad.getkey(); if (i==0){ Serial.println("Insert PIN to verify..."); i++; if (key!= NO_KEY && j<6){ Serial.print("*"); //Serial.println(key); keyinsert[j]=key; j++; if(key == '*') { Serial.println(); Serial.println("Verifyng the code..."); delay(1000); for(s=0; s<6;s++){ if(keyinsert[s]==code[s]){ x++; if(x==6){ Serial.println("The code is correct"); digitalwrite(led,high); //TODO possibili ulteriori implementazioni else{ Serial.println("The code is incorrect, please retry"); delay(2000); x=0; i=0; j=0; if(key == '#'){ x=0; i=0; j=0;

115 digitalwrite(led,low); Conclusione Spero che i programmi presentati in questo post, siano di facile lettura e sopratutto, siano possibili di ulteriori implementazioni. Souliss: un progetto open source di domotica da tenere sott occhio Per chi non conoscesse ancora il termine Domotica, trovare qui una breve definizione tratta da Wikipedia: può La domotica, dall unione delle parole domus (che in latino significa casa ) + robotica, è la scienza interdisciplinare che si occupa dello studio delle tecnologie atte a migliorare la qualità della vita nella casa e più in generale negli ambienti antropizzati. Questa area fortemente interdisciplinare richiede l apporto di molte tecnologie e professionalità, tra le quali ingegneria edile, ingegneria energetica, automazione, elettrotecnica, elettronica, telecomu nicazioni ed informatica. La domotica ha lo scopo di rendere più facile la vita, dal momento che permette automatizzare alcune procedure (come ad esempio aprire il cancello di casa), utilizzando un semplice

116 telecomando. La robotica sta avendo solo adesso riscontro da parte degli user, dal momento che il costo per realizzare impianti è diminuito nel corso degli ultimi anni, grazie al progresso tecnologico, che permette di avere sempre un maggiore numero di Transistor su una scheda PCB. Un progetto open source che è nato da pochissimo tempo si chiama Souliss. Questo progetto, ancora in fase di testing, ha come obiettivo di permette a tutte le persone appassionate di informatica/elettronica, di creare dei dispositivi in casa, in grado di essere comandati da remoto, attraverso un semplicissimo smartphone Android. Per esempio è possibile accendere una lampada a distanza, accedere l aria condizionata da remoto oppure aprire il cancello di casa con un tap. Insomma, ci sono davvero tantissimi progetti che si possono fare con Souliss.

117 Souliss si basa sui concetti di nodi e sul meccanismo del P2P; in pratica ogni dispositivo è un nodo (ad esempio la presa elettrica della lampada) e attraverso un micro controllore con interfaccia TCP/IP (è il protocollo principale per la navigazione su Internet) è possibile interagire con il proprio smartphone. In pratica non c è un vero e proprio webserver unico che gestisce ogni singolo device in casa e questo permette di facilitare la creazione di apparecchi in grado di interfacciarsi con il web. Ecco un piccolo manuale, in cui vengono spiegati questi concetti: Ecco una lista degli apparecchi compatibili con Souliss: che sono attualmente

118 List of Supported Boards from Olimex Olimex AVR-T32U4 (ATmega 32U4 microcontroller) Olimex OLIMEXINO-32U4 (ATmega 32U4 microcontroller) Olimex OLIMEXINO-328 (ATmega 328 microcontroller) Olimex MOD-ENC28J60 (Ethernet UEXT Microchip ENC28J60 module) Olimex MOD-WIFI (WiFi UEXT Microchip MRF24WB0MA module)* Olimex MOD-IO (I/O board, 4 relay and 4 opto-isolated inputs) Olimex MOD-IO2 (I/O board, 2 relay and 7 GPIOs) Olimex MOD-RGB (Controller for RGB LED Strip) List of Supported Boards from AirQ Networks AirQ Shield : Wireless 433 MHz Transceiver for snet Networks, Arduino compatible AirQ305 : Wireless 433 MHz board with four relays and four optoisolated inputs. List of Supported Boards from KMTronics KMTronic DINo: Ethernet I/O board Microchip ENC28J60 List of Supported Boards from Freaklabs Freakduino Chibi (Atmel AT86RF230 Wireless 2.4 GHz prototyping board) List of Supported Boards from Arduino Arduino Arduino Arduino Arduino UNO/Duemilanove Leonardo Ethernet (Ethernet Wiznet W5100 prototyping board) Ethernet Shield (Ethernet Wiznet W5100) List of Supported Boards from DFRobot DFRobot XBoardRelay List of Supported Shields Open Electronics RGB Shield Open Electronics Ethernet Shield

119 Ethernet Shield based on ENC28J60 General Requirements Microcontrollers: ATmega328P, ATmega32U4 Wireless 2.4 GHz Point to Point: Atmel AT86RF230 Ethernet Communication: Wiznet W5100, Microchip ENC28J60 WiFi Communication : Microchip MRF24WB0MA Come si può leggere, Arduino è pienamente supportato, rendendo ancora più semplice l utilizzo di Souliss per la creazione di impianti di domotica a basso costa. Per chi fosse interessato a trovare qualche codice pronto da poter utilizzare, ecco la wiki ufficiale Ecco un esempio di utilizzo di Souliss, con il quale è possibile aprire il proprio garage di casa con lo smartphone: Conclusione Souliss è un progetto da poco nato e secondo me merita di essere seguito, perché la domotica sarà il mercato su cui investiranno le aziende nei prossimi anni, dal momento che è un settore che è ancora poco sviluppato. Inoltre, sono già presenti tantissimi progetti sul sito, in modo da poter iniziare fin da subito ad utilizzare il servizio. Buon divertimento con Souliss! [banner]