Il modulo XBee è un componente, creato dalla Digi, che ci consente di far comunicare in modo differenti wireless due schede Arduino. Quando parliamo di XBee dobbiamo aver presente che tipo di componente ci serve, poichè la gamma di questi moduli è veramente molto vasta, come anche le shield adatte ad essi, oppure le antenne. Parlando del componente, possiamo trovare:
- XBee pro 60mW wire antenna - Series 1 (802.15.4);
- XBee 1mW trace antenna - Series 1 (802.15.4);
- XBee 1mW wire antenna - Series 1 (802.15.4);
- XBee 2mW wire antenna - Series 2 (ZigBee Mesh);
- XBee 2mW PCB antenna - Series 2 (ZigBee Mesh);
- XBee pro 63mW RPSMA - Series 2B (ZigBee Mesh);
- XBee pro 60mW U.FL connection - Series 1 (802.15.4).
Questi sono solo alcuni dei molti differenti moduli in vendita; non scriverò ognuno di essi poichè la differenza è principalmente la distanza massima di comunicazione, oltre che l'antenna preinstallata, ed inoltre ne verrà trattato solo uno in questo articolo. In ogni caso la lista è facilmente reperibile on line.
Bisogna però valutarne l'impiego, poichè se dobbiamo creare una rete privata di XBee dobbiamo averne a disposizione almeno due, ed il costo di questi moduli non è indifferente, nonostante la semplicità dell'utilizzo valga l'impiego dei soldi.
Descrizione del modulo
In questo articolo andremo a studiare il modulo XBee 1mW wire antenna - Series 1 (802.15.4), perciò di seguito ne troverete le caratteristiche:
- 3.3V
- 250kbps di velocità massima di scambio dati
- 1mW output (0 dBm)
- 100 m di distanza massima
- Antenna
- 6 10 bit ADC input pins
- 8 digital I/O pins
- Crittografia a 128 bit
- Configurazione locale o a distanza
- Set di comandi AT o API
La particolarità di ogni modulo XBee, incluso il componente che stiamo studiando, è la capacità di semplificare l'utilizzo dell'802.15.4 stack, che è anche la base per lo ZigBee, trasformandola in un set di comandi utilizzabili via connessione seriale in modo molto semplice. Difatti questo componente rende la comunicazione di qualsiasi dispositivo avente una porta seriale molto semplice ed accessibile.
Oltre al modulo utilizzeremo anche una XBee shield V3.0 , la quale ci semplificherà ulteriormente il lavoro, poichè una volta installati i moduli XBee su questo componente, caricando l'applicativo su Arduino UNO, i moduli comunicheranno automaticamente, senza dover ricorrere al settaggio manuale; un buon aiuto per il completamento dei nostri progetti in modo rapido.
Abbiamo quindi visto e capito le caratteristiche hardware del nostro modulo; di seguito potete trovare un piccolo progetto di esempio per capirne l'utilizzo corretto, nonostante la semplicità.
Progetto: inviamo dati tramite interfaccia seriale da un modulo XBee ad un altro
In questo progetto testeremo la capacità di trasmissione dati da un modulo XBee ad un suo simile, inviando tramite interfaccia seriale un dato raccolto da un dispositivo PIR; in base a questo, il secondo componente deciderà cosa deve essere fatto ed invierà quindi un dato, in base al quale verrà accesa o meno una luce led.
Utilizzeremo i nostri dispositivi XBee Series 1 installati su una XBee shield V 3.0 , perciò è necessario sapere che il programma da lanciare dovrà essere caricato precedentemente all’installazione sulla scheda della shield, altrimenti il caricamento non verrà completato. Inoltre, poiché il dispositivo funzioni, dobbiamo fare attenzione al fatto che il piccolo switch in basso a sinistra sulla nostra shield sia dalla parte con la scritta XBee, e non dove presenta la scritta USB, altrimenti attenderà la ricezione di dati alla nostra porta seriale, e non dal modulo XBee.
Una volta caricato l’applicativo sui nostri Arduino UNO li staccheremo dall’alimentazione, così da installare correttamente il supporto XBee; dopo questa operazione procederemo a collegarlo nuovamente alla corrente, ed in pochi secondi potremo verificare la corretta comunicazione dei due dispositivi, con anche l’output dei dati su cui sta lavorando il modulo nel nostro serial monitor.
Questo progetto non vuole essere complicato ma solo esplicativo e di dimostrazione delle caratteristiche più rilevanti del modulo su cui lavoriamo. Spero che sarà utile!
Primo codice:
Per costruire questa prima parte del progetto occorre un Arduino UNO, una XBee shield v 3.0, un modulo XBee 1mW wire antenna - Series 1 (802.15.4), un led, collegato al pin digitale 13 della XBee shield, ed un PIR, collegato al pin digitale 7 della shield:
Codice:
/*
Programma da caricare su un Arduino UNO. Viene letto il valore assunto da un dispositivo PIR,
dopodichè questo dato viene inviato ad un altro modulo XBee tramite interfaccia seriale;
questo Arduino poi attenderà una risposta che gli comunichi il da farsi, ovvero se accendere o meno il led.
Programma molto semplice ma adatto a chi è alle prime armi con gli xbee.
Scritto da: Cristian Cesaro.
*/
int pir = 7; //Definiamo il pin al quale è collegato il PIR
bool presence; //Definiamo una variabile di tipo booleano che assumerà valori durante l'esecuzione del codice
const short led = 13; //Definiamo una variabile intera costante per il led
char risp; //Definiamo una variabile di tipo character che servirà a memorizzare la risposta dell'altro XBee
void setup() {
Serial.begin (9600); //Inizializzazione della simulazione dell'interfaccia seriale
pinMode (led, OUTPUT); //Modalità del pin: impostiamo che il pin 13 deve dare risultati in output, cioè ricevere impulsi
pinMode (pir, INPUT); //Modalità del pin: impostiamo che il pin 7 collegato al PIR deve leggere valori, quindi ricevere impulsi elettrici
}
void loop() {
Presenza (); //Lanciamo il void Presenza()
if (presence == 0){ //Se la variabile precedentemente dichiarata corrisponde a 0
Serial.print (presence); //Scriviamo la variabile sul serial monitor
delay (2000); //Attendiamo due secondi
delete & presence; //Distruggiamo la varibile completamente per evitare malfunzionamenti del programma
delay (1000); //Attendiamo un secondo
}else{ //Altrimenti
Serial.print (presence); //Scriviamo sul monitor seriale il contenuto della variabile presence
delay (2000); //Aspettiamo due secondi
delete & presence; //Distruggiamo totalemnte la varibile utilizzata
delay (1000); //Aspettiamo un altro secondo
}
if (Serial.available () > 0){ //Se è disponibile una lettura di caratteri sul serial monitor
risp = Serial.read (); //Memorizziamo il carattere nella varibile risp già dichiarata
if (risp == 'S'){ //Se risp contiene il carattere S
leds (); //Viene lanciato il void leds()
}
else if (risp == 'A'){ //Altrimenti se la varibile contiene un carattere uguale ad A
leda (); //Viene lanciato il void leda()
}
risp = ' '; //Per evitare bug, impostiamo che la variabile risp assuma il valore carattere vuoto
}
}
void leda (){ //Void che fa accendere il led
digitalWrite (led, HIGH); //Scrittura digitale, invia impulsi per accendere il led
}
void leds (){ //Void che fa spengere il led
digitalWrite (led, LOW); //Scrittura digitale, Arduino non invia impulsi, così il led rimane spento
}
void Presenza (){ //Void per la lettura del valore del PIR
presence = digitalRead (pir); //Lettura digitale del pin 7 a cui è collegato il PIR e memorizzazione in una variabile.
}
Secondo codice:
Per il montaggio di questo secondo circuito abbiamo necessità di un Arduino UNO, una XBee shield V3.0, ed un modulo XBee 1mW wire antenna - Series 1 (802.15.4).
Codice:
/*
Programma da caricare su un Arduino UNO. Viene letto da monitor seriale un dato raccolto dall'altra scheda Arduino,
riguardante il valore di un PIR, ed in base a questa lettura risponde, scrivendolo sempre su monitor seriale,
cosa fare al primo Arduino, ovvero viene inviato il carattere S se la luce deve rimanere spenta, ed invece viene inviato il carattere
A se la luce deve accendersi.
Un piccolo progetto basato sulla semplicità di comunicazione di dati da un modulo XBee ad un altro.
Scritto da: Cristian Cesaro.
*/
void setup(){
Serial.begin (9600); //Inizializziamo l'interfaccio di comunicazione seriale con una velocità di scambio dati di 9600 baud
}
void loop(){
int lettura; //Inizializziamo una varibile intera nominata lettura
if (Serial.available() > 0){ //Se l'interfaccia seriale riceve un qualsiasi tipo di dato
lettura = Serial.read (); //Memorizziamo il dato nella variabile dichiarata precedentemente
if (lettura == '0'){ //Se la variabile corrisponde al carattere 0
char risp = 'S'; //Inizializziamo una variabile di tipo character e memorizziamo nella variabile il carattere S
Serial.print (risp); //Scriviamo sul monitor seriale la variabile carattere dichiarata precedentemente
delay (1500); //Attendiamo un secondo e mezzo
delete & risp; //Distruggiamo la variabile carattere
delay (500); //Attendiamo ancora mezzo secondo
}
else if (lettura == '1'){ //Altrimenti, se la variabile lettura corrisponde al carattere 1
char risp = 'A'; //Inizializziamo la variabile carattere risp e memorizziamo il carattere A
Serial.print (risp); //Scriviamo sul monitor seriale la variabile appena dichiarata
delay (1500); //Aspettiamo un secondo e mezzo
delete & risp; //Distruggiamo la variabile risp
delay (500); //Aspettiamo mezzo secondo ancora
}
lettura = ' '; //Memorizziamo un carattere nullo all'interno della variabile lettura
}
}