Click through the break for information on the setup and source code to get the Arduino Fio onto the web.

The project uses an Arduino Fio as the microcontroller, a Microchip RN171XV wifi module to connect to the internet (hereafter described using the old part name, RN-XV), and a Mini12864 graphical LCD to show debug information. Here’s a part list for this project (assuming you already have a USB -> Micro USB cable):

• Arduino Fio (available on Amazon & Sparkfun)
• Mini12864 graphical LCD (available on Amazon & DX)
• Microchip RN171XV/Roving Networks RN-XV (available on Amazon & Sparkfun)
• XBee USB adapter – for programming RN-XV (available on Amazon, DX, & SparkFun)
• FTDI 3.3V USB cable – for programming Fio (available on Amazon, DX, & SparkFun)

Want to make it completely wireless? I also used a Lithium Ion Polymer battery (available at Sparkfun).

When you first get the RN-XV, it needs to be updated to the latest firmware. First, it needs to be plugged into the XBee USB adapter and connected to your computer. These days, I’m working on a Mac, so I use CoolTerm to communicate with the RN-XV. Here are the settings (basically 9600 baud serial communication):

Then the RN-XV needs to be connected to your wireless access point and updated. Type in $$$ to enter the command mode and you should see the RN-XV respond CMD. You can then enter the commands one by one (carriage returns after each line) to connect the RN-XV to your WiFi access point. Here is my basic setup (see the RN-XV datasheet for additional information):

[code lang=”text”]
factory RESET
reboot
set wlan auth 4
set wlan ssid XXXX
set wlan phrase XXXX
set wlan join 1
save
reboot
[/code]

The RN-XV should associate (connect) with your wifi network and then you can test the connectivity by pinging the Microchip FTP server:

[code lang=”text”]
ping 198.175.253.161 10
[/code]

Then, update the RN-XV to the latest firmware (4.00.1 as of this article’s publish date):

[code lang=”text”]
set ftp address 198.175.253.161
set ftp user roving
set ftp pass Pass123
save
ftp update
[/code]

Once the update downloads, you can reset the factory defaults and reboot:

[code lang=”text”]
factory RESET
reboot
[/code]

After the RN-XV resets, you should again enter the basic setup information to get the RN-XV connected to your WiFi access point (see above). If all works out, then you can disconnect the serial port and pull the RN-XV out of the XBee adapter for the time being (don’t put it into the Arduino Fio, because the Fio needs to be programmed and the TX/RX lines are shared on the board).

I found a wonderful Arduino library for the RN-XV called WiFlyHQ by harlequin-tech. The author includes a number of great examples, including a HTTP client, HTTP server, TCP client, UDP client, and web socket client. Using the basic setup code in the HTTP client example, I added code from my previous Arduino FIO Graphical LCD Console to make a simple “clock” that updates approximately every 3 seconds using the time-c.nist.gov time server. I used the console code because it allows for very simple debug printing (since the Fio’s serial TX/RX pins are shared with the XBee socket). Here an admittedly boring short video illustrating the “clock” being startup and allowed to run (the value on the far left is an indicator of the wireless signal strength, RSSI):

And finally, here’s the Arduino sketch:

More information on the project, a video of it in operation, and its code after the break.

A little while ago, I picked up an Arduino Fio (available on Amazon.com) and the mini12864 graphical LCD (available on dx.com & Amazon.com) for some microcontroller tinkering. It turned out that a great graphical LCD library was available — u8glib — that supports the mini12864’s controller (the UC1701).

Using u8glib, the Arduino and the GLCD communicate flawlessly. Thankfully, the mini12864 is 3.3V compatible, so there are no issues setting it up with the Arduino Fio and the simple SPI connection makes setup surprisingly easy. As mentioned, I was able to use u8glib to port my oscilloscope code from CCS C to the Arduino:

• Arduino FIO LCD Oscilloscope
• Arduino FIO 2 Channel LCD Oscilloscope

In addition to all of the functions u8glib provides, the library also comes with a nice little serial console/terminal demonstration program. The current u8glib console code can be found here.

I added four functions that would allow me to quickly and easily debug my applications u8g_print, u8g_println, u8g_print_P, and u8g_println_P. u8g_print allows one to print a character array, u8g_println does the same, but then adds a new line to the end of the string, u8g_print_P allows you to print a character array saved in program memory, and u8g_println_P does the same but adds a new line. Here are the new functions:

This allowed me to create this simple demo of the GLCD debug console code:

