SquidBee

SquidBee es un dispositiu de maquinari obert i codi font obert, de sensors inalàmbrics. El objectiu de SquidBee es aconseguir un “mote obert” per a crear xarxes de sensors inalàmbrics (WSN).

Els conceptes principals que té SquidBee son els següents : Auto alimentada. Comunicacions inalàmbriques.

Com treballa SquidBee?1. Adquireix els valors dels paràmetres: temperatura, humitat, lluminositat, presencia,

per quasi qualsevol cossa que es pot detectar amb sensors.2. Transmet aquests valors, quan sigui necessari.3. Capacitat de temps d'espera fins el següent i es repeteix el primer pas.

El segon pas no sempre es necessari, en funció dels càlculs necessaris, pot esser millor per a fer en el ordinador del receptor per estalviar energia dels nodes.

Un mote obert. Que significa realment?Això significa que cada part de la caixa es accessible i pot esser estudiat, modificat i personalitzat,...Des de el circuit esquemàtic fins el codi font dels programes que s'executen dintre de la caixa.

Qui pot estar interessat en SquidBee?Qualsevol persona que esta investigant en el camp de vigilància del medi ambient.Aquest es també un projecte educatiu per a que les universitats ofereixin als seus estudiants un dispositiu multi aprenentatge. Amb SquidBee la gent pot aprendre al mateix temps, electrònica, programació, comunicacions,... i tot en un sol dispositiu.

Qui esta darrere de SquidBee?La junta directiva dintre de SquidBee ha sigut desenvolupat per el equip d'Arduino. El modul de comunicacions que permet el node transmetre a traves d'un modul ZigBee que a estat creat per per “LIBELIUM”. Amb-dos components son de maquinaria obert. Tenen una wiki especialitzada en relació amb SquidBee i les xarxes de sensors, es creara en breu.

Que puc fer amb SquidBee?El que es pot fer bàsicament, es “sentir el medi ambient” i transmetre'l

Dos configuracions de SquidBee? Que es exactament?Utilitzant la mateixa targeta i el modul de comunicacions han creat dos tipus de SquidBee: el “mote” sensors i el “gateway”. El primer es el “mote” de sensors auto-alimentat i el segon es el receptor USB connectat al ordinador.

Puc integrar SquidBee en una xarxa de malla inalàmbrica 802.11?Si També han desenvolupat un route Mesh per ha funcionar al aire lliure que pot utilitzar per a recollir mitjançant el protocol ZigBee i transmetre'l a la xarxa que utilitzi la tecnologia Wi-Fi (802.11).

Puc afegir mes sensors? Quants?Si es pot afegir, SquidBee té 12 E/S digitals i 6 E/S analògiques, això permet fins a 18 sensors.

Quin tipus de nous sensors puc afegir?Qualsevol. So, gasos , fum, presencia, GPS, la pressió.

Auto-alimentat? De quin tipus de bateries estem parlant?SquidBee treballa amb 5 V, aixi que podem utilitzar qualsevol cossa que s'alimenti entre 5V-15V. Configuracions son: 4*1,5V (AA) i 2*9V (6F22).

Puc incluir un modul GPS?Si. Han desenvolupat un modul GPS per a SquidBee.

Quin es el modul ZigBee de transmetre energia?El modul de comunicació desenvolupat utilitza el xip MaxStream Xbee. Hi ha dues versions:

Xbee: 1mW= 30 metres en interiors, 100m l'aire lliure. Xbee: Pro: 100mW= 100 metres en interiors, i 1600 a l'aire.

SquidBee bé amb un modul Xbee 1mW i un connector de cable flexible connectat a una antena de 2,1 dB dipol. Aquesta configuració s'utilitza perquè el objectiu de baix consum. Peró es pot canviar el modul Xbee si ja les transmissions son necessàries per que el xip no esta soldada a la placa. També pot canviar l'antena, la connexió amb el modul ZigBee es fa a traves d'un connector MMCX estandar mascle.

Característiques: La base del mòdul es Arduino + Xbee. “Mote” de codi obert. Energia de la bateria de 9V. Fàcil programació (Arduino). 12 pins digitals d' E/S i 6 pins d'entrada analògica. 5 pins PWM sortida analògica. Connexió USB per a PC (Windows, Linux i Mac). La comunicació sense fils, amb mòdul XBee base (ZigBee). Sensors:

Temperatura. Humitat. Lluminositat. Possibilitat d'afegir mes sensors.

Possibilitat d'afegir mes “motes”. Topologia de xarxa Peer-to-peer, punt a punt, punt-a-multipunt i de malla. Dirigint-se a 65.000 “motes”. Mida del mòdul 70 x 60 x 30 mm. Mida de la caixa 120 x 65 x 40 mm.

Especificacions tècniques: Mòdul de control - Arduino :

Velocitat del processador: 16 Mhz. Flash (programa). ATmega8 - 8KB . ATMega168 - 16 kb. EEPROM de 512 bytes. SRAM 1KB .

Digital I / O 12 . E / S analògiques 6. Tensions de servei de 5 V - 12 V

Que son les característiques de la placa Arduino Uno.

Mòdul de comunicació sense fils. Potència de sortida d'1 mW (fins a 100 m) XBee ,100 mW (fins a 1000 m)

XBee Pro. RF velocitat de dades 250 kbps. Freqüència d'operació es de 2,4 Ghz. Tensions de servei de 5 V – 12 V. Topologia de xarxa Peer-to-peer, punt a punt, punt-a- multipunt i de malla. Capacitat del canal 16 canals de seqüència directa (programari seleccionable)

. Davant 65.000 adreces de xarxa disponibles per cada canal.

Sensors: Temperatura. Humitat. Lluminositat. Es poden afegir mes:

Altres sensors. Connexió bàsica del sensor analògic. Sensor resistiu. Una resistència

que canvia el seu valor amb el magnitud dels sentits. Fem una crida R resistència pull-up i en general és d'1 kW o 10 kW. Sensor analògic.

La sortida del sensor és un valor analògic, el que significa que es poden obtenir els valors de 0 V a 5 V .En general, no necessiten una resistència de per aquest i connecteu directament a un senyal analògic al pin.

Connexió bàsica del sensor digital: Sensor digital. La sortida del sensor és un valor digital 0 (0 V) o 1 (5 V). Si el sensor necessita un resistència de pull-up o pull-down ens

connectem a 1 kW i 10 kW resistència entre 5 V (per pull-up) o 0 V (per pull-down).

Si el sensor no cal Pull-up o Pull-down resistència que es connecta directament a un pin digital.

Circuits electrònics: Placa Arduino Uno.

Placa Xbee.

Coneixements Bàsics SquidBee:

Lectura d'un valor analògic i convertir-lo en el valor real

Quan fem servir en arduino analogRead (pin) que estem rebent un valor sencer que correspon amb un valor de tensió. Aquest valor ens pot variar aleatòriament entre 0 i 1023.

0 és equivalent a 0 volts.

1023 és l'equivalent a 5 volts

Per tant, si volem obtenir el valor en volts de l'entrada 0 que hem de fer el següent càlcul

Valor = analogRead (0) * 5 / 1024 .

Adició d'un sensor analògic:

En primer lloc anem a veure una mica de sensors analògics.

Un sensor analògic és un component que mesura qualsevol magnitud real i tradueix el seu valor en una magnitud que podem mesurar amb un circuit electrònic, normalment un valor resistiu o capacitiu del que podem convertir-lo en un valor de tensió (normalment entre 0V i 5V). Finalment, podem obtenir aquest valor en el nostre microcontrolador utilitzant un dels seus pins d'entrada analògica.

La majoria dels sensors analògics que utilitzarem són sensors resistius, la connexió que hem de fer és molt simple (figura 1).

Sensor és el sensor resistiu i R en general és 1 kW o 10 kW

Una vegada que el sensor està connectat l'Arduino es pot obtenir el valor en el seu programa d'Arduino amb la funció analogRead només has d'escriure en el seu programa

val == analogRead (pin);

val és la variable per emmagatzemar el valor i el pin és el número del pin analògic(0-5). Després de la conversió d'analògica a digital val obtindrà en val un nombre entre 0 i 1023, el que significa 0-0 V i 1023 - 5V i així successivament.

També hi ha alguns sensors que ofereixen una sortida analògica, el que es pot connectar directament a l'entrada analògica.

Adició d'un sensor digital:

Un sensor digital és un component que proporciona valor digital de la magnitud mida significa '0 'o '1', 'tots' o 'res' per la qual cosa hi ha només dos valors possibles en la seva sortida. Normalment, el valor dels canvis de sortida del sensor amb algun tipus de “ mon

real” .

Una vegada que el sensor està connectat l'Arduino es pot obtenir el valor en el seu programa d'Arduino amb la funció digitalgRead només has d'escriure en els seu programa:

int val = 0;

void setup () { pinMode (pin, INPUT); }

void loop () { val == digitalRead (pin); }

En la configuració que ha de declarar amb pinMode el pin com a entrada. Val és la variable per emmagatzemar el valor i el pin és el número del pin digital (2.13).

La lectura d'un sensor de llum:

Un sensor de llum (LDR o resistència dependent de llum) és un component simple que proporciona una resistència variable que canvia amb la llum, que podem llegir a la placa Arduino com un valor analògic. En aquest exemple, aquest valor controla la velocitat a la qual un LED parpellegi.

Materials necessaris:

Placa Arduino.

LDR.

Una resistència kW.

Placa .

3 cables .

Un LED connectat al pin 13 de Arduino (si la teva placa Arduino no hi ha cap connectat).

Em connectar tres cables a la placa Arduino. El primer va a terra d'un dels pins de la LDR. El segon va de 5 volts a un dels pins de la resistència d'1kW. L'altre cable va de la resistència al pin lliure en la LDR. El tercer va des de l'entrada analògica 2 al pin LDR que està connectat a la resistència.

Codi:

/ * Sensor de llum * ------------------ * * Encén i s'apaga un díode emissor de llum (LED) connectat al sistema digital * Pin 13. La quantitat de temps que el LED estarà encès i apagat depèn de * El valor obtingut per analogRead () que és funció de la quantitat * De la llum en el LDR * * /

int LDR = 2; / / selecciona el pin d'entrada de la LDR int ledPin = 13; / / selecciona el pin per el LED int val = 0; / / variable per emmagatzemar el valor procedent del sensor de

void setup () { pinMode (LDR, INPUT); / / declara el LDR com entrada pinMode (ledPin, OUTPUT); / / declara el ledPin com sortida }

void loop () { val = analogRead (LDR); / / llegir el valor del sensor

digitalWrite (ledPin, HIGH); / / posar el pin 13 en High (alt, encès) delay (val); / / atura el programa durant un temps digitalWrite (ledPin, LOW); / / posar el pin 13 a Low (baix, apagat) delay (val); / / atura el programa durant un temps }

La lectura d'un sensor de Temperatura:

Un sensor de temperatura és un component simple que proporciona una resistència variable que canvia amb la temperatura, que podem llegir a la placa Arduino com un valor analògic. En aquest exemple, aquest valor controla la velocitat a la qual un LED parpellegi.

Materials necessaris:

Placa Arduino.

NTC.

Una resistència 1kW.

Placa .

3 cables .

Un LED connectat al pin 13 de Arduino (si la teva placa Arduino no hi ha cap connectat).

Em connectar tres cables a la placa Arduino. El primer va a terra d'un dels pins de la NTC. El segon va de 5 volts a un dels pins de la resistència d'1kW. L'altre cable va de la resistència al pin lliure en la NTC. El tercer va des de l'entrada analògica 2 al pin NTC que està connectat a la resistència.

/ * El sensor de temperatura * ------------------ * * Encén i s'apaga un díode emissor de llum (LED) connectat al sistema digital * Pin 13. La quantitat de temps que el LED estarà encès i apagat depèn de * El valor obtingut per analogRead () que és funció de la temperatura * En el NTC * * /

int NTC = 2; / / selecciona el pin d'entrada de la NTC int ledPin = 13; / / selecciona el pin per el LED int val = 0; / / variable per emmagatzemar el valor procedent del sensor de

void setup () { pinMode (NTC, INPUT); / / declara la NTC com a entrada pinMode (ledPin, OUTPUT); / / declara el ledPin com SORTIDA }

void loop () { val = analogRead (NTC); / / llegir el valor del sensor digitalWrite (ledPin, HIGH); / / pin 13 encès delay (val); / / atura el programa durant un temps digitalWrite (ledPin, LOW); / / pin 13 apagat delay (val); / / atura el programa durant un temps }

Construeix tu mateix una “mote” SquidBee:

SquidBee és una “mote2 de detecció sense fils que mesura simultàniament la temperatura, humitat relativa i la intensitat de la llum i envia sense fils les dades a una passarel·la de monitorització. Aquest tutorial esta destinat a proporcionar una guia de muntatge ràpid per a aquells que volem construir una SquidBee a través d'etapes de construcció senzilla.

Si anem a construir una “mote” SquidBee, quan anem a obrir, tenim que comprovar que esta tot el material per a construir-la, aquesta es la llista de material necessari.

Llista de components:

Caixa SquidBee.

Entrada de cables i la femella de fixació.

Placa Arduino.

Pins headers de 2,54 mm i preses de corrent.

Resistències 1 kW / 10 kW . LDR sensor (Sensor de llum). RH Sensor (Sensor d'Humitat). LM35 Sensor (Sensor de Temperatura). Cables de connexió Màniga Termoretràctil. Clip de la bateria de 9V Antena omnidireccional 3 dBi, mascla SMA i femella SMA. Placa per el xip Xbee i xip Xbee. Soldador, pasta per soldar, tisores, alicates, tornavís i lleuger (aquest material no esta

inclòs).Passos a seguir:

Una vegada, hem comprovat que tenim tot el material necessari per la construcció de la nostra “mota”, procedirem a construir la nostra primera SquidBee.

1. Descarregar el programari de programació d'Arduino (IDE Arduino) , per a la nostra plataforma en el nostre cas Windows i procedim a instal·lar-la ( com esta explicat en els tutorials d'Arduino).

2. Agafar la placa Arduino i treure el microcontrolador Atmega 328p amb cura (podem utilitzar un destornilllador). Ara inserim el mòdul Xbee a la placa Xbee i aquesta a la placa Arduino, en les preses corresponents ( solament hi ha una manera que encaixen).Comproveu que els dos jumpers dels ponts sobre l'escut Xbee es posen a "USB". Llavors, connectarem el cable USB a l'Arduino i al ordinador i hem de comprovar si el LED PWR està encès (Arduino està encès).

3. Obrir una finestra de terminal, per exemple, HyperTerminal, X-CTU en Windows o en Linux Gtkterm, per tal de comunicar-se amb el mòdul Xbee amb comandaments AT. Seleccioneu el port USB de la placa Arduino es connecta a través i una velocitat de transmissió de 9600bauds, que és la velocitat per defecte. Després d'això, escriviu els següents comandaments:

+ + (Si vostè aconsegueix una resposta OK, la comunicació és correcta, i si no, revisi els passos anteriors).

ATBD4 [ENTER] (això canvia la velocitat de transmissió de 19200bauds) - OK . ATWR [ENTER] (aquest guarda els canvis) - OK . ATCN [ENTER] (per sortir) - OK

Hem fet servir aquest comandaments però amb altres programes ho tindrem de fer d'una altra manera però el objectiu es canviar la velocitat de transmissió de la nostra SquidBee.

4. Traiem la placa Xbee i tornem a inserir el xip Atmega 328 o agafar una altra placa

Arduino. Amb el cable USB connectat, obrim el programari d'Arduino (IDE Arduino), anem a Eines (Tools)-> Plaques (Boards) i seleccionem el model que nosaltres estem fent servir, a continuació, aneu a Eines (Tools)-> Serial Port i seleccioneu el port USB al que està connectada la nostra placa ( Tot això esta mes explicat als tutorials en el temari Arduino). Còpia i pega el codi bàsic (veure exemple) o qualsevol tipus de codi desitgem, i a continuació, premeu el botó "verificar" per compilar i, finalment, "pujar a l'E / S". Heu de veure el LED TX / RX de Arduino parpelleja. En aquest punt sabem que la placa Arduino està llest per llegir els senyals dels sensors i enviar dades sense fils.

5. Soldarem les tres potes de cada sensor i els cables junts com es mostra a la figura. Tingueu en compte que la LDR necessita una resistència addicional retorçat i soldat en paral·lel.

6. Inserir els petits tubs termoretràctils al voltant de cada cable i tubs més amplis al voltant de cada grup de 3 fils, i reduir-los tots amb un encenedor. El resultat dels tentacles aïllatats ha de deixar al descobert només 03/04 cm en l'extrem dels cables.

7. Col · loqueu dos petits tubs termoretràctils al voltant dels cables vermell i negre del clip de la bateria. Prengui un parell de pins, doblegar en angle recte (90 º) amb un alicates i inserir el costat més llarg a una presa de Arduino. Ara soldar els cables i el costat curt dels pins entre si i aïllar les connexions amb l'encenedor.

8. Busquem tres connectors 5V/3V i GND a la placa Xbee (veure exemple de la figura). Prendre sis preses de pin, col·locar-les a través d'aquestes vies lliures a la part frontal de la placa Xbee i soldar a la cara inversa.

9. Prendre els tentacles i inserir tots els cables descoberts a través de la part estreta del passa murs de cables. Poseu la cara ample del passa murs de cables amb els cables descoberts a través del gran forat fora de la caixa SquidBee, després cargolar la femella i estrenyer fermament que tot el grup al panell de la caixa.

10. Afluixar la femella i volandera d'or de la cua, col·loquem el SMA-enf a través del petit forat dins de la caixa i el cargol SquidBee les peces d'or un cop més per tal de fixar al tauler. Després, inseriu el U.FL-final en el connector corresponent de la fitxa Xbee amb un clic.

11. Inseriu els dos connectors de la bateria en el clip de Vin GND i preses de Arduino, assegurant-se que està utilitzant la polaritat correcta (Vin = vermell, GND = negre). Canvi el jumper del PWR_SEL del port USB de Arduino a "EXT" i els dos ponts sobre placa de "XBee". Després posi la placa Xbee de nou sobre l' Arduino . Ara col·locarem l'Arduino +la placa Xbee + el clip de la bateria a la caixa de SquidBee.

12. Connectem els tres cables vermells i els tres cables negre, els negres a les preses GND que ja havíem soldat i els vermells a les preses de 3V i 5V, i ara connectarem els cables de senyal morat, groc i blanc a la Arduino i Xbee a les entrades analògiques 0-1-2 (veieu la figura).

13. Tanqueu el quadre de SquidBee i el cargol de l'antena al connector SMA.

La “mote” comença a enviar dades d'uns segons després de connectar una bateria de 9V . A més, es pot connectar una “gateway” al nostre ordinador amb un cable USB i llegir aquestes en una finestra de terminal. És molt fàcil de construir una “gateway” només l'ús d'una placa Arduino sense xip Atmega i una placa Xbee connectat de la mateixa manera com es descriu en el pas numero 2.

Codi Bàsic :

/*

*/// Declaració de variablesint sens0 = 0; //sensorsint sens1 = 1;int sens2 = 2;int val0 = 0; //aux varint val1 = 0;int val2 = 0;int count = 0;void setup(){Serial.begin(19200); //Inicialitza el port serie amb una velocitat de transmissió de19200bps (el mateix que el xip XBee)

}//Funció per enviar les dadesvoid sendData(int id,int num, int data0,int data1,int data2){ Serial.print("@"); Serial.print(id); Serial.print("|"); Serial.print(num); Serial.print("|data0-"); Serial.print(data0); Serial.print("|data1-"); Serial.print(data1); Serial.print("|data2-"); Serial.print(data2); Serial.println("#r"); // final de missatge}void loop(){ while (count <= 10000){val0 = analogRead(sens0);val1 = analogRead(sens1);val2 = analogRead(sens2); sendData(3,count, val0,val1,val2);delay(5000);count++;} count = 0;}

Com fer dormir (mode Sleep) a la SquidBeeSens dubte una de les característiques més importants d'una xarxa de sensors sense fils és la durada de la bateria de les “motes”. En l'actualitat, amb el programari inicial de SquidBee la vida de la bateria no dura molt de temps, pel fet que el sensor llegeix a intervals (cada “mote” llegeix i envia missatges cada 5 segons).

Normalment, en una xarxa "normal" de sensors, no necessitem les “motes” enviïn dades cada 5 segons, la causa es que la temperatura, la humitat o la llum no canvien tant, en un període tant curt de temps. Pel que considerem un bon interval de temps és, per exemple 5 minuts per a l'enviament de missatges de dades.

Una altra cosa que fem per estalviar energia en SquidBee és utilitzar el mode de dormir la placa i el mòdul XBee. Arduino es pot configurar per a dormir i despertar amb una font d'interrupció.

En l'Arduino s'utilitzara un mode d'estalvi d'energia i com a font d'interrupció conegut com interrupció per desbordament del temporitzador 2.

Timer 2 ( Temporitzador 2) és un comptador de 8 bits (compte fins a 255) i és capaç de provocar una interrupció de desbordament si s'utilitzen també un preescaler 10 bits. Es divideix la freqüència entre 1024 i tenim una font d'interrupció que es dispara 61 vegades per segon (16 milions / 1024 / 255 = 61).

Una vegada que la font d'interrupció de temporitzador 2 està configurada hem d'establir els paràmetres per posar Arduino i el mòdul XBee en mode de repòs.

Arduino

Per ajustar els paràmetres del mode dormir (Mode Sleep) en Arduino fem servir la biblioteca de la son (Sleep Library)

Principi mundial El somni (Mode Sleep) és l'assistència de les interrupcions. sense ells, només un reinici pot despertar l'Arduino de nou. Afortunadament, les interrupcions s'han incorporat des de la versió 0007 de l'IDE Arduino.

En matèria de maquinari, el Arduino està equipat amb dos ports d'interrupció: pin digital 2 i 3. Pel que l'Arduino pot detectar els pins per a un esdeveniment de despertar i reprendre l'execució de codi. Fins i tot és possible executar codi especial en funció de cada pin va provocar el despertar (la interrupció).

Esdeveniments en el USART (sèrie) també es desperta l'Arduino. Perquè això funcioni, l'Arduino ha d'estar en POWER_MODE_IDLE, la manera d'únic poder que no es desactiva el USART. Encara que aquesta manera no dóna grans estalvis d'energia que pot utilitzar les funcions previstes en avr / power.h (power_adc_disable(), power_spi_disable(), power_timer0_disable (), power_timer1_disable (), power_timer2_disable(), power_twi_disable()).

A causa de la forma dominant es trenca una interrupció en l'execució del codi principal, és convenient que el codi sigui executat per una interrupció de temps possible. Potser fins i tot acaba d'establir una variable que es tractaran en el programa principal. Sempre que el codi de la interrupció de carreres, els temporitzadors interns estan a l'espera.

Exemple Nota de l'autor: no hi ha necessitat d'una resistència entre RX i el pin 2 i la declaració anterior és bastant confusa. De fet, RX i el pin 2 es pot connectar directament com RX ja està connectat a la sortida del convertidor de USB a sèrie i una línia de sèrie quan en estat de repòs es troba en nivell lògic alt (en el que significa TTL 5V). Per tant el pin 2 està efectivament ja es va aturar en un alt estat. Una resistència només pot ser útil per limitar la discòrdia entre dues sortides si els programes de pin 2 com sortida per error (pins són d'entrada per defecte de totes maneres), encara que actual ja és internament limitat a 40 mA.

#include <avr/sleep.h>

/* Demostració mode Sleep * -----------------* Codi d'exemple per demostrar les funcions de mode Sleep Arduino.** L'ús d'una resistencia entreRX i el PIN2. Per defecte RX s'atura en nivell alt (5V).*Per tant, poden utilitzar una seqüència de dades en sèrie obligant a que RX sigui 0.* Farà el Pin2 a Baix (LOW) activem la interrupció INT0 externa de manera que * El MCU torni a funcionar.** També hi ha un comptador de temps que possarà el MCU a dormir desprès de 10sg.** NOTA:en tornar del mode “Power-Down” es necessita una mica de temps* Fins que el sistema esta totalment en funcionament al 100% (normalment <1seg)*Este programa es de programari lliure: pot esser redistribuir i/o modificar* esta baix els termes de GNU * La Fundació de programari lliure.o* (A la teva elecció) a qualsevol versió posterior.* * Aquest programa es distribueix amb l'esperança que serà util,* però sense cap garantia, fins i tot sense garantia implícita de* DE ESSER ADEQUAT A UNA I PARTICULAR. Veure el* els detalls de la GNU.* * Vostè ha d'haver rebut una còpia de la GNU.* Si no consulti en la web <http://www.gnu.org/licenses/>.* */

int wakePin = 2; // pin utilitzat per a despertarint sleepStatus = 0; // variable per emmagatzemar una sol·licitud de Sleepint count = 0; // comptador

void wakeUpNow() // Aqui es controla la interrupció després de despertar{ // executar el codi després de despertar, abans de tornar a la funció bucle ()// temporitzadors i el codi d'ús de temporitzadors (serial.print i mes...) no funcionarà aqui.// En realitat no te necessitat executar cap funció especial aqui ja que// Només vull que cal fer per despertar.

}

void setup(){pinMode(wakePin, INPUT);

Serial.begin(9600);

/* Ara és el moment perquè una interrupció. A la crida a la funció * attachInterrupt(A, B, C)* A Pot ser 0 o1 per a les interrupcions en el pin 2 o 3. * * B Nom d'una funció que voleu executar, mentre que en interrompre.** C Modes de disparament de la patilla d'interrupció. Poden ser:* LOW un tret de baix nivell* CHANGE un tret quan hi ha un canvi de nivell.* RISING un tret quan hi ha un flanc ascendent.* FALLING un tret quan hi ha un flanc descendent.** En tots els modes d'espera inactius només LOW es pot utilitzar.*/

attachInterrupt(0, wakeUpNow, LOW); //Ús d'interrupció 0 (pin2) i la funció d'execució// wakeUpNow quan el pin 2 esta LOW }

void sleepNow() // Aquí posem l'Arduino a dormir{ /* Ara és el moment d'establir la manera de repòs. En el full de dades ATmega8* http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf on page 35* No és una llista de maneres de repòs el que explica que els rellotges i * despertar les fonts estan disponibles en la manera de dormir.**En l'arxiu avr/sleep.h , els noms de cridar a un d'aquests modes de Sleep es trobem:** Hi ha 5 modes diferents:* SLEEP_MODE_IDLE No estalvia energia * SLEEP_MODE_ADC* SLEEP_MODE_PWR_SAVE* SLEEP_MODE_STANDBY* SLEEP_MODE_PWR_DOWN El major estalvi d'energia.* Per ara, volem que l'estalvi d'energia tant com sigui possible, de manera que* Escollir-la* La manera de suspensió : SLEEP_MODE_PWR_DOWN* */ set_sleep_mode(SLEEP_MODE_PWR_DOWN); // el mode sleep s'estableix aquí

sleep_enable(); // activa el bit de Sleep en el registre mcucr// Per que el mode Sleep sigui possible. Només un un pin de seguretat

/* Ara és el moment per una interrupció. Ho fem aqui * Si accidentalment premem el botó d'interrupcció no s'interromp * El nostre programa en execució. Si vols ser capaç d'executar * la interrupció mes el mode Sleep , col·locar setup() per exemple.* * A la funció de crida attachInterrupt(A, B, C)* A pot ser 0 o 1 per les interrupcions dels pin 2 o 3. * B Nom d'una funció que voleu executar, mentre que en interrompre.** C Modes de disparament de la patilla d'interrupció. Poden ser:* LOW un tret de baix nivell* CHANGE un tret quan hi ha un canvi de nivell.* RISING un tret quan hi ha un flanc ascendent.* FALLING un tret quan hi ha un flanc descendent.** En tots els modes d'espera inactius només LOW es pot utilitzar.*/

attachInterrupt(0,wakeUpNow, LOW); // ús d'interrupció 0 (pin2) i la funció d'execució // wakeUpNow quan el pin 2 esta en LOW

sleep_mode(); // Aqui realment el dispositiu es posa a dormir!!// El programa segueix d'aquí després de despertar

sleep_disable(); // El primer després de despertar:// desactivar el mode SleepdetachInterrupt(0); // Desactivar la interrupció 0 al pin 2 de manera que el // Codi wakeUpNow no es pugi executar //Durant el temps de funcionament normal.

}

void loop(){ // Informació sobre la pantalla del comptador Serial.print("Awake for "); Serial.print(count); Serial.println("sec"); count++; delay(1000); // espera un segon// Calcula la entrada serie if (Serial.available()) {int val = Serial.read();if (val == 'S') {Serial.println("Serial: Entrar en mode Sleep");delay(100); // Aquest retard és necessari, el Sleep //Funció va a provocar una sèrie d'errors d'una altra manera!! count = 0;sleepNow(); // La funció sleep cridada aqui}if (val == 'A') {

Serial.println("Hola Senyors"); // Clàssic missatge}}

// Comprovar si s'ha d'anar a dormir a causa del tempsif (count >= 10) {Serial.println("Timer: Entering Sleep mode");delay(100); // Este retard és necessari, en mode Sleep //Funció va a provocar una sèrie d'errors d'una altra manera!!count = 0;sleepNow();// La funció de Sleep la cridem aqui}}

XBee

Per configurar XBee en mode de suspensió és molt fàcil, el XBee que es va a utilitzar ha de ser configurat amb els següents paràmetres:

- ATSM1 => Mode de son - pin hibernació - ATD70 => control de flux CTS discapacitats

Finalment, hem de connectar el pin 6 de Arduino amb el

pin 9 en XBee, ja que està treballant amb Arduino i XBee 5v, amb 3,3 V, no cal connectar directament, utilitzarem un pont de resistència per adaptar-se a aquests nivells ( veure imatge).

Un cop tinguem tot el maquinari que acabem de llegir el codi i llest, tenim la nostra SquidBee estalviar tota l'energia possible.

Quants estem estalviant energia?

Per respondre a aquesta pregunta hem mesurar el consum actual amb SquidBee normal i després amb el mode d'estalvi d'energia nova.

SquidBee manera normal ==> 69-70mA. Energia estalviada 69 mA

SquidBee manera d'estalvi ==> 14 mA en mode de repòs 69 mA (estat remitent aprox. 0,5 s cada 5 min)

Energia estalviada ((14 x 295 mA s) + (69 x 5 mA s)) / 300 = 14. 91 mA

Com pot veure, l'energia estalviada és (69-14,91) / 69 = 78%

/* * * * Aquest arxiu és part d'exemple de codi SquidBee * SquidBee_sleeping.pde és un programari lliure, podeu redistribuir o modificar * Sota els termes de la GNU segons les bases * de la Free Software Foundation; ja sigui la versió 2 de la llicència, o * (A la seva elecció) qualsevol versió posterior. * * Aquest programa es distribueix amb l'esperança que serà útil, * Però sense cap garantia, fins i tot sense la garantia implícita de * O ADEQUACIÓ A UN FI PARTICULAR. Veure el * Els detalls de la llicència GNU. * *Vostè ha d'haver rebut una còpia de la llicència GNU *Juntament amb Foobar. Si no és així, consulteu <http://www.gnu.org/licenses/>. *//* Nom: squidbee_sleeping.pde * Version 0.0.1 * Descripció: Exemple de codi per demostrar les funcions del son en SquidBee. *// ** El temps variable controla el temps de la SquidBee està dormint,quan aquest t.* És més d'Arduino es desperta, desperta a Xbee i enviar un missatge a traves* Xbee, més tard es torna a dormir.** Pin 7 a SquidBee (Arduino) està connectada al pin 9 a Xbee (resistència de * pont) Xbee torna estat de Sleep* -------*       pin 7 (Arduino)  ---------|       |---------+-------------  pin 9 XBee*                                  -------          |  *                                   10 k            |*                                                   -*                                                  | |*                                                  | |  15 k*                                                  | |*                                                   -*                                                   |*                                                   |*                                                   |*                                                  gnd  * /

#include <avr/interrupt.h>#include <avr/io.h> #include <avr/sleep.h>#define INIT_TIMER_COUNT 0#define RESET_TIMER2 TCNT2 = INIT_TIMER_COUNTint int_counter = 0int second = 0;int counter = 0;int XBee_pin = 7; // Aquest pins despertar Xbee i el va posar a dormirint seconds = 300; // El temps de Sleep (Segons aprox) // MINIMUM VALUE = 5 int time = 2*seconds;// Tiempo auxiliarint sens0 = 0;// Variables SquidBee int sens1 = 1;int sens2 = 2;int sens3 = 3;int val0 = 0; int val1 = 0;int val2 = 0;

int val3 = 0;int id = 23; // nodo identificadorint al = 0;// codi alarma// Aruino funciona a 16 Mhz, de manera que tenim 61 desbordaments per segon...// 1/ ((16000000 / 1024) / 256) = 1 / 61ISR(TIMER2_OVF_vect) {// Esta subrutina s'executa 61 vegades per segon

int_counter ++; if (int_counter == 15) {second++;int_counter = 0;} if (second == time - 1) {digitalWrite(XBee_pin, LOW);} if (second == time) { second = 0; val0 = analogRead(sens0);val1 = analogRead(sens1);val2 = analogRead(sens2);val3 = analogRead(sens3); sendData(id,al,val0,val1,val2,val3); digitalWrite(XBee_pin, HIGH);} }// Funció per enviar les dadesvoid sendData(int id, int al, int val_t0,int val_h0,int val_l0,int val_b0){ //ID-virtualNode@#al=0#t0=6#gas0=234#... Serial.print(id);Serial.print("@#");Serial.print("al=");Serial.print(al);

Serial.print("#t0=");Serial.print(val_t0); Serial.print("#h0=");Serial.print(val_h0); Serial.print("#l0=");Serial.print(val_l0); Serial.print("#b0=");Serial.print(val_b0); Serial.println("#r");// fi del missatge}void setup() {

Serial.begin(19200);pinMode(XBee_pin, OUTPUT);digitalWrite(XBee_pin,HIGH);

//Configuració Timer2: Timer Prescaler /1024TCCR2B |= ((1 << CS22) | (1 << CS21) | (1 << CS20));//Interrupció de desbordament del Timer2 ActivaTIMSK2 |= (1 << TOIE2);RESET_TIMER2;sei(); digitalWrite(XBee_pin, LOW);delay(20);val0 = analogRead(sens0);val1 = analogRead(sens1);val2 = analogRead(sens2);val3 = analogRead(sens3); sendData(id,al,val0,val1,val2,val3);digitalWrite(XBee_pin,HIGH); }void sleepNow()// Aquí posem el Aruino a dormir{/* Ara és el moment d'establir la manera de repòs. En el full de dades Atmega8* http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf a la pagina 35* No és una llista de maneres de repòs el que explica que els rellotges i* **Wake Up**Despertar les fonts estan disponibles en els que el Sleep es troben** En l'arxiu avr/sleep.h, els noms d'aquestes trucades modes somni es troben ** Les 5 maneres diferents:* SLEEP_MODE_IDLE -si més no l'estalvi d'energia * SLEEP_MODE_ADC* SLEEP_MODE_PWR_SAVE* SLEEP_MODE_STANDBY* SLEEP_MODE_PWR_DOWN -el major estalvi d'energia** Per ara, volem que l'estalvi d'energia tant com sigui possible, de manera que * Escollir * mode Sleep: SLEEP_MODE_PWR_DOWN** Timer 2 interrompre desbordament només és capaç de despertar xip en PWR_SAVE* */ set_sleep_mode(SLEEP_MODE_PWR_SAVE);// Mode d'espera s'estableix aquísleep_enable();// activa el bit de dormir en el registre mcucr // Pel que el somni és possible. Només un passador de seguretat. sleep_mode();// Aquí el dispositiu és realment posar a dormir!!// El PROGRAMA SEGUEIX D'AQUI després de despertar.sleep_disable();// El primer que després de despertar del Sleep:// Desactivar el Sleep...}void loop() { sleepNow();// No fer res, només el Sleep }

Descripción rápida (Gateway)

La “Gateway SquidBee USB” es el punt d'unió entre la xarxa sensorial formada per els dispositius SquidBee i un ordinador. Rep totes les dades rebudes per la xarxa i els envia al ordinador a traves del port USB per a poder visualitzar-los. Com alternativa, per la seva utilització en grans superficies es pot optar per el router Meshlium amb un mòdul ZigBee.

Passos a seguir en la creació de la Gateway de SquidBee.

Pas 1: La porta d'entrada (gateway) i SquidBee:

SquidBee es un dispositiu de maquinari obert (open hardware) i de sensors inalàmbrics. L'objectiu de SquidBee es aconseguir “mote obert” per a crear una xarxa de sensors inalàmbrics.

Els conceptes principals ja han estat comentats al principi d'aquest document.

Pas 2: Connexió d'entrada SquidBee al PC:

Instal·lació dels controladors: Els controladors es poden descarregar aqui http://www.ftdichip.com/Drivers/VCP.htm

Controladors VCP. Port COM virtual (VCP) dels connectors del dispositiu USB, per a que aparegui com un port COM més disponible per al PC. El programari d'aplicació pot accedir al dispositiu USB de la mateixa manera com ho faria a un port COM estàndar.

Aquest programari de l'empresa “Future Technology Devices International Limited “ no es cap garantia expressa. Ja que es un programari de codi obert i per tant modificable.Drivers FTDI es poden fer servir solament en combinació amb porductes a base de FTDI.Drivers FTDI poden esser distribuïts en qualsevol format i sempre que no es modifica la informació de la llicencia.

La comunicació amb XBee per a obtindre dades de les altres SquidBee's : Solament tens que connectar la porta d'enllaç de SquidBee ( gateway)al ordinador i

obrir un terminal del port serie. Configuració del port serie: 9600 baudios, 8 bits, sense paritat, 1 bit de parada.

Pas 3: Obtenció de dades:

Quan amb dos la “Gateway de SquidBee” i SquidBee estan llestos per a poder rebre i enviar dades al PC i els sensors a monitoritzar l'ambient. En tenim prou en encendre la caixa SquidBee i obtindrà

dades com les de l'imatge.

Matemàtiques per a obtindre els valors dels sensors:

Valor (en volts) d'una entrada analògica es---->V (volts) = analogRead(0) * 5 / 1024 Els Valors dels Sensors son:

Humidity (Humitat) : Humidity (%) is => H (%) = 32.25 V - 25.81 H(%) = (analogRead(0) * 5 / 1024.0) * 32.25 - 25.81 que coincideix amb : 0.8V => 0%

3.9V => 100% (mira figura).

Temperatura

LM35 Sensor de Temperatura proporciona 10 mV/ºC Temp (ºC) = V (volts) / 0.01 Temp (ºC) = (analogRead(0) * 5 / 1024.0) / 0.01

Llum

El Sensor de Llum es una LDR connectat a una resistència pull-up.

Per a poder calibrar en un 100% de llum (aprox.) i la foscor, tinc els següents valors de analogRead:

Fosc => 0 100% de llum (per una bombeta UV) => 950 Aixi que es pot estimar la llum (%) = (100 / 950) * analogRead ()

Pas 4: El codi de SquidBee:

El programa en el SquidBee es pot canviar facilment utilitzant el IDE Arduino , pots treure el Arduino Uno de la caixa, desconnectar la placa Xbee, i connectar el cable USB, i pots carregar un nou programa.Aquí està el programa d'Arduino que s'executa a la nostra SquidBee:

Código Arduino: /* * Copyright (C) 2007 Libelium Comunicaciones Distribuidas S.L. * http://www.libelium.com * * Aquest programa és de programari lliure: podeu redistribuir i/o modificar * Sota els termes de la llicència Pública General GNU segon el publicat per * La Free Software Foundation, versió 2 de la llicència, o * (A la seva elecció) qualsevol versió posterior. * * Aquest programa es distribueix amb l'esperança de ser util, * * Però sense cap garantia, fins i tot sense garantia implica res * * O no estar preparat per a ús particular. Veure la * GNU General Public License per a mes detalls. * * Vostè ha d'haver rebut una còpia de la GNU. * Si no es aixi consulteu http://www.gnu.org/licenses/. * * SquidBee codi * Version 0.1 * */ // Declaració variables //sensors int sens0 = 0; // Sensor de Llum int sens1 = 1; // Sensor de Humitat.

int sens2 = 2; // Sensor de temperatura //aux var int val0 = 0; int val1 = 0; int val2 = 0; int count = 0; void setup(){ Serial.begin(19200); // Inicia el port serie } // Funció per enviar les dades void sendData(int id,int num, int data0,int data1,int data2){ Serial.print("@"); Serial.print(id); Serial.print("|"); Serial.print(num); Serial.print("|data0-"); Serial.print(data0); Serial.print("|data1-"); Serial.print(data1); Serial.print("|data2-"); Serial.print(data2); Serial.println("#\r"); // final del missatge } void loop(){ while (count <= 10000){ val0 = analogRead(sens0); val1 = analogRead(sens1); val2 = analogRead(sens2); sendData(1,count, val0,val1,val2); delay(5000); count++; } count = 0; }