ARDUINO Duemilanove
Lelio Spadoni
Argomenti trattati
• Caratteristiche di Arduino Duemilanove (hardware e software)
• Programmazione di Arduino
• Arduino + GPS
• Ethernet shield
• XBee shield
• Arduino + GSM
• Arduino + Bluetooth
Arduino
Principali caratteristiche
• 14 ingressi/uscite digitali di cui:
6 utilizzabili come uscite di tipo PWM;
4 utilizzabili per comunicazione SPI;
2 utilizzabili per comunicazione I2C;
2 utilizzabili per i collegamenti seriali TTL level;
2 utilizzabili per interrupt esterno;
• 6 ingressi analogici (risoluzione 10 bits)
• memoria SRAM 2KB;
• memoria FLASH 32KB di cui 2 utilizzati per il bootloader;
• memoria EEPROM 1KB
• microcontrollore ATMEGA328 a 16 MHz
Arduino
Principali caratteristiche
• Il microcontrollore è fornito con un bootloader, che è un software che
permette il caricamento dei programmi in memoria senza l’ausilio di
programmatori esterni (occupa 2 KB di memoria flash).
• Il bootloader si mette in ascolto di comandi o dati in arrivo dal computer
(che generalmente sono i programmi scritti dall’utente) e li carica nella
memoria flash del microcontrollore; dopodiché viene lanciato il programma
in memoria. Se non ci sono programmi in arrivo dal computer viene lanciato
l’ultimo sketch* caricato. Se invece, il microcontrollore è vuoto viene
lanciato in continuazione il bootloader.
*programma scritto dall’utente
Arduino
IDE
• Il software per la programmazione di tutti i tipi di schede Arduino, si
chiama semplicemente Arduino.
• Ne esistono diverse versioni sia per Windows (quella testata in questo
lavoro), sia per Linux sia per Mac.
• La versione utilizzata per le successive prove è la 0018.
Arduino
Programmazione
• Uno sketch si compone di due funzioni principali che non accettano
nessun parametro e non restituiscono alcun valore:
- void setup() , tutte le istruzioni contenute all’interno di questa funzione
vengono eseguite una sola volta al lancio dello sketch da parte del
microcontrollore;
- void loop() , tutte le istruzioni contenute in questa funzione sono eseguite
in continuazione.
• E’ sempre possibile inserire parti di programma all’interno di altre funzioni
che vengono richiamate dal programma principale all’occorrenza.
Arduino
Programmazione - Strutture e Costanti
• setup()
• loop()
• if
• if...else
• for
• switch case
• HIGH | LOW
• INPUT | OUTPUT
• true | false
• Integer Constants
• while
• do... while
• break
• continue
• return
Arduino
Programmazione - Funzioni
Digital I/O
• pinMode(pin, mode)
• digitalWrite(pin, value)
• int digitalRead(pin)
Analog I/O
• int analogRead(pin)
• analogWrite(pin, value)
Advanced I/O
• tone()
• noTone()
• shiftOut(dataPin, clockPin, bitOrder, value)
• unsigned long pulseIn(pin, value)
Time
• unsigned long millis()
• unsigned long micros()
• delay(ms)
• delayMicroseconds(us)
Math
• min(x, y)
• max(x, y)
• abs(x)
• constrain(x, a, b)
• pow(base, exponent)
• sq(x)
• sqrt(x)
• map(value, fromLow, fromHigh,
toLow, toHigh)
Trigonometry
• sin(rad)
• cos(rad)
• tan(rad)
Random Numbers
• randomSeed(seed)
• long random(max)
• long random(min, max)
Communication
• Serial
Arduino
Programmazione - Librerie
• Di solito uno sketch utilizza delle librerie di comandi che consentono di
controllare dei particolari dispositivi.
• Molte librerie per usi generali e per le comunicazioni, sono già pronte
come ad esempio: SPI, I2C, Ethernet, ecc…; altre possono essere scritte
dagli utenti a proprio uso e consumo.
• Le librerie vengono inserite con il comando
#include <SoftwareSerial.h>
Arduino - Laboratorio
…per cominciare!
int sensorPin = 0;
int ledPin = 13;
int sensorValue = 0;
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop() {
sensorValue = analogRead(sensorPin);
digitalWrite(ledPin, HIGH);
delay(sensorValue);
digitalWrite(ledPin, LOW);
delay(sensorValue);
}
“Il led collegato al pin 13 lampeggia
con una frequenza proporzionale al
valore di tensione letto sull’ingresso
analogico 0 regolato da un
potenziometro”.
ARDUINO + GPS
Arduino - Laboratorio
GPS
• Il GPS (Global Positioning System) è il sistema
satellitare di posizionamento globale, capace di
localizzare in ogni momento la posizione di un
dispositivo senza l’ausilio di carte o bussole.
• I satelliti inviano ai ricevitori i dati necessari al
calcolo della loro posizione.
• Il calcolo della posizione si basa sulla
conoscenza della distanza del dispositivo da tre
punti noti (tre satelliti).
Arduino - Laboratorio
GPS - NMEA
• Il ricevitore dopo aver elaborato le informazioni provenienti dai satelliti,
invia sulla seriale i risultati in una forma standard chiamata frase NMEA
(National Marine Electronics Association).
• Esempio di frase (o sentenza):
$GPRMC,140502.53,A,4329.5619,N,01256.1853,E,000.1,000.0,271209,002.3,E,A*36
Arduino - Laboratorio
GPS - Programma
#include <SoftwareSerial.h>
#define rxPin 2
#define txPin 3
SoftwareSerial mySerial =
SoftwareSerial(rxPin, txPin);
int buffer_int;
byte buffer_byte;
void setup(){
pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);
Serial.begin(9600);
mySerial.begin(4800);
}
void loop(){
buffer_byte = mySerial.read();
Serial.write(buffer_byte);
}
“I dati trasmessi sulla seriale dal GPS
vengono intercettati e inviati tramite
i comandi seriali al Personal
Computer dove possono essere
visualizzati ed interpretati”.
GPS-41MLR
Arduino - Laboratorio
GPS – Cattura sentenza NMEA
• Il ricevitore utilizzato in questa prova (GPS-41MLR) trasmette sulla seriale
le sentenze NMEA: $GPGSA, $GPGSV, $GPRMC, $GPGGA
ARDUINO + Ethernet shield
Arduino - Laboratorio
Ethernet shield
• La Ethernet shield è una scheda elettronica che si
collega alla Arduino Duemilanove board con la
quale è possibile il collegamento ad una rete locale
LAN.
• La Ethernet shield è basata sull’integrato Wiznet
W5100 che è un 10/100 ethernet controller,
progettato per applicazioni embedded, che
fornisce lo stack TCP/IP dal livello fisico fino al
livello di trasporto.
Arduino - Laboratorio
Ethernet shield – Architettura di riferimento
• In questo primo esempio Arduino è il client che richiede una pagina .html
al Web Server Apache.
Arduino - Laboratorio
Ethernet shield – Lato Server
• Arduino si collega all’indirizzo http://192.168.1.100 e richiede la pagina
index.html (visibile di seguito insieme alla sua pagina sorgente).
Arduino - Laboratorio
#include <Ethernet.h>
Ethernet shield – Lato client
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE,
0xED };
• Nel programma a fianco, dopo
aver impostato l’IP del server
(al quale è inviata la richiesta) e
del client (che genera la
richiesta), viene inviata una
richiesta GET e viene inoltrata la
risposta attraverso la porta
seriale.
byte ip[] = { 192, 168, 1, 103 };
byte server[] = { 192, 168, 1, 100 };
Client client(server, 80);
void setup() {
Ethernet.begin(mac, ip);
Serial.begin(9600);
delay(1000);
Serial.println("connecting...");
if (client.connect()) {
Serial.println("connected");
client.println("GET /index.html HTTP/1.0");
Arduino - Laboratorio
Ethernet shield – Risultato
• Con il Serial Monitor
disponibile nel software di
programmazione di Arduino
catturiamo i dati che arrivano
sulla seriale.
• Dall’analisi della videata a
fianco si vede che il server ha
risposto alla richiesta del client
inviandogli un messaggio di
HTTP/1.1 200 OK e di seguito il
sorgente (HTML) della pagina
richiesta.
Arduino - Laboratorio
Ethernet shield – Architettura di riferimento
• In questo secondo esempio Arduino è il server che una volta interrogato
dal client (FireFox), gli invia una pagina .html in cui inserisce il livello di
tensione presente all’ingresso analogico 0 in quel momento.
Arduino - Laboratorio
Ethernet shield – Lato Server
• Dopo aver impostato l’IP e la
porta di ascolto (http) del server
(Arduino), questo si mette in
attesa
di
una
richiesta
proveniente da un client (Firefox);
al suo arrivo il server inserisce in
una pagina in formato .html il
livello di tensione presente
all’ingresso analogico “0”, e la
invia come risposta alla richiesta
del client.
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
byte ip[] = { 192, 168, 1, 103 };
Server server(80);
void setup()
{Ethernet.begin(mac, ip);
server.begin();
Serial.begin(9600);}
void loop()
{Client client = server.available();
if (client) {
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.print(c);
if ((c == '\n')) {
client.println("HTTP/1.1 200 Ok");
client.println("Content-Type: text/html");
client.println();
client.println("<html>");
client.println("<title>");
client.println("Arduino Web Server");
client.println("</title>");
client.println("<body>");
client.println("<hr>");
client.println("<h2 align=\"center\">Arduino Web
Server</h2>");
client.println("<hr>");
client.println("<br>");
client.println("<h2 align=\"center\">Il livello di
tensione presente all'ingresso analogico 0
&egrave;</h2>");
client.print("<h1 align=\"center\">");
client.print(analogRead(0)*0.0048828125);
client.println("</h1>");
client.println("</body>");
client.println("</html>");
break; }}}}
delay(1);
client.stop();}
Arduino - Laboratorio
Ethernet shield – Lato client
• La pagina di richiesta da
parte del client.
• La pagina di risposta da
parte del server.
ARDUINO + XBee
Arduino - Laboratorio
XBee shield
• Il modulo XBee è una soluzione compatibile con lo standard ZigBee/IEEE
802.15.4 che soddisfa la necessità di una rete a basso costo e a basso
consumo, pensata soprattutto per l'utilizzo con sensori.
• Per configurare lo XBee il suo
produttore, la Digi International,
mette a disposizione il software
X-CTU, reperibile all’indirizzo:
http://www.digi.com
Arduino - Laboratorio
XBee shield – Architettura di riferimento
• In questo esempio il trasmettitore invia al ricevitore lo stato di due
contatori interni (uno si incrementa , l’altro si decrementa ad ogni secondo);
il ricevitore riceve i dati e li invia, attraverso un collegamento USB (seriale
virtuale) al PC in cui un applicativo (Tera Term) li mostra a video.
Arduino - Laboratorio
XBee shield – Configurazione del Coordinator
• La configurazione che permette al
Coordinator di ricevere i dati da
qualsiasi modulo Xbee Router/End
Device, si ottiene con le impostazioni
seguenti:
•Modem Xbee: XB 24-B
•Function Set:
ZNET 2.5 COORDINATOR AT
• Operating Channel: 11
(canali da 11 a 26)
• Operating PAN ID: 234
(numero a scelta)
Arduino - Laboratorio
XBee shield – Configurazione del Router/End Device
• La configurazione che permette al
Router/End Device di trasmettere i
dati verso il Coordinator, si ottiene con
le impostazioni seguenti:
•Modem Xbee: XB 24-B
•Function Set:
ZNET 2.5 ROUTER/END DEVICE AT
• Operating Channel: 11
(canali da 11 a 26)
• Operating PAN ID: 234
(numero a scelta)
Arduino - Laboratorio
XBee shield – Lato Router/End Device
• Lo sketch a lato deve essere
caricato sulla scheda Arduino
2009 dove è alloggiato il
Router/End Device (TX).
• Nel programma vengono creati
due contatori: il primo A è
inizializzato
a
0
e
successivamente incrementato
di 1; il secondo B è inizializzato a
1024
e
successivamente
decrementato di 1.
• Quando il contatore arriva a
1024
viene
impostato
nuovamente a zero e il ciclo
riparte.
int count = 0;
void setup() {
Serial.begin(9600);
}
void loop() { // counter A will go forwards
Serial.print('A');
Serial.print(count);
Serial.println();
delay(1000); // counter B will go backwards
Serial.print('B');
Serial.print(1024 - count);
Serial.println();
delay(1000); // increase and reset the
counter
count++;
if (count == 1024) count = 0;
}
Arduino - Laboratorio
XBee shield – Lato Personal Computer
• Nella pagina iniziale di Tera Term selezionare la porta seriale sulla quale è
collegato il Coordinator e assicurarsi di impostare i parametri di
comunicazione nel seguente modo:
• Baud rate: 9600
• Data: 8 bit
• Parity: none
• Stop: 1 bit
• Flow control: none
• Il risultato è che
vedremo a video il
contatore A che si
incrementa,
mentre il contatore
B si decrementa.
ARDUINO + GSM
Arduino - Laboratorio
GSM - Telit GM862
• Il modem della Telit GM862 è utilizzato nell’esempio seguente per
inviare un SMS, attraverso la rete GSM, ad un telefono cellulare.
• Una volta inserita la SIM di un qualsiasi gestore di telefonia mobile il
dispositivo ricerca la rete e, nel caso sia presente, si collega ad essa.
• Per comandare il modem si utilizzano i comandi AT.
Arduino - Laboratorio
GSM - Comandi AT
• La maggior parte degli attuali modem utilizza i comandi AT Hayes, uno
specifico insieme di comandi originalmente sviluppato per il modem Hayes
Smartmodem da 300 baud.
• Ogni funzione del modem è governata dal relativo comando AT (che sta
per ATtention, attenzione).
• Per inviare un comando occorre trasmettere sulla porta seriale del modem
una stringa ASCII formata da AT seguito da uno o più comandi e da un
carattere di ritorno a capo (CR).
Arduino - Laboratorio
GSM - Schema elettrico
Arduino - Laboratorio
Programma per
l’invio di un SMS
“Dopo aver caricato lo
sketch nell’ATmega328,
viene inviato un SMS
attraverso il modem ad
esso collegato tramite
una seriale software.”
Arduino - Laboratorio
Utilizzo dei comandi AT
• Invio di un SMS da un telefonino, utilizzando i comandi AT:
a) collegare il proprio cellulare al PC (seguire le istruzioni del produttore);
b) aprire un programma che simula un terminale (HyperTerminal, Tera
Term, ecc…) e selezionare la COM dove è collegato il telefono;
c) digitare i seguenti comandi:
1: AT
2: OK
3: AT+CMGF=1
4: OK
5: AT+CMGW=“328467xxxx“
6: > Un semplice messaggio :-)
7: +CMGW: 1
9: OK
10: AT+CMSS=1
11: +CMSS: 20
13: OK
La descrizione dei
comandi è nella
slide seguente
Arduino - Laboratorio
Utilizzo dei comandi AT
• Linea 1: "AT" viene spedito al modem GSM/GPRS per testare la connessione. Il
modem risponde con un codice di risposta (OK alla linea 2)
• Linea 3: Il comando AT+CMGF viene usato per istruire il modem ad operare in
modalità testuale per gli SMS. Il codice di risposta OK alla linea seguente indica che linea
di comando AT+CMGF=1 è stata eseguita con successo;
• Linee 5-6: Il comando AT+CMGW viene usato per memorizzare nel modem il
messaggio, mentre +85291234567 è il numero telefonico del destinatario. Dopo aver
digitato tale numero, premete il tasto Enter. Il modem a questo punto dovrebbe ritornare
il prompt ">" e a questo punto potete incominciare a scrivere il vostro SMS (in questo
caso "Un semplice messaggio"). Quando avete finito, premete Ctrl+Z;
• Linea 7: +CMGW: 1 ci dice che l'indice assegnato al messaggio è 1. Questo indica la
locazione dell'SMS nella memoria del modem;
• Linea 9: Il risultato OK indica che l'esecuzione del comando +CMGW ha avuto
successo;
• Linea 10: il comando +CMSS viene usato per spedire i messaggi dalla memoria del
modem. 1 indica l'indice dell'SMS ottenuto alla linea 7;
• Linea 11: +CMSS: 20 ci dice che il numero di riferimento assegnato all'SMS è 20;
• Linea 13: Il risultato OK indica che l'esecuzione del comando +CMSS ha avuto
successo.
ARDUINO + BLUETOOTH
Arduino - Laboratorio
BluetoothBee
• BluetoothBee è un modulo Bluetooth Serial Port Profile (SPP) che permette di
realizzare collegamenti seriali wireless.
• Il device è pienamente compatibile con la XBee shield già vista nelle slide precedenti; in
pratica basta sostituire il modulo Xbee con il modulo BluetoothBee per avere a
disposizione la tecnologia Bluetooth.
CSR Bluecore-04 Externel
Bluetooth singol chip
BluetootBee
Arduino - Laboratorio
BluetoothBee - Caratteristiche Hardware e Software
Arduino - Laboratorio
BluetoothBee – Installazione del dispositivo
• In questa immagine si vede come si installa il modulo BluetoothBee sulla
Xbee shield e anche come si posiziona quest’ultima sulla Arduino board.
Arduino - Laboratorio
BluetoothBee – Architettura di riferimento
• In questo esempio faremo in modo che il modulo BluetoothBee si colleghi
con il PC equipaggiato con una chiavetta Bluetooth.
• Una volta avvenuto il collegamento fra i due dispositivi, inviando il
carattere “a” dal PC (utilizzando il programma Tera Term o altro simile), il
modulo BluetoothBee risponderà inviando indietro la stringa “You are
connected to BluetoothBee”.
Arduino - Laboratorio
BluetoothBee – Collegamento BluetoothBee-PC
Animazione
Arduino - Laboratorio
BluetoothBee - Sketch
Sketch 1/2
• Lo sketch a lato deve
essere caricato sulla
scheda Arduino 2009
dove è alloggiato il
BluetoothBee.
• Con questo programma
il
modulo
BluetoohBee funziona in
modalità slave.
• Quando
arriva
il
carattere “a” , Arduino
risponde
con
il
messaggio: "You are
connected
Bee“.
to
Bluetooth
void setup()
{ Serial.begin(38400);
setupBlueToothConnection();
}
void loop()
{ if(Serial.read() == 'a')
{ Serial.println("You are connected to Bluetooth Bee");}
}
void setupBlueToothConnection()
{ delay(1000);
sendBlueToothCommand("\r\n+STWMOD=0\r\n");
sendBlueToothCommand("\r\n+STNA=modem\r\n");
sendBlueToothCommand("\r\n+STAUTO=0\r\n");
sendBlueToothCommand("\r\n+STOAUT=1\r\n");
sendBlueToothCommand("\r\n+STPIN=0000\r\n");
delay(2000);
Arduino - Laboratorio
BluetoothBee - Sketch
Sketch 2/2
• Lo sketch prosegue
dalla slide precedente.
Serial.print("\r\n+INQ=1\r\n");
delay(2000);
}
void sendBlueToothCommand(char command[])
{ Serial.print(command);
delay(3000);
}
• Comandi utilizzati
Arduino - Laboratorio
BluetoothBee - Flowchat
Arduino - Laboratorio
BluetoothBee – Risultato
Prossimi sviluppi
Arduino
Arduino + Android
Arduino
Arduino + WiFi