And last but not least, here is the Arduino Sketch used to produce the above output:

Here’s a short demonstration video of the new two channel project:

Click through the break to check out the code.

The project used an Arduino Fio (available on Amazon.com) and the mini12864 128×64 pixel graphical LCD (available on dx.com & Amazon.com).

The basic modification was to include a second set of variables that is used to store the second channel’s readings. A more elegant solution would have been to make each variable an N-channel array (so that one could easily scale to more channels), but the low-resolution monochrome display really limits the possibilities, unfortunately. In addition, the sampling rate for the single channel oscilloscope was already quite low (with a maximum sampling rate of approximately 28kHz), but two channels could allow for some interesting possibilities as long as one can deal with the slower acquisition speed.

The display refresh is triggered by a rising signal (useThreshold == 1) on the channel A input (analog pin 7, as defined by theAnalogPinA = 7), but you could easily modify the code to make this switchable so that either channel acts as the trigger. The code is very similar to my previous code, including the serial port parameter controls, so I recommend taking a look at that post first, if you have any questions: Arduino FIO LCD Oscilloscope

As with the previous single channel project, you need to make sure that you have the u8glib library installed to compile the code.

Here’s the Arduino sketch for the oscilloscope:

Here’s a short teaser video just to show that, yes, it works (going through a couple different sine wave frequencies, some random noise, etc. just to illustrate it working):

Click through the break to get more information on the setup.

I used an Arduino Fio board that I picked up from SparkFun.com (available at Amazon.com) and a small SPI graphical LCD board that I picked up for a few bucks at dx.com (SKU 153821, also apparently available at Amazon.com). Since I don’t have a soldering iron here, I had to improvise with some female to female cables, also purchased from dx.com (SKU 151650).

Dx.com describes the LCD as a 5V module, but the GLCD board designer’s page (mini12864) states otherwise (translated from Chinese via Google Translate):

Dimensions (L × W × H): 47mm × 38mm × 6mm (excluding pins)
LCD sight (L × W): 33.7mm × 33.5mm
LCD Active Display Area (L × W): 30.7mm × 23mm
Backlight: White LED backlight bracket
Operating voltage: 3.3V ~ 5.5V (built-in booster circuit, without pressure)
Control IC: UC1701
Display format: 128 × 64 rows
Display: Blue on White

(mini12864 datasheet)

So, I ordered one of the graphical LCDs, waited a few weeks for delivery (because dx.com is a notoriously slow shipper), received it, hooked it up, and tried out the following simple “Hello World” script to confirm that that the GLCD/FIO combo functioned:

And it worked!

Thankfully, the code I previously posted was written in C, so porting to the Arduino took only a few minutes. I took advantage of a great open source graphical LCD library (u8glib) to handle the brunt of the work and added a serial port menu for manipulating the various display parameters. One important difference between this project and the previous one: Since the Arduino Fio is a 3.3V device, it can only handle 0-3.3V inputs, limiting its utility as an “oscilloscope” without proper input protection/voltage scaling. However, the code is extremely portable, meaning that you should be able to program any other Arduino and have it up-and-running in no time.

Here’s another 2 videos of the oscilloscope in action:

And finally, here’s the Arduino sketch for the oscilloscope:

Here’s the Arduino sketch for the square wave generator shown in the second video:

These temperature sensors are much more accurate out-of-the-box, so I don’t need to deal with calibration (which I did need to worry about with the internal thermometer). In addition, using separate, discrete components allows for the possibility of putting temperature sensors directly on/in whatever you may want to measure (rather than merely measuring the ambient temperature) and the potential for multiple temperature sensors with a single Arduino Fio (which are available at Amazon.com).

So, the most important addition is the Arduino OneWire.h library. Once we have that, all that’s needed is two simple declarations:

[code lang=”arduino”]
#include <OneWire.h> // Get here: http://www.arduino.cc/playground/Learning/OneWire
OneWire ds(DS18B20Data);
[/code]

And a modified readTemp function:

[code lang=”arduino”]
// See: http://www.arduino.cc/playground/Learning/OneWire
float readTempDS18B20() {
int HighByte, LowByte, TReading, SignBit, Tc_100;
byte i;
byte present = 0;
byte data[12];
byte addr[8];
float resultTempFloat;

digitalWrite(DS18B20Power,HIGH); // Power up the DS18B20
delay(250);

ds.search(addr);
if ( OneWire::crc8( addr, 7) != addr[7]) {
return 0.0; // CRC is not valid!
}

ds.reset();
ds.select(addr);
ds.write(0x44,1); // Start conversion, with parasite power on at the end

delay(1000); // Maybe 750ms is enough, maybe not
// We might do a ds.depower() here,
// but the reset will take care of it.

present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad

for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
LowByte = data[0];
HighByte = data[1];
TReading = (HighByte << 8) + LowByte;
SignBit = TReading & 0x8000; // Test most sig bit
if (SignBit) // Negative
{
TReading = (TReading ^ 0xffff) + 1; // Take 2’s comp
}

ds.reset_search();
digitalWrite(DS18B20Power,LOW); // Turn off DS18B20

resultTempFloat = (float) (6 * TReading) + TReading / 4; // Multiply by (100 * 0.0625) or 6.25
resultTempFloat = resultTempFloat/100;
resultTempFloat = resultTempFloat * 1.8 + 32.0; // Convert to F
return resultTempFloat;
}
[/code]

And we are ready to read! Note that the measurement times are a bit longer (I measured ~75 seconds in between transmissions) because of the 1 second settling time for the DS18B20. Here is some example output from TeraTerm (I measured the ambient temperature for measurements 1-10, then put my thumb onto the DS18B20 for measurements 11 & 12, and then allowed the DS18B20 to return to ambient for readings 13-20):

[code gutter=”false”]
ƒƒª 0 0 0
~
Aª 1 3.303 71.70
~
Aª 2 3.303 71.14
~
@ª 3 3.303 71.22
~
@ª 4 3.303 71.07
~
?ª 5 3.303 71.30
~
@ª 6 3.303 70.95
~
@ª 7 3.303 71.26
~
?ª 8 3.303 71.60
~
?ª 9 3.303 71.35
~
0ª 10 3.303 71.01
~
7ª 11 3.303 77.35
~
6ª 12 3.303 77.35
~
Aª 13 3.303 73.72
~
Aª 14 3.303 72.14
~
Aª 15 3.303 71.66
~
Aª 16 3.303 71.49
~
Aª 17 3.303 71.27
~
Aª 18 3.303 71.40
~
Aª 19 3.303 71.23
~
Aª 20 3.303 70.91
[/code]

I stored the data for another 40 readings, cut out all of the trash data between the carriage returns (deliminating the readings) and sync characters (which visually show up as “ª” in TeraTerm), removed the initial sync reading, and plotted the temperature data in Mathematica (voltage was constant):

Compare to the temperature results of the Arduino Fio internal temperature sensor:

Here’s all of the Arduino Fio SuperSleepyDS18B20 code:

[code lang=”arduino”]
/*
* SuperSleepyDS18B20 SuperSleepyDS18B20.ino
* Steven A Cholewiak – www.semifluid.com
*
* This sketch takes advantage of the XBee’s hibernation mode as
* well as the Ardunio Fio’s Power Save Mode to grossly reduce power
* consumption. It impliments a temperature logging IC (DS18B20)
* That has been connected to D3,D4,D5. Provides a much more
* accurate temperature measurement than the internal thermometer
* (see SuperSleepyTempAndVolts.ino).
*
*/

#include <avr/wdt.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <OneWire.h> // Get here: http://www.arduino.cc/playground/Learning/OneWire

const int ledPin = 13;
const int DS18B20Ground = 3; // DS18B20 Pin 1
const int DS18B20Data = 4; // DS18B20 Pin 2 NOTE: 4.7k pull-up resistor required between data and power
const int DS18B20Power = 5; // DS18B20 Pin 3
const int XBeeSleep = 2; // Connect to XBee DTR
const int waitPeriod = 8; // Number of 8 second cycles before waking
// up XBee and sending data (8*8 = 64 seconds)

OneWire ds(DS18B20Data); // Setup DS18S20 Temperature chip I/O

// See: http://code.google.com/p/tinkerit/wiki/SecretVoltmeter
float readVcc() {
signed long resultVcc;
float resultVccFloat;
// Read 1.1V reference against AVcc
ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
delay(10); // Wait for Vref to settle
ADCSRA |= _BV(ADSC); // Convert
while (bit_is_set(ADCSRA,ADSC));
resultVcc = ADCL;
resultVcc |= ADCH<<8;
resultVcc = 1126400L / resultVcc; // Back-calculate AVcc in mV
resultVccFloat = (float) resultVcc / 1000.0; // Convert to Float
return resultVccFloat;
}

