Seeeduino Stalker v1.0

This is not the latest version of Seeeduino Stalker and has been discontinued.
The latest version can be found here: Seeeduino Stalker v2.1
Look here for comparison between v1.0, v2.0 and v2.1.

Link to product page for this device (follow this link to buy):
Seeeduino Stalker Atmega 168P v1.0 Model: ARD125B5P

Seeeduino Stalker is a feature rich Arduino compatible Wireless Sensor Network node. It's modular structure and onboard peripherals makes it convenient to log time stamp sensor data on a periodic basis. The Seeeduino Stalker is a good candidate for all your tracking, monitoring and control projects.

Seeeduino Stalker v1.0

Features

• Arduino compatible, based on Seeeduino
• Onboard microcontroller: ATmega168P or ATmega328P (both variants available for purchase)
• Dual mode of operation: As a standalone Arduino or as a Shield stacked ontop of Arduino. (Pinheader locations are Arduino Duemilanove compatible)
• Onboard Real Time Clock chip with CR2032 coin cell as backup power source
• Serial interface with DTR for auto reset during programming when operating in standalone mode. (For programming, UartSBee must be bought separately)
• microSD card socket
• I2C Pin header (operation voltage is selectable: 5.0V or 3.3V)
• User defined switch and LED
• Bee series socket - 2*10 pin 2.0mm pitch (which will mate with - one at a time - any of the wireless modules: XBee, BluetoothBee, GPSBee or RFBee.) Please note that UartSBee is incompatible with this socket - a separate serial interface connector (as mentioned above) is provided for UartSBee

Applications

• Wireless Sensor Network (using XBee - bought seperately)
• GPS Logging (using GPSBee - bought seperately)
• Data Acquisition System capable of communicating with an App running on iPhone/Android Phone/Nokia Phone (using BluetoothBee - bought seperately)
• RF Remote Control (using RFBee - bought seperately)
• As a simple standalone Arduino compatible physical computing platform (UartSBee must be bought seperately for programming)

Cautions

• The product is provided as is. Please observe ESD precautions specially in dry (low humidity) weather.
• Please disable bluetooth serial ports when using a Windows based development machine to prevent the Arduino IDE from freezing.

Block Diagram

Schematics

Schematics for Seeeduino Stalker v1.0 (PDF)

Specifications

Key Technical Specifications

Electrical Characterstics

Usage

Application Notes

Connection Notes

• Bee series socket - 2*10 pin 2.0mm pitch (which will mate with - one at a time - any of the wireless modules: XBee, BluetoothBee, GPSBee or RFBee.) Communication with these modules are done through UART.
• Serial interface – To save space and lower costs, USB<->Serial connectivity is not provided by default. You may use the FT232 based UartSBee or other USB to serial adapter to do the programming or communicate with the PC.
• User LED and Switch – An LED and a Switch have been provided onboard for use in your application as desired.
• Master switch – Removes power from the Seeeduino Stalker board. RTC will remain working if a CR2032 battery has been installed.
• Interrupt Jumper – Mount this jumper if you want to allow the module inserted in the Bee series socket to interrupt the microcontroller on any data reception event. This is useful in sensor network application to wake up the microcontroller from sleep mode.
• I²C Interface: Onboard I²C level shifter IC provides voltage translation between 3.3V and 5V devices. This allows you to connect 5.0 Volt I² ICs to you microcontroller when its operating on 3.3 Volts.

Datasheets of Components

• ATmega168 - 8-bit AVR Microcontroller present onboard Seeeduino Stalker.
• PCA9306 - Dual bidirectional I²C-bus and SMBus voltage-level translator.
• DS1307 - I²C Real Time Clock chip.
• LM1117 - Low Drop Out linear voltage regulator used in the power supply section.

Source Code Examples

Programming Seeeduino Stalker is made easy through the use of Arduino and its libraries. A few code snippets provided below will help you kickstart the coding for your project. A RAR archive containing all of the following sketches is available here.

Please note that all of the Demo sketches presented below make use of the FileLogger library. Please refer to this thread at the Arduino Forum and download the library from its project page at Google Code.

Also, a few Seeeduino Stalker users have shared some of the code developed by them in a thread at the Arduino Forum.

Demo 1 - SD card usage

Using a FileLogger library to store all the data from GPSBee on to the SD Card.

#include <SD.h>
 
const int chipSelect = 10;
String buffer = "";
unsigned char ptr;
File myFile;
byte val;
void setup()
{
  Serial.begin(19200);
  pinMode(chipSelect,OUTPUT);
  if(!SD.begin(chipSelect))
  {
    return;
  }
  File myFile = SD.open("data.log",FILE_WRITE);
   myFile.close();
}
 
void loop()
{
  if(Serial.available() > 0)
  {
    val = Serial.read();
    buffer = String(val);
    myFile = SD.open("data.log",FILE_WRITE);
    myFile.print(buffer);
    myFile.close();
  }
}

Demo 2 – Logging timestamped sensor data

