Arduino BeagleBoard e Tecnologia Beacon

Arduino, BeagleBoard

e tecnologia Beacon

Massimiliano Avagliano

1

Sommario

1. Arduino ...................................................................................................................................................... 3

1.1 What’s Arduino? – Panoramica generale ................................................................................................ 3

1.2 Programmazione Arduino ....................................................................................................................... 6

1.2.1 Funzioni I/O ...................................................................................................................... 10

1.2.2 Comunicazioni Seriali e Librerie ....................................................................................... 12

2. BeagleBoard

............................................................................................................................................. 16

2.1 Beagleboard vs Arduino ...................................................................................................... 18

3. Tecnologia Beacon ................................................................................................................................... 22

3.1 GPS e Beacon per la localizzazione e focus sulla privacy ..................................................... 25

4. Conclusioni .............................................................................................................................................. 27

2

1. Arduino

1.1 What’s Arduino? – Panoramica generale

Con il termine Arduino si fa riferimento ad una scheda elettronica, di piccola dimensione,

open-source dotata di un microcontrollore ATmega che comprende una base hardware per

1

il physical computing che, per definizione, indica la possibilità di realizzare dei sistemi

che possano interagire con l’ambiente

(usando un mix tra hardware e software) esterno.

ha lo scopo di permettere l’interazione con il mondo esterno: il

Quindi il physical computing

sistema può sia acquisire e/o misurare grandezze fisiche tramite l’uso dei sensori sia

comportarsi in un certo modo mediante l’uso di attuatori (Figura 1).

Figura 1. Interazione Arduino-Mondo esterno

prevede l’utilizzo

Tipicamente, il physical Computing sia dei sensori che degli attuatori, in

quanto un sistema:

 sfrutta i sensori per acquisire i dati dal mondo fisico

 esegue delle valutazioni su di essi; azioni sull’ambiente (grazie agli attuatori).

 agisce di conseguenza applicando delle di “processing”

Le valutazioni che avvengono sono caratterizzate da un’operazione che può

essere:

 eseguita direttamente dal microcontrollore;

 remotizzata.

Nel secondo caso, il nostro sistema embedded trasmette i dati ad un server che li elabora e

un comando sulla base della “decisione” presa; questo tipo di

poi, successivamente, invia dell’Internet

approccio rientra nel mondo of Things e della M2M (Machine To Machine)

Communication.

1 Il physical computing è stato sviluppato presso l’Interaction Design Institute, un istituto di formazione post-dottorale

con sede ad Ivrea. 3

Nel dettaglio, la scheda elettronica si compone di:

1. microcontrollore: basato sul dispositivo ATmega328, i cui terminali (pin) sono

connessi a porte I/O;

2. connettore di alimentazione: con voltaggi dai 7 ai 12 V in DC;

3. risuonatore ceramico a 16 MHz: fornisce il clock per tutta la scheda;

4. connettore universal-serial-bus: consente la comunicazione tra computer e Arduino.

È utile, inoltre, anche per alimentare il dispositivo;

5. LED di trasmissione (Tx) e ricezione(Rx): utile per controllare eventuali errori;

6. pulsante di reset: azzera e riporta al default le operazioni del microcontrollore;

7. LED di alimentazione: indica se la scheda è alimentata;

8. LED collegato al pin 13: se è impostato su un valore alto (1) allora il LED è acceso,

altrimenti è spento;

9. terminali per GND e V (5V e 3,3V);

cc

10. terminali analogici in ingresso: dove poter connettere sensori analogici;

11. terminali digitali in ingresso e uscita;

12. header In-Circuit Serial Programming(ICSP): indica la capacità di alcuni

microcontrollori di essere programmati durante la loro installazione in un sistema

completo.

In figura 2 viene messa in evidenza tale componentistica che, nello specifico, appartiene alla

versione Arduino uno.

6 11

8

4 7

5 12

3 1

2 9 10

Figura 2. Componenti dell’Arduino uno. 4 –

Questa versione, in particolare, possiede: una memoria Flash da 32 KB di questi 32 KB,

occupati da un programma d’avvio (bootloader) –

0,5 sono utilizzata per il salvataggio del

nostro sketch che sarà lanciato in esecuzione ad ogni avvio della scheda; una SRAM (Static

RAM) da 2 KB utilizzata in runtime; una EEPROM (Electrically Erasable Programmable

ROM) da 1 KB utile per salvare eventuali dati e parametri di configurazioni necessari al

nostro programma.

In termini di capacità di calcolo si sta parlando di un microcontrollore con architettura RISC

ad 8 bit con una frequenza di clock di 16 MHz. Ciononostante è comunque possibile

realizzare qualsiasi cosa.

A questo hardware viene affiancato un ambiente di sviluppo integrato (Integrated

Development Environment o Integrated Design Environment o ancora Integrated

Debugging Environment- IDE) multipiattaforma: questo programma consente di

programmare tramite un linguaggio semplice ed intuitivo derivato da C e C++ chiamato

Wiring, mentre ciascun programma realizzato viene definito sketch.

Per permettere la stesura del codice sorgente, l'IDE include un editore di testo dotato inoltre

di alcune particolarità, come il syntax highlighting, il controllo delle parentesi e

Il programma scritto dall’utente viene quindi

l'indentazione automatica. memorizzato

all’interno del microcontrollore insieme a tutte le configurazioni di base che permettono il

In poche parole un Arduino nuovo possiede al suo

corretto funzionamento dell’Arduino.

“file” che permette l’utilizzo

interno solo il bootloader: di base di un software dedicato,

semplificando il caricamento dei vari programmi sulla memoria flash incorporata nel chip.

In altre parole il bootloader è un pezzo di codice, scritto sul chip della scheda Arduino, che

permette di verificare se viene inviato un programma, lo sketch, tramite la porta seriale.

Quindi se è presente un codice, lo legge e infine lo scrive nella memoria.

L’Arduino è in grado, quindi, una volta programmato, di leggere gli ingressi – che sia una

–

luce su un sensore o un dito su un pulsante e di convertirlo in un segnale di uscita.

Una considerazione importantissima da fare, onde evitare di bruciare la scheda, riguarda la

sua massima tensione operativa. Il microcontrollore lavora con una tensione di 5V

(massimo tollerabile su tutti i pin) ma è possibile utilizzare un alimentatore esterno tra i 6 ed

i 20V (che rappresentano valori limiti). Inoltre, la corrente massima supportata su tutti i pin

è pari a 40mA.

che salta all’occhio è che,

La cosa trattandosi di un hardware open-source, tutti gli schemi

elettrici sono disponibili online sul sito ufficiale di Arduino - https://www.arduino.cc/ , per

-

è assolutamente “replicabile” in casa;

cui la scheda a tale scopo, infatti, esistono tantissime

“Arduino-like” non ufficiali.

schede 5

1.2 Programmazione Arduino

Il linguaggio di programmazione usato in Arduino è una versione semplificata del

linguaggio C con in più delle funzioni specifiche per gestire, facilmente, le interfacce di I/O

L’ambiente di programmazione

della scheda. (Figura 3) si chiama arduino.exe ed è

2

facilmente scaricabile dal sito ufficiale .

Figura 3. Ambiente di

programmazione in

Arduino

Come si nota dalla figura, ogni sketch contiene sempre due funzioni, setup() e loop() che

racchiudono le impostazioni necessarie per il funzionamento dei dispositivi collegati con

Arduino e i blocchi di istruzioni per svolgere quanto richiesto.

In C, per eseguire un programma era necessario compilarlo. Il processo di compilazione non

fa altro che trasformare le istruzioni scritte in linguaggio naturale in una serie di istruzioni

macchina eseguibili dal calcolatore.

Per Arduino avviene la medesima cosa ma, stavolta la fase di compilazione si traduce e si

completa essenzialmente nella fase di caricamento del codice sulla scheda stessa.

È bene ricordare che ogni istruzione di programma deve terminare con il punto e virgola,

cosa che non accade per le istruzioni del pre-processore.

2 http://arduino.cc/en/Main/Software 6

Per comprendere al meglio un qualsiasi tipo di codice bisogna introdurre dei concetti

cardini:

 Variabili, constanti e tipo di dato;

 Funzioni (parametri di ingresso e di ritorno);

 Operazioni Aritmetiche e Operatori Logici e di Confronto;

 Istruzioni condizionali;

 Istruzioni di preprocessore;

 Costanti di Arduino;

 Funzioni di Arduino.

La variabile rappresenta una locazione di memoria alla quale attribuiamo un nome e nella

quale memorizziamo un determinato valore. È molto importante, quando si programma,

ricordarsi sia di dichiarare le variabili prima di essere usate, altrimenti, in fase di debug, si

produce un errore, sia di specificare di che tipo è la variabile.

In figura 4 sono rappresentati i vari tipi di dato.

Figura 4. Tipi di dato.

Similmente alla variabile, la costante rappresenta una locazione di memoria pre-nominata e

pre-caricata di un certo valore (per esempio, pi=3.14). Anche le costanti, così come le

variabili, vanno dichiarate.

Il linguaggio Arduino è composto di una serie di parole chiave predefinite con valori

specifici:

 HIGH e LOW: per accendere o spegnere un pin in Arduino;

 INPUT e OUTPUT: per impostare un pin come ingresso o uscita;

 per indicare se una condizione o un’espressione è vera o meno.

TRUE/FALSE:

Per funzione si intende un blocco di codice, di istruzioni che vengono eseguite quando la

funzione stessa viene invocata.

La struttura della funzione è la seguente:

<Tipo del valore restituito> <nome funzione> ( <elenco dei parametri> )

7

Dopo il tipo, occorre dichiarare il nome dato alla funzione e, tra parentesi, i parametri che

vengono passati alla funzione.

Come visto dalla figura 3, la struttura base del linguaggio di programmazione di Arduino si

sull’uso di due specifiche:

basa void setup () e void loop().

La funzione setup() è la prima che viene invocata quando parte lo sketch e sarà la prima ad

essere eseguita dopo ogni accensione o reset dell’Arduino. Viene usata, inoltre, non solo per

inizializzare le variabili ma anche per impostare lo stato dei pin, per far partire le varie

librerie da usare e per impostare le comunicazioni seriali.

La sintassi è la seguente:

void setup( ){

// istruzioni varie

}

Dopo la creazione della funzione setup(), che inizializza e imposta i valori iniziali, la

Quest’ultimo

funzione loop() esegue ciclicamente il programma definito al suo interno.

la sezione di codice principale che verrà ripetuto all’infinito fino a quando non si

indica

spegne la scheda. La sintassi di questa funzione è:

void loop( ){

// istruzioni da ripetere in modo ricorsivo

}

Un esempio di codice è riportato in figura 5. Figura 5.

8

L’istruzione all’Arduino

pinMode(LED,OUTPUT) non fa altro che dire come usare un

determinato pin. Tra le parentesi tonde devono essere specificati gli argomenti che possono

essere numeri e lettere. Se non avessimo usato #define LED 13, potevamo scrivere:

pinMode(13,OUTPUT). sia come INPUT che come OUTPUT : nell’esempio

I pin digitali possono essere utilizzati –

preso in considerazione, poiché vogliamo far lampeggiare il diodo LED vogliamo quindi

ottenere un’uscita - dobbiamo definire il pin di OUTPUT. Le parole INPUT e OUTPUT

sono costanti definite, che non variano mai nel linguaggio di Arduino.

Anche l’istruzione digitalWrite(LED,HIGH), come si nota, possiede due argomenti: il primo

definisce i