// See: http://www.arduino.cc/playground/Learning/OneWire
float readTempDS18B20() {
int HighByte, LowByte, TReading, SignBit, Tc_100;
byte i;
byte present = 0;
byte data[12];
byte addr[8];
float resultTempFloat;

digitalWrite(DS18B20Power,HIGH); // Power up the DS18B20
delay(250);

ds.search(addr);
if ( OneWire::crc8( addr, 7) != addr[7]) {
return 0.0; // CRC is not valid!
}

ds.reset();
ds.select(addr);
ds.write(0x44,1); // Start conversion, with parasite power on at the end

delay(1000); // Maybe 750ms is enough, maybe not
// We might do a ds.depower() here,
// but the reset will take care of it.

present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad

for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
}
LowByte = data[0];
HighByte = data[1];
TReading = (HighByte << 8) + LowByte;
SignBit = TReading & 0x8000; // Test most sig bit
if (SignBit) // Negative
{
TReading = (TReading ^ 0xffff) + 1; // Take 2’s comp
}

ds.reset_search();
digitalWrite(DS18B20Power,LOW); // Turn off DS18B20

resultTempFloat = (float) (6 * TReading) + TReading / 4; // Multiply by (100 * 0.0625) or 6.25
resultTempFloat = resultTempFloat/100;
resultTempFloat = resultTempFloat * 1.8 + 32.0; // Convert to F
return resultTempFloat;
}

void sleepNow()
{
/* Now is the time to set the sleep mode. In the Atmega8 datasheet
* http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf on page 35
* there is a list of sleep modes which explains which clocks and
* wake up sources are available in which sleep modus.
*
* In the avr/sleep.h file, the call names of these sleep modus are to be found:
*
* The 5 different modes are:
* SLEEP_MODE_IDLE -the least power savings
* SLEEP_MODE_ADC
* SLEEP_MODE_PWR_SAVE
* SLEEP_MODE_STANDBY
* SLEEP_MODE_PWR_DOWN -the most power savings
*
* the power reduction management <avr/power.h> is described in
* http://www.nongnu.org/avr-libc/user-manual/group__avr__power.html
*/

set_sleep_mode(SLEEP_MODE_PWR_SAVE); // Sleep mode is set here

sleep_enable(); // Enables the sleep bit in the mcucr register
// so sleep is possible. just a safety pin
sleep_mode(); // Here the device is actually put to sleep!!
// THE PROGRAM CONTINUES FROM HERE AFTER WAKING UP
sleep_disable(); // Dirst thing after waking from sleep:
// disable sleep…
}

ISR (WDT_vect) { // WDT Wakeup
cli();
wdt_disable();
sei();
}

// Variable Definition
volatile int MeasurementID = 1;
volatile int timeKeeper = 0;
volatile float averageVcc = 0.0;
volatile float averageTemp = 0.0;

void setup(void) {
Serial.begin(57600);
pinMode(DS18B20Ground, OUTPUT);
digitalWrite(DS18B20Ground, 0); // Ground the DS18B20 GND pin
pinMode(XBeeSleep, OUTPUT);

digitalWrite(XBeeSleep, 0); // Enable XBee
digitalWrite(ledPin, 1); // Turn on Notification LED
delay(4000); // 4 second LED blink, good for wireless programming
digitalWrite(ledPin, 0); // Turn off Notification LED

Serial.write( 170 ); // Sync Byte
Serial.print( ‘\t’ ); // Tab
Serial.print( ‘0’ ); // Reading # (0)
Serial.print( ‘\t’ ); // Tab
Serial.print( ‘0’ ); // Voltage (unmeasured, so 0)
Serial.print( ‘\t’ ); // Tab
Serial.println( ‘0’ ); // Temperature (unmeasured, so 0)

digitalWrite(XBeeSleep, 1); // Disable XBee
}

void loop(void) {
averageVcc = averageVcc + (float) readVcc();
averageTemp = averageTemp + (float) readTempDS18B20();

if (timeKeeper == (waitPeriod-1)) { // Transmit every 8*8 (64) seconds
digitalWrite(XBeeSleep, 0); // Enable XBee
delay(50); // Wait for XBee Wakeup

Serial.write( 170 );               // Sync Byte
Serial.print( '\t' );
Serial.print( MeasurementID, DEC );
Serial.print( '\t' );
Serial.print( (float) (averageVcc/waitPeriod) , 3);
Serial.print( '\t' );
Serial.println( (float) (averageTemp/waitPeriod) , 2);
MeasurementID++;

digitalWrite(ledPin, 1);           // Turn on Notification LED
delay(50);                         // Blink LED
digitalWrite(ledPin, 0);           // Turn off Notification LED

digitalWrite(XBeeSleep, 1);        // Disable XBee

averageVcc = 0;                    // Reset voltage for new measurements
averageTemp = 0;                   // Reset temperature for new measurements
timeKeeper = 0;

} else { // Add a reading to the average
digitalWrite(ledPin, 1); // Turn on Notification LED
delay(1); // Blink LED very quickly
digitalWrite(ledPin, 0); // Turn off Notification LED

timeKeeper++;

}

wdt_reset(); // Get ready to go to sleep…
watchdogEnable(); // Turn on the watchdog timer
sleepNow(); // Go to sleep, watchdog timer will wake later
}

void watchdogEnable() { // Turn on watchdog timer; interrupt mode every 8.0s
cli();
MCUSR = 0;
WDTCSR |= B00011000;
//WDTCSR = B01000111; // 2 Second Timeout
//WDTCSR = B01100000; // 4 Second Timeout
WDTCSR = B01100001; // 8 Second Timeout
sei();
}
[/code]

So, taking advantage of the available hardware and the code available, I went about creating a wireless temperature logger using an Arduino Fio (available from Amazon.com) and two XBees (one for the Fio and one for the coordinator).

I already have code for a very low power logger setup that takes advantage of the Arduino Fio’s sleep mode as well as the XBee’s hibernation mode (see here).  So, all I needed to do was to add the thermometer and voltmeter code that tinkerit documented.

Here is their internal thermometer example code:

I modified the readTemp() function so that it returned a “human-readable” float in Fahrenheit (my local method of measuring temperature). In addition, I added a small calculation to return a more accurate temperature (calibrated against a thermometer at my house). If you want to calibrate the internal thermometer, put the Arduino Fio into a glass of ice water (I recommend putting it into a plastic bag and vacuuming out as much air as possible!), measure the values it returns, then put it into a cup of hot water, of known temperature, and measure the values it returns. It would be best to have multiple measurements along a series of temperatures, confirmed with a pre-calibrated thermometer (i.e., mercury thermometer). After making the measurements, you can fit a linear model (i.e., best fit line) to the data to get the slope and y-intercept for your device.

I also added their internal voltmeter example code:

The only modification was to convert the decimal to a float for (again) human readable format:

And last, but not least, I’ve been finding “trash data” that can be transmitted when the XBee is woken from hibernation, so I added a sync byte (DEC 170), that allows for easier parsing of the data. Here is some example output from TeraTerm (I measured the ambient temperature for measurements 1-10, then put my thumb onto the ATmega328P for measurements 11 & 12, and then allowed the Arduino to return to ambient for readings 13-20):

[code gutter=”false”]
ª 0 0 0
~
?ª 1 3.303 69.83
~
?ª 2 3.303 69.62
~
?ª 3 3.303 69.62
~
@ª 4 3.303 69.41
~
?ª 5 3.303 69.41
~
?ª 6 3.303 69.83
~
?ª 7 3.303 69.41
~
?ª 8 3.303 68.78
~
?ª 9 3.303 69.20
~
#ª 10 3.303 69.20
~
Ի 11 3.303 72.35
~
(ª 12 3.303 72.77
~
#ª 13 3.303 72.14
~
>ª 14 3.303 72.35
~
?ª 15 3.303 70.88
~
>ª 16 3.303 70.25
~
>ª 17 3.303 69.62
~
>ª 18 3.303 69.41
~
>ª 19 3.303 69.41
~
>ª 20 3.303 68.36
[/code]

Yes, I have poor circulation in my hands (hence only a 3 degree jump). I stored the data for another 30 readings, cut out all of the trash data between the carriage returns (deliminating the readings) and sync characters (which visually show up as “ª” in TeraTerm), removed the initial sync reading, and plotted the temperature data in Mathematica (voltage was constant for the ~50 minutes while I wrote this post):

Nice!

Here’s all of the Arduino Fio SuperSleepyTempAndVolts code:

As my free hobby time has dwindled, so has the time I’ve been able to devote to debugging programs written for my little Microchip PICs.  So, given my limited time, I decided to dive right into Arduinos — which utilize a higher-level programming language, making things a little quicker and easier for me to tinker — and try to get some wireless communication working.  After looking through the possibilities, I settled on the Arduino Fio.  The Arduino Fio is a great little Arduino-compatible board that includes a socket for an XBee 802.15.4 wireless module along with a LiPo plug and charger circuit.

I picked up a pair of Arduino Fios from sparkfun.com (my older revision was recently updated with a newer battery charging IC), along with an XBee Explorer USB (to directly interface/program the XBee modules with my desktop computer) and 3 XBee XB24-AWI-001 modules (XBee 802.15.4 low-power modules with wire antennas).

I may go into a bit more “nitty-gritty detail” for this post, but this is partially because I wanted to recreate all of the steps for this blog post (since I actually last worked on this about a year ago).  After receiving all of the components in the mail, I first updated XBee firmware using X-CTU to 17ED using the firmware image from digi.com, xb24_15_4_10ed.zip (available here: ftp://ftp1.digi.com/support/firmware/update/xbee/).  Digi has some firmware upgrade instructions that spell everything out.

After pressing “Restore” in X-CTU, the baud rate is reverted to 9600. BD (Interface Data Rate) needed to be changed from “3 – 9600” to “6 – 57600” for use with the Arduino Fio.  Selecting “Always update firmware” and pressing “Write” updated the firmware and adjusted the baud rate.

I initially setup the programming and slave XBee modems using the funnel-1.0-r806 XBeeConfigTool available at http://funnel.cc/Hardware/FIO (direct link to the downloads here, after unzipping, the config tool is in “funnel-1.0-r806\tools\XBeeConfigTool\application.windows64\XBeeConfigTool.exe”).  Here are the specific settings for my setup of 3 XBees:

For the coordinator/programming XBee (X-CTU configuration profile):

• Mode: Programming radio
• Baud rate: 57600
• PAN ID (The ID of the network these two devices will share) = 8484
• MY ID (The unique ID of the device on the PAN network) = 0000
• DL ID (Destination Address, FFFF means broadcast to all) = FFFF

For the XBee slave 1 (X-CTU configuration profile):

• Mode: Arduino Fio radio
• Baud rate: 57600
• PAN ID (The ID of the network these two devices will share) = 8484
• MY ID (The unique ID of the device on the PAN network) = 0001
• DL ID (Destination Address, 0000 means send only to coordinator radio) = 0000

For the XBee slave 2 (X-CTU configuration profile):

• Mode: Arduino Fio radio
• Baud rate: 57600
• PAN ID (The ID of the network these two devices will share) = 8484
• MY ID (The unique ID of the device on the PAN network) = 0002

In order to use the XBEEs in low-power pin-controlled sleep mode, go into X-CTU and set SM (Sleep Mode) to “1 – PIN HIBERNATE”.  Here’s the relevant information from the XBee datasheet:

Pin Hibernate (SM = 1)

• Pin/Host-controlled
• Typical power-down current: < 10 µA (@3.0 VCC)
• Wake-up time: 13.2 msec

Pin Hibernate Mode minimizes quiescent power (power consumed when in a state of rest or inactivity). This mode is voltage level-activated; when Sleep_RQ (pin 9) is asserted, the module will
finish any transmit, receive or association activities, enter Idle Mode, and then enter a state of
sleep. The module will not respond to either serial or RF activity while in pin sleep.

To wake a sleeping module operating in Pin Hibernate Mode, de-assert Sleep_RQ (pin 9). The
module will wake when Sleep_RQ is de-asserted and is ready to transmit or receive when the CTS
line is low. When waking the module, the pin must be de-asserted at least two ‘byte times’ after
CTS goes low. This assures that there is time for the data to enter the DI buffer.

In addition, D3 (DIO3 Configuration) to “5 – DO HIGH” and IU (I/O Output Enable) to “0 – DISABLED”.  I’ve attached the X-CTU configuration profiles for each of the XBees above.  Now… onto the Arduino!

The DTR line on the Ardunio FIO is connected to pin 9 on the XBee (Sleep_RQ), so in order to take advantage of the pin hibernation, it needs to be pulled to ground and tied to the Arduino FIO D2  to control the XBee’s hibernation.  I soldered a header onto the CTS and DTR pins on the FIO, connected D2 to DTR using a wire and pulled the line to ground using a resistor:

Finally, I took advantage of the Ardunio power-save sleep mode of the ATmega328P to lower the power usage further (see the ATmega328P datasheet).  Here is some barebones code, where the Arduino puts the radio to sleep and wakes up every 8 seconds, checks if the timekeeper variable has hit 8, and, if so, transmits an increasing variable (MeasurementID). Basically, MeasurementID is transmitted every approximately 64 seconds.