The onboard Real Time Clock module can be used for adding timestamp to the periodically read sensor data.
The Arduino sketch presented below illustrates how to take sensor readings from Analog Pin 0 and save it to SD Card along with timestamps.

#include "FileLogger.h"
#include "DS1307.h"
#include <WProgram.h>
#include <Wire.h>
 
#define Timing 0
#define Accept 1
#define Record 2
 
byte start[7]= { 'B','e','g','i','n',0x0D,0x0A};
byte buffer[20];
int temp;
byte ASCII[10]={'0','1','2','3','4','5','6','7','8','9'};
unsigned char result;
unsigned char state;
int time=0;
int oldtime=0;
 
 
void setup(void)
{
    result = FileLogger::append("data.log", start, 7);//Initial the SD Card
    while(result) result = FileLogger::append("data.log", start, 7);
    RTC.stop();
    RTC.set(DS1307_MIN,30); //set the minutes
    RTC.set(DS1307_HR,10); //set the hours
    RTC.set(DS1307_DATE,22); //set the date
    RTC.set(DS1307_MTH,12); //set the month
    RTC.set(DS1307_YR,9); //set the year
    RTC.start();
}
void loop(void)
{
    switch(state)
    {
        case Timing:
        time=RTC.get(DS1307_SEC,true);
        delay(200);
        if(time!=oldtime)
        {
            oldtime=time;
            temp=RTC.get(DS1307_MTH,false);
            buffer[0]=ASCII[(temp/10)];
            buffer[1]=ASCII[(temp%10)];
            buffer[2]='-';
            temp=RTC.get(DS1307_DATE,false);
            buffer[3]=ASCII[(temp/10)];
            buffer[4]=ASCII[(temp%10)];
            buffer[5]='-';
            temp=RTC.get(DS1307_HR,false);
            buffer[6]=ASCII[(temp/10)];
            buffer[7]=ASCII[(temp%10)];
            buffer[8]='-';
            temp=RTC.get(DS1307_MIN,false);
            buffer[9]=ASCII[(temp/10)];
            buffer[10]=ASCII[(temp%10)];
            buffer[11]='-';
            //temp=RTC.get(DS1307_SEC,false);
            buffer[12]=ASCII[(time/10)];
            buffer[13]=ASCII[(time%10)];
            buffer[14]=':';
            state=Accept;
        }
        break;
        case Accept:
        temp=analogRead(0);
        buffer[15]=ASCII[(temp/100)];
        buffer[16]=ASCII[((temp%100)/10)];
        buffer[17]=ASCII[(temp%10)];
        buffer[18]=0x0D;
        buffer[19]=0x0A;
        state=Record;
        break;
        case Record:
        result = FileLogger::append("data.log", buffer, 20);
        if (result==0)
        {
            state=Timing;
        }
        break;
        default:
        state=Timing;
        break;
    }
}

Demo 3 Operating the Seeeduino Stalker as a Shield

The Seeeduino Stalker can be mounted as a shield on another Arduino Duemilanove/UNO compatible board.
The following sketch illustrates how to receive data from the microcontroller below via I²C and save it onto the SD Card.

#include "FileLogger.h"
#include <Wire.h>
 
byte start[7]= { 'B','e','g','i','n',0x0D,0x0A};
unsigned char buffer[10];
unsigned char result;
unsigned char state;
 
void setup()
{
    result = FileLogger::append("data.log", start, 7);//Initial the SD Card
    while(result) result = FileLogger::append("data.log", start, 7);
    Wire.begin(4); // join i2c bus with address #4
    Wire.onReceive(receiveEvent); // register event
}
void loop()
{
}
void receiveEvent(int howMany)
{
    unsigned char i=0;
    while(Wire.available()>0)
    {
        buffer[i] = Wire.receive(); // receive byte as a character
        i++;
    }
    result = FileLogger::append("data.log", buffer, i);
    while(result) result = FileLogger::append("data.log", start, 7);
}

FAQ

Answers to questions asked about this product by its users are posted here

Support

If you have questions or other better design ideas, you can go to our forum or wish to discuss.

Revision History

Bug Tracker

Bug Tracker is the place you can publish any bugs you think you might have found during use. Please write down what you have to say, your answers will help us improve our products.

Additional Ideas

The Additional Ideas is the place to write your project ideas about this product, or other usages you've found. Or you can write them on Projects page.

Resources

Stalker Eagle Design Files

How to buy

Seeeduino Stalker v1.0 is already out of stock (Product page here), instead please checkout Seeeduino Stalker v2.0: Wiki page | Product Page

See Also

• Seeeduino Stalker v2.0
• Comparison between various versions of Seeeduino Stalker

Licensing

This documentation is licensed under the Creative Commons Attribution-ShareAlike License 3.0 Source code and libraries are licensed under GPL/LGPL, see source code files for details.

External Links

Links to external webpages which provide more application ideas, documents/datasheet or software libraries.

This static html page was created from http://www.seeedstudio.com/wiki