Sparrow este o arhitectură de reţea wireless de senzori care a fost construită ca o platformă de cercetare pentru rețelele wireless de senzori, în special pentru a pune în practică tehnici de recoltare de energie. Acesta a fost, de asemenea, folosită pentru a implementa şi testa o serie de aplicaţii fără fir, inclusiv IEEE 802.15.4, 6LoWPAN şi reţele ZigBee. Arhitectura unui nod Sparrow este dată în figura de mai jos.

<imgcaption sparrow | Arhitectura nodului senzorial Sparrow> </imgcaption>

După cum se poate vedea din figură, în centrul nodului senzorial se află microcontroller-ul Atmega128RFA1.

Un microcontroller este un tip de circuit care integrează un microprocesor şi alte dispozitive periferice într-un singur chip punandu-se accent pe un cost redus de producţie şi consum redus de energie electrică. Principala diferenţă dintre un microcontroller (µC) şi un microprocesor (µP) o constituie faptul că un µC integrează memoria de program, memoria de date şi alte interfeţe de intrare-ieşire sau periferice.

Din cauza integrării unui număr mare de periferice şi a costului redus de producţie, un µC operează la frecvenţe reduse, în general la zeci sau sute de MHz. Cu toate acestea, microcontrollerele se pretează la o gamă variată de aplicaţii fiind folosite atât în mediul industrial cât şi în produse de larg consum, de la sisteme din industria aerospaţială până la telefoane mobile, cuptoare cu microunde şi jucării. Spre deosebire de µP microcontroller-ul execută un program încărcat pe acesta şi dedicat unei singure funcţionalităţi.

ATmega128RFA1 reprezintă un microcontroller cu o arhitectură pe 8 biţi. Ca urmare, registrele şi magistrala internă de date sunt pe 8 biţi. Totuşi, în codul C se pot folosi variabile întregi pe 32 de biţi şi chiar în virgulă mobilă. Compilatorul este cel care se ocupă de translatarea instrucţiunilor cu variabile pe 32 de biţi în cod asamblare care lucrează pe 8 biţi.

<imgcaption micro | Microcontroller-ul ATMega128RFA1> </imgcaption> Caracteristicile procesorului folosit în cadrul laboratorului - Atmega128RFA1:

• 128KB Flash, sau dimensiunea maximă a programului care poate fi scris in microcontroller
• 4KB EEPROM
• 16KB RAM
• transceiver radio IEEE 802.15.4 în banda de 2.4GHz încorporat
• frecvența maximă de lucru de 16Mhz
• tensiune de alimentare între 1.8 și 3.6V
• timere cu canale PWM multiple
• canale de ADC multiple, precizie de 10 biți (situate pe portul F)
• cinci porturi de I/O digitale (de la portul B la G)
• interfeţe seriale: USART, SPI, TWI (two-wire serial interface)
• interfaţă programare JTAG

Perifericele interne chip-ului pot fi accesate din exterior prin intermediul pinilor porturilor (cinci porturi B, D, E, F a câte 8 pini, respectiv portul G cu doar 6 pini), prezentați în figura de mai jos:

<imgcaption uc_ports | Porturile digitale de intrare/ieșire pentru ATMega128RFA1> </imgcaption>

Arduino este un proiect hardware open source bazat pe microcontroller-ele ATMEGA8 sau ATMEGA168, produse de Atmel. Poate fi folosit pentru a construi obiecte interactive, primind date de intrare de la o gamă variată de senzori şi controlând diverse periferice. Hardware-ul poate fi extins prin diverse module, ale căror scheme sunt publice, astfel încât pot fi la rândul lor extinse şi îmbunătăţite de utilizatori.

Mediul integrat de dezvoltare Arduino a fost proiectat astfel încât să fie uşor de folosit de oameni care nu au cunoştinţe avansate de hardware sau software. În acelaşi timp, Arduino IDE este suficient de flexibil pentru a putea fi folosit şi de utilizatorii avansaţi. Bazat pe mediul de dezvoltare Processing, Arduino IDE este open source şi poate fi extins prin librării C++. Nu în ultimul rând, Arduino IDE este disponibil în versiuni pentru Windows, Mac OS şi Linux, cross-platform-ul fiind unul dintre marile sale avantaje.

Sparrow este o arhitectură de reţea wireless de senzori care a fost construită ca o platformă de cercetare pentru rețelele wireless de senzori, în special pentru a pune în practică tehnici de recoltare de energie. Acesta a fost, de asemenea, folosită pentru a implementa şi testa o serie de aplicaţii fără fir, inclusiv IEEE 802.15.4, 6LoWPAN şi reţele ZigBee. Ajunse la a patra revizie, nodurile Sparrow v.4 integreaza un microcontroller low-power cu transceiver radio incorporat, pe frecventa de 2.4GHz. De asemenea, nodurile sunt dotate cu o unitate inertiala completa cu 9 grade de libertate, ce incorporeaza un accelerometru, un giroscop si un magnetometru pe trei axe. Capabilitatile senzoriale sunt extinse de senzorii de temperatura, umiditate, luminozitate, masurare a indicelui UV si a radiatiei incidente in spectrul IR, vizibil si UV precum si un barometru/altimetru de precizie.

<imgcaption sparrowv4 | Nodul senzorial Sparrow v4></imgcaption>

Step 1. Open the Arduino IDE Step 2. Go to File → Preferences Step 3. In the Additional Boards Manager URLs textbox add the following link: http://clkdiv8.com/download/package_clkdiv8pre_index.json

Step 4. Close the window by pressing OK Step 5. Go to Tools → Board → Boards Manager Step 6. Search “sparrow” Step 7. Hit Install Step 8. You're done!

After a successful install, you should be able to select a new board named Sparrow from the Tools>Board menu. Also select the appropriate COM port from the Tools>Port menu You're all set up!

Bootloader-ul folosit este aici. Pentru a îl scrie în memoria flash se poate folosi Flash Programmer-ul din AtmelStudio (Tools→Device Programming). Fusebits: EXT 0XFE, HI 0xD0, LO 0xF7

Microntrollerul ATMega128RFA1 oferă 6 porturi I/O, iar intern, fiecare port are asociat trei registre prin care utilizatorul poate controla la nivel de pin fluxul datelor: poate scrie sau citi date din portul respectiv. Aceste trei registre sunt:

DDRn - Data Direction Register în el se stabilește direcţia pinilor portului, dacă sunt de ieşire(1) sau de intrare(0) PORTn - se scriu date pt ieşire sau se activează rezistenţele de pull-up. PINn - se citesc date de pe portul respectiv n poate să fie A, B, C sau D în funcţie de portul selectat.

Exemplu:

• pe pinul 1 de pe portul B avem un led și pe pinul 2 avem un buton
• bitul cu indexul 1 (PB1) din registrul DDRB va fi 1
• bitul cu indexul 2 (PB2) din registrul DDRB va fi 0
• se va scrie 1/0 bitul 1 din registrul PORTB pentru aprinde/stinge ledul
• se va citi bitul 2 din registrul PINB pentru a verifica dacă butonul este apăsat sau nu

Descrierea detaliată porturilor şi registrelor corespunzătoare acestora se găseşte în datasheet-ul ATmega128RFA1, în capitolul I/O Ports.

Registrele DDRn, PORTn, PINn, precum şi registrele perifericelor nu fac parte din cele 32 de registre de uz general. Ele nu sunt folosite pentru stocarea datelor, ci au ca rol comunicarea cu perifericul corespunzător. Pentru a face accesul la acestea mai simplu, ele sunt mapate în memorie. Astfel, pentru a scrie o valoare într-un registru este necesar să se scrie valoarea la adresa de memorie corespunzătoare registrului. Adresele lor se pot vedea în datasheet, în capitolul Register Summary, iar în avr-libc sunt definite macrouri pentru fiecare dintre aceste adrese.

<tabcaption op_bytes|Lucrul cu bytes>

Byte |= (1 << Bit_index)

 Byte &= ~(1 << Bit_index) 

 Byte ^= (1 << Bit_index) 

 Byte & (1 << Bit_index) 

</tabcaption>

DDRB = 8;            // directia pinului 3 este de iesire <--- ASA NU
DDRB = (1<<3);       // nici așa, este hardcodat indexul pinului
DDRB |= (1<<PB3);     // ASA DA
DDRB &= ~(1<<PB3);   // directia pinului 3 devine de intrare

Vom testa un program care stinge și aprinde un LED la interval de 1000ms. Acest lucru se face modificând voltajul unuia din pinii microcontroller-ului, în cazul nostru pinul 5 din portul B.

void setup()                    // run once, when the sketch starts
{
  DDRB |= (1<<PB5);      // sets the digital pin PB5 as output
}
 
 
void loop()                     // run over and over again
{
  PORTB ^= (1<<PB5);            //toggles bit
  delay(1000);                  // waits for a second
}

În programul de mai sus se observă folosirea unor macrouri: DDRB și PORTB. Acestea sunt expandate de compilator în locația de memorie unde este mapat registrul de I/O respectiv.

Alternativ, puteți folosi funcțiile de bibliotecă Arduino:

/*
 * Blink
 *
 * The basic Arduino example.  Turns on an LED on for one second,
 * then off for one second, and so on...  We use pin 13 because,
 * depending on your Arduino board, it has either a built-in LED
 * or a built-in resistor so that you need only an LED.
 *
 * http://www.arduino.cc/en/Tutorial/Blink
 */
 
 
int ledPin = 11;                // LED (PB5) connected to digital pin 11
 
void setup()                    // run once, when the sketch starts
{
  pinMode(ledPin, OUTPUT);      // sets the digital pin as output
}
 
 
void loop()                     // run over and over again
{
  digitalWrite(ledPin, HIGH);   // sets the LED off (reverse logic)
  delay(1000);                  // waits for a second
  digitalWrite(ledPin, LOW);    // sets the LED on
  delay(1000);                  // waits for a second
}

Pentru a compila şi executa codul de mai jos pe un nod Sparrow folosind Arduino IDE paşii sunt următorii:

1. Se creează un proiect nou şi se copiază codul de mai jos (File→New);
2. În Tools→Board selectaţi Sparrow;
3. Se alege portul COM la care a fost conectat nodul din Tools→Serial Port;
4. Se încarcă proiectul, folosind butonul de Upload.

<imgcaption leds | LED-urile de pe Sparrow V4></imgcaption> <tabcaption led_bytes|Pin-out leduri>

</tabcaption>

Câteodată trebuie să executăm două acțiuni în paralel. De exemplu, putem să facem un LED să clipească în timp ce interogăm un senzor de efracție. În acest caz nu putem să folosim delay() pentru că am opri întreaga execuție a programului timp de o secundă și programul ar putea să rateze detecția unui eveniment de la senzor. Sketch-ul de mai jos demonstrează cum putem să realizăm aceste task-uri fără a folosi delay(). Programul contorizează numărul de intervale de timp de când starea LED-ului a fost schimbată și modifică starea LED-ului atunci când expiră un anumit număr de intervale de timp.

Codul de mai jos folosește funcția millis() ce returnează numărul de milisecunde ce au trecut de la lansarea în execuție a programului.

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated
 
// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long interval = 1000;           // interval at which to blink (milliseconds)
 
void setup() {
  // set the digital pin as output:
  DDRB |= (1<<PB5);      
}
 
void loop()
{
  // here is where you'd put code that needs to be running all the time.
 
  // check to see if it's time to blink the LED; that is, if the
  // difference between the current time and last time you blinked
  // the LED is bigger than the interval at which you want to
  // blink the LED.
  unsigned long currentMillis = millis();
 
  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;  
 
    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
    {
        ledState = HIGH;
        PORTB |= 1<<PB5;
    }
    else
    {
      ledState = LOW;
      PORTB &= ~(1<<PB5);
    }
 
  }
}

Câteodată este foarte util ca nodul senzorial să comunice cu calculatorul de pe care este programat, pentru a trimite datele citite de la senzori sau ca modalitate facilă de debug pentru program.

Codul de mai jos inițializează interfața serială și trimite înapoi caracterele primite de la calculator.

/*
 Echo
 Reads data from serial, when available, and prints the result to the serial monitor 
 
 This example code is in the public domain.
 */
int incomingByte = 0;
 
void setup() {
  //start serial communication with a baud rate of 9600
  Serial.begin(9600);
}
 
void loop() {
  if(Serial.available() > 0) {
      //read the incoming byte
      incomingByte = Serial.read();
 
      //NOTE: the byte you sent from serial monitor is considered of type char
      //the value of the character '0' is 48 
      //by subtracting 48 from the value returned by the Serial.read() function you get  
      //the actual number you entered in serial monitor
      incomingByte = incomingByte - 48;
 
      //confirm the byte you just received
      Serial.print("I received ");
      Serial.println(incomingByte);
}
}

Pentru a putea măsura semnalele analogice într-un sistem de calcul digital, acestea trebuie convertite în valori numerice discrete. Un convertor analog – digital (ADC) este un circuit electronic care convertește o tensiune analogică de la intrare într-o valoare digitală.

Bibliotecile Arduino ne pun la dispoziție funcții dedicate pentru citirea intrărilor analogice. De exemplu, dacă dorim să măsurăm valoarea tensiunii de pe bateria nodului Sparrow, va trebui să citim intrarea analogică A0, la care este conectată bateria:

int controlPin = 7; //sensor ON/OFF control pin (PE7)
 
void setup() {
 
  pinMode(controlPin, OUTPUT);  //sensor on/off control
 
  // initialize the serial communication:
  Serial.begin(9600);
}
 
void loop() {
  digitalWrite(controlPin, LOW); //enable all sensors
 
  // wait a bit for the analog-to-digital converter
  // to stabilize after the last reading:
  delay(100);
 
  // send the value of analog input 0:
  Serial.println(analogRead(A0));
 
  digitalWrite(controlPin, HIGH); //disable all sensors
 
 
}

Si7021 este un senzor integrat pentru măsurarea temperaturii și a umidității ambientale produs de compania SiliconLabs. Avantajele acestuia față de senzorii similari sunt dimensiunile reduse (3mm x 3mm) și faptul că posedă o interfață digitală de comnicație a parametrilor măsurați. Circuitul este construit în tehnologie CMOS și încorporează un senzor capacitiv de umiditate precum și un senzor foarte precis de temperatură ce suferă un process de auto-calibrare la fiecare punere în funcțiune. Rezoluția parametrilor măsurați poate fi selectată din software între 8/12 biți pentru umiditate și 12/14 biți pentru temperatură. Comunicația cu microcontroller-ul se face peste o interfață standard I2C ce permite transferul rapid al datelor și al comenzilor.

<imgcaption humid | Senzorul de umiditate Si7021 și conectarea lui la microcontroller></imgcaption>

Pentru a citi date de la acest senzor s-au folosit fişierele sht2x.cpp si sht2x.h oferite ca suport în această arhivă. Dezarhivați conținutul în folder-ul Arduino\libraries

După aceşti paşi se va putea importa header-ul SHT2x.h în proiectul Arduino: #include “SHT2x.h”, aşa cum se va vedea în proiectul următor.

Notă: Dacă IDE-ul era pornit, va fi nevoie de un restart.

#include <Wire.h>
#include <SHT2x.h>
 
int controlPin 7;
 
void setup()
{
  pinMode(controlPin, OUTPUT);  //sensor on/off control
 
  Wire.begin();
  Serial.begin(9600);
}
 
void loop()
{
  digitalWrite(controlPin, LOW); //enable all sensors
 
  Serial.print("Humidity(%RH): ");
  Serial.print(SHT2x.GetHumidity());
  Serial.print("     Temperature(C): ");
  Serial.println(SHT2x.GetTemperature());
 
  digitalWrite(controlPin, HIGH); //disable all sensors
 
  delay(1000);
}

<imgcaption light | Senzorul de luminozitate Si1145 și conectarea lui la microcontroller></imgcaption>

Pentru a citi date de la acest senzor s-a folosit biblioteca Adafruit_SI1145. Dezarhivați conținutul aceste arhive în folder-ul Arduino\libraries

După aceşti paşi se va putea importa header-ul Adafruit_SI1145.h în proiectul Arduino: #include “Adafruit_SI1145.h”, aşa cum se va vedea în proiectul următor.

Notă: Dacă IDE-ul era pornit, va fi nevoie de un restart.

#include <Wire.h>
#include "Adafruit_SI1145.h"
 
int controlPin 7;
Adafruit_SI1145 uv = Adafruit_SI1145();
 
void setup() {
  pinMode(controlPin, OUTPUT);  //sensor on/off control
  delay(100);
 
  Serial.begin(9600);
 
  Serial.println("Adafruit SI1145 test");
 
  if (! uv.begin()) {
    Serial.println("Didn't find Si1145");
    while (1);
  }
 
  Serial.println("OK!");
}
 
void loop() {
 
  Serial.println("===================");
  Serial.print("Vis: "); Serial.println(uv.readVisible());
  Serial.print("IR: "); Serial.println(uv.readIR());
 
  // Uncomment if you have an IR LED attached to LED pin!
  //Serial.print("Prox: "); Serial.println(uv.readProx());
 
  float UVindex = uv.readUV();
  // the index is multiplied by 100 so to get the
  // integer index, divide by 100!
  UVindex /= 100.0;  
  Serial.print("UV: ");  Serial.println(UVindex);
 
  delay(1000);
}

<imgcaption IMU | Senzorul de inerțial LSM9DS0 și conectarea lui la microcontroller></imgcaption>

Pentru a citi date de la acest senzor s-a folosit biblioteca Sparkfun. Dezarhivați conținutul acestei arhive în folder-ul Arduino\libraries

După aceşti paşi puteți să deschideți și să rulați unul din exemplele care însoțesc biblioteca.

Pentru afișarea rapidă a datelor de la IMU, puteți folosi Processing sau puteți descărca o aplicație utilă de Serial Chart de aici. Configurația pentru ea o puteți deriva din acest tutorial.

Pe nod, va trebui să modificați exemplul de mai sus pentru a trimite datele în format CSV.

<imgcaption IMU_graph| Afișarea datelor de la accelerometru în fereastra SerialChart></imgcaption>

Notă: Dacă IDE-ul era pornit, va fi nevoie de un restart.

în exemplul de mai jos vom vedea cum putem să trimitem un octet de date de la placa Sparrow la PC și să afișam grafic rezultatul. Comunicația se va face peste interfața serială, dar datele vor fi preluate de către un alt program care va fi responsabil pentru desenarea graficului pe ecran.

Bineînțeles, puteți folosi Serial Monitor ca și până acum pentru a vizualiza datele în formă text, dar pentru a le afișa sub formă grafică avem nevoie de Processing. Puteți să descărcați programul de aici: http://processing.org/download/ Pur și simplu dezarhivați în directorul Arduino și rulați fișierul .exe

Încărcați următorul program pe placa Sparrow:

#include <Wire.h>
#include <SHT2x.h>
 
int controlPin = 7; //sensor ON/OFF control pin (PE7)
 
void setup() {
 
  pinMode(controlPin, OUTPUT);  //sensor on/off control
 
  // initialize the serial communication:
  Serial.begin(9600);
  Wire.begin();
}
 
void loop() {
  digitalWrite(controlPin, LOW); //enable all sensors
 
  // wait a bit for the analog-to-digital converter
  // to stabilize after the last reading:
  delay(100);
 
  // send the value from the temerature sensor:
  Serial.println(SHT2x.GetTemperature());
 
  digitalWrite(controlPin, HIGH); //disable all sensors
 
 
}

După cum puteți vedea, programul trimite pe serială datele citite de la senzorul de temperatură. Pentru a le afișa în mod grafic, încărcați următoarea schiță în Processing:

// Graphing sketch
 
 
 // This program takes ASCII-encoded strings
 // from the serial port at 9600 baud and graphs them. It expects values in the
 // range 0 to 1023, followed by a newline, or newline and carriage return
 
 // Created 20 Apr 2005
 // Updated 18 Jan 2008
 // by Tom Igoe
 // This example code is in the public domain.
 
 import processing.serial.*;
 
 Serial myPort;        // The serial port
 int xPos = 1;         // horizontal position of the graph
 
 void setup () {
 // set the window size:
 size(400, 300);        
 
 // List all the available serial ports
 println(Serial.list());
 // I know that the first port in the serial list on my mac
 // is always my  Arduino, so I open Serial.list()[0].
 // Open whatever port is the one you're using.
 myPort = new Serial(this, Serial.list()[3], 9600);
 // don't generate a serialEvent() unless you get a newline character:
 myPort.bufferUntil('\n');
 // set inital background:
 background(0);
 }
 void draw () {
 // everything happens in the serialEvent()
 }
 
 void serialEvent (Serial myPort) {
 // get the ASCII string:
 String inString = myPort.readStringUntil('\n');
 
 if (inString != null) {
 // trim off any whitespace:
 inString = trim(inString);
 // convert to an int and map to the screen height:
 float inByte = float(inString);
 inByte = map(inByte, 0, 1023, 0, height);
 
 // draw the line:
 stroke(127,34,255);
 line(xPos, height, xPos, height - inByte);
 
 // at the edge of the screen, go back to the beginning:
 if (xPos >= width) {
 xPos = 0;
 background(0);
 }
 else {
 // increment the horizontal position:
 xPos++;
 }
 }
 }
 
 
 
/* Max/MSP v5 patch for this example
 ----------begin_max5_patcher----------
1591.3oc0YszbaaCD9r7uBL5RalQUAO3CvdyS5zVenWZxs5NcfHgjPCIfJIT
RTxj+6AOHkoTDooroUs0AQPR73a+1cwtK3WtZxzEpOwqlB9YveAlL4KWMYh6
Q1GLo99ISKXeJMmU451zTUQAWpmNy+NM+SZ2y+sR1l02JuU9t0hJvFlNcMPy
dOuBv.U5Rgb0LPpRpYBooM3529latArTUVvzZdFPtsXAuDrrTU.f.sBffXxL
vGE50lIHkUVJXq3fRtdaoDvjYfbgjujaFJSCzq4.tLaN.bi1tJefWpqbO0uz
1IjIABoluxrJ1guxh2JfPO2B5zRNyBCLDFcqbwNvuv9fHCb8bvevyyEU2JKT
YhkBSWPAfq2TZ6YhqmuMUo0feUn+rYpY4YtY+cFw3lUJdCMYAapZqzwUHX8S
crjAd+SIOU6UBAwIygy.Q1+HAA1KH6EveWOFQlitUK92ehfal9kFhUxJ3tWc
sgpxadigWExbt1o7Ps5dk3yttivyg20W0VcSmg1G90qtx92rAZbH4ez.ruy1
nhmaDPidE07J+5n2sg6E6oKXxUSmc20o6E3SPRDbrkXnPGUYE.i5nCNB9TxQ
jG.G0kCTZtH88f07Rt0ZMMWUw8VvbKVAaTk6GyoraPdZff7rQTejBN54lgyv
HE0Ft7AvIvvgvIwO23jBdUkYOuSvIFSiNcjFhiSsUBwsUCh1AgfNSBAeNDBZ
DIDqY.f8.YjfjV1HAn9XDTxyNFYatVTkKx3kcK9GraZpI5jv7GOx+Z37Xh82
LSKHIDmDXaESoXRngIZQDKVkpxUkMCyXCQhcCK1z.G457gi3TzMz4RFD515F
G3bIQQwcP3SOF0zlkGhiCBQ1kOHHFFlXaEBQIQnCwv9QF1LxPZ.A4jR5cyQs
vbvHMJsLll01We+rE2LazX6zYmCraRrsPFwKg1ANBZFY.IAihr8Ox.aH0oAL
hB8nQVw0FSJiZeunOykbT6t3r.NP8.iL+bnwNiXuVMNJH9H9YCm89CFXPBER
bz422p8.O4dg6kRxdyjDqRwMIHTbT3QFLskxJ8tbmQK4tm0XGeZWF7wKKtYY
aTAF.XPNFaaQBinQMJ4QLF0aNHF0JtYuHSxoUZfZY6.UU2ejJTb8lQw8Fo5k
Rv6e2PI+fOM71o2ecY1VgTYdCSxxUqLokuYq9jYJi6lxPgD2NIPePLB0mwbG
YA9Rgxdiu1k5xiLlSU6JVnx6wzg3sYHwTesB8Z5D7RiGZpXyvDNJY.DQX3.H
hvmcUN4bP1yCkhpTle2P37jtBsKrLWcMScEmltOPv22ZfAqQAdKr9HzATQwZ
q18PrUGt6Tst2XMCRUfGuhXs6ccn23YloomMqcTiC5iMGPsHsHRWhWFlaenV
XcqwgCQiGGJzptyS2ZMODBz6fGza0bzmXBj7+DA94bvpR01MffAlueO7HwcI
pWCwmzJdvi9ILgflLAFmyXB6O7ML0YbD26lenmcGxjVsZUN+A6pUK7AtTrPg
M+eRYG0qD9j4I7eEbco8Xh6WcO.or9XDC6UCiewbXHkh6xm5LiPEkzpJDRTu
mEB44Fgz4NCtJvX.SM1vo2SlTCZGAe7GZu6ahdRyzFOhYZ+mbVVSYptBw.K1
tboIkatIA7c1cTKD1u.honLYV04VkluHsXe0szv9pQCE9Ro3jaVB1o15pz2X
zYoBvO5KXCAe0LCYJybE8ZODf4fV8t9qW0zYxq.YJfTosj1bv0xc.SaC0+AV
9V9L.KKyV3SyTcRtmzi6rO.O16USvts4B5xe9EymDvebK0eMfW6+NIsNlE2m
eqRyJ0utRq13+RjmqYKN1e.4d61jjdsauXe3.2p6jgi9hsNIv97CoyJ01xzl
c3ZhUCtSHx3UZgjoEJYqNY+hYs5zZQVFW19L3JDYaTlMLqAAt1G2yXlnFg9a
53L1FJVcv.cOX0dh7mCVGCLce7GFcQwDdH5Ta3nyAS0pQbHxegr+tGIZORgM
RnMj5vGl1Fs16drnk7Tf1XOLgv1n0d2iEsCxR.eQsNOZ4FGF7whofgfI3kES
1kCeOX5L2rifbdu0A9ae2X.V33B1Z+.Bj1FrP5iFrCYCG5EUWSG.hhunHJd.
HJ5hhnng3h9HPj4lud02.1bxGw.
-----------end_max5_patcher-----------
 
 */

La prima rulare vi se va afișa o listă cu porturi COM disponibile, aveți grijă să selectați portul pe care este conectată placa Sparrow. Pentru aceasta va trebui probabil să modificați programul de mai sus și să îl re-rulați.

Datele eșantionate de la senzorul de lumină ar trebui să fie vizibile în fereastra deschisă de către schița Processing.

<imgcaption processing | Graficul afișat de la senzor în fereastra Processing></imgcaption>

Pentru a folosi transceiver-ul radio cu care sunt dotate nodurile senzoriale, vom utiliza o bibliotecă scrisă pentru Arduino ce ne va simplifica foarte mult codul. Această bibliotecă se numește ZigduinoRadio și poate fi descărcată de aici.

Instalarea bibliotecii este foarte facilă, trebuie doar să dezarhivați arhiva în Arduino\libraries

Mai jos aveți un exemplu care vă permite să trimiteți și să recepționați date de pe interfața radio.

/*
 
Run this sketch on two Zigduinos, open the serial monitor at 9600 baud, and type in stuff
Watch the Rx Zigduino output what you've input into the serial port of the Tx Zigduino
 
*/
 
#include <ZigduinoRadio.h>
 
void setup()
{
  ZigduinoRadio.begin(11);
  Serial.begin(9600);
 
  ZigduinoRadio.attachError(errHandle);
  ZigduinoRadio.attachTxDone(onXmitDone);
}
 
void loop()
{
  if (Serial.available())
  {
    ZigduinoRadio.beginTransmission();
 
    Serial.println();
    Serial.print("Tx: ");
 
    while(Serial.available())
    {
      char c = Serial.read();
      Serial.write(c);
      ZigduinoRadio.write(c);
    }
 
    Serial.println(); 
 
    ZigduinoRadio.endTransmission();
  }
 
  if (ZigduinoRadio.available())
  {
    Serial.println();
    Serial.print("Rx: ");
 
    while(ZigduinoRadio.available())
      Serial.write(ZigduinoRadio.read());
 
    Serial.println();
    Serial.print("LQI: ");
    Serial.print(ZigduinoRadio.getLqi(), 10);
    Serial.print(", RSSI: ");
    Serial.print(ZigduinoRadio.getLastRssi(), 10);
    Serial.print(" dBm, ED: ");
    Serial.print(ZigduinoRadio.getLastEd(), 10);
    Serial.println("dBm");
  }
 
 
  delay(1000);
}
 
void errHandle(radio_error_t err)
{
  Serial.println();
  Serial.print("Error: ");
  Serial.print((uint8_t)err, 10);
  Serial.println();
}
 
void onXmitDone(radio_tx_done_t x)
{
  Serial.println();
  Serial.print("TxDone: ");
  Serial.print((uint8_t)x, 10);
  Serial.println();
}

Pentru lucrarea curentă de laborator veți folosi biblioteca ZigduinoTransfer ce folosește clasele definite în laboratorul anterior pentru transmisia radio. Clasa implementează un protocol peste functiile de transmisie și recepție obișnuite și poate fi descărcată de aici.

Instalarea bibliotecii este foarte facilă, trebuie doar să dezarhivați arhiva în Arduino\libraries

Mai jos aveți un exemplu care vă permite să trimiteți și să recepționați pachete de date de pe interfața radio. Pentru aceasta aveți nevoie de două noduri: primul rulează codul care transmite (Tx) și al doilea recepționează (Rx).

Codul pentru Transmitter:

#include <ZigduinoTransfer.h>
 
//create object
ZigduinoTransfer ET; 
 
struct SEND_DATA_STRUCTURE{
  //put your variable definitions here for the data you want to send
  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
  int blinks;
  int pause;
};
 
//give a name to the group of data
SEND_DATA_STRUCTURE mydata;
 
void setup(){
  Serial.begin(9600);
  //start the library, pass in the data details
  ET.begin(details(mydata));
 
  pinMode(11, OUTPUT);
 
 
 
}
 
void loop(){
  //this is how you access the variables. [name of the group].[variable name]
  mydata.blinks = 5;
  mydata.pause = 10;
  //send the data
  ET.sendData();
 
  //Just for fun, we will blink it out too
   for(int i = mydata.blinks; i>0; i--){
      digitalWrite(11, HIGH);
      delay(mydata.pause * 100);
      digitalWrite(11, LOW);
      delay(mydata.pause * 100);
    }
 
  delay(5000);
}

Codul pentru Receiver:

#include <ZigduinoTransfer.h>
 
//create object
ZigduinoTransfer ET; 
 
struct RECEIVE_DATA_STRUCTURE{
  //put your variable definitions here for the data you want to receive
  //THIS MUST BE EXACTLY THE SAME ON THE OTHER NODE!!!
  int blinks;
  int pause;
};
 
//give a name to the group of data
RECEIVE_DATA_STRUCTURE mydata;
 
void setup(){
  Serial.begin(9600);
  //start the library, pass in the data details  
  ET.begin(details(mydata));
 
  pinMode(11, OUTPUT);
 
}
 
void loop(){
  //check and see if a data packet has come in. 
  if(ET.receiveData()){
    //this is how you access the variables. [name of the group].[variable name]
    //since we have data, we will blink it out. 
    for(int i = mydata.blinks; i>0; i--){
      digitalWrite(11, HIGH);
      delay(mydata.pause * 100);
      digitalWrite(11, LOW);
      delay(mydata.pause * 100);
    }
  }
 
  //you should make this delay shorter than your transmit delay or else messages could be lost
  delay(250);
}