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.

Transmitter Circuit

The source and firmware for the transmitter circuit can be found at the bottom of the page. Each section of the circuit is labeled in the schematic. All of the sections and their components are described and discussed below. The part numbers for the components are linked to websites for data and more information when available.

Transmitter Power Supply

The power supply uses a 9 volt battery and a TC1264-3.0V high-accuracy low-dropout linear voltage regulator to provide a stable 3 volt supply for the microcontroller and the transceiver. An additional TC1262-5.0V high-accuracy low-dropout linear voltage regulator is used to provide a stable 5 volt supply for the accelerometers. 1uF (microFarad) polarized decoupling capacitors are necessary on the outputs of the voltage regulators to prevent spikes or ripples. A wall wart power supply as low as 5.3V can be substituted for the 9 Volt battery.

Transmitter Accelerometers

To sense the position of the board, I used 3 single axis accelerometers in an X-Y-Z configuration. I used two MMA2260D Low-G X-axis accelerometers and one MMA1260D Low-G Z-axis accelerometer. The two X-axis accelerometers were positioned in an X-Y configuration and the Z-axis accelerometer was used to sense gravity in the Z-direction. The resistors below the accelerometers are used as a voltage divider so that the PIC, which is running at 3V, can read the voltage, which will vary from 0V to 2.5V. With this configuration, for each accelerometer 1.85V is +1G, 1.25V is 0G, and 0.65V is -1G.

Transmitter RF-24G Transceiver

The Laipac TRW-24G 2.4GHz transceiver uses a Nordic Semiconductor nRF2401a transceiver chip and includes all of the necessary components. The TRW-24G (also called the RF-24G and TXRX24G) requires a 3 Volt power supply and 3 Volt logic, so running the transceiver at 5 volts is not a viable option. Information on the chip’s interface cam be found in the following data sheets:
– http://www.sparkfun.com/datasheets/RF/RF-24G_datasheet.pdf
– http://www.sparkfun.com/datasheets/RF/RF-24G.pdf
– http://www.sparkfun.com/datasheets/RF/nRF2401rev1_1.pdf

Transmitter Microcontroller

The microcontroller used was a Microchip PIC18LF2550. I modified the PIC18F2550 Tiny PIC Bootloader assembly file so I could use a 10MHz crystal/resonator at 57,600 baud (the modified bootloader can be found at the bottom of the page). The PIC18LF2550 runs at a maximum speed of 16MHz (4 MIPs) with a 3 Volt power supply; however, I had 10MHz and 20MHz ceramic resonators on-hand, so I ran at the fastest ‘safe’ speed possible (I could overclock the PIC by running it at 20MHz with a 3 volt supply, but it would be running out of spec. so it may not operate reliably). The firmware was written in C (using CCS PICC) and can be found at the bottom of the page, in addition to a generic RF-24G driver for Laipac TRW-24G 2.4GHz transceivers. R1 is a pull-up resistor necessary for operation. C1 is a stabilizing capacitor that is used for the onboard USB voltage regulator (which is not utilized in this project). The component marked ‘RES’ is a 10MHz resonator.

Transmitter RS232 Level Converter

The microcontroller USART pins need to be connected to a RS-232 Level Converter to connect to a PC for firmware updates using the Tiny PIC Bootloader. Otherwise, after initial programming they can be left disconnected.

Receiver Circuit

The circuit for the receiver is exactly the same as the circuit for the 2.4GHz Serial Link; however, the receiver code is different because it expects a 6-byte payload from the RF-24G. The source code for the receiver can be found below.

Source and Firmware

The PIC must initially programmed with the ‘SAC_tinybld18F2550_10MHz_57600’ hex file to program the bootloader on the PIC. Then, using Tiny PIC Bootloader, the hex files can be placed on the chips using the Tiny PIC Bootloader frontend with ’12h 34h 56h 78h 90h’ in the ‘List of codes to send first:’ in the ‘Options’ menu.
– SAC_tinybld18F2550_10MHz_57600.asm (hex)
– 18LF2550 RF-24G Accelerometer Transmitter.c (hex)
– 18LF2550 RF-24G Accelerometer Receiver.c (hex)
– RF-24G_6-byte.c

Receiver Circuit

The source and firmware for the receiver circuit can be found at the bottom of the page. Each section of the circuit is labeled in the schematic. All of the sections and their components are described and discussed below. The part numbers for the components are linked to websites for data and more information when available.

Receiver Power Supply

The power supply uses a 9 volt battery and a TC1264-3.0V high-accuracy low-dropout linear voltage regulator to provide a stable 3 volt supply for the microcontroller and the transceiver. An additional TC1262-5.0V high-accuracy low-dropout linear voltage regulator is used to provide a stable 5 volt supply for the servos. 1uF (microFarad) polarized decoupling capacitors are necessary on the outputs of the voltage regulators to prevent spikes or ripples. A wall wart power supply as low as 5.3V can be substituted for the 9 Volt battery.

Receiver Servos

I used two standard hobby servos that were bought on eBay. Any servos that conform to the standard RC servo control scheme can be used with this circuit.

Receiver RF-24G Transceiver

The Laipac TRW-24G 2.4GHz transceiver uses a Nordic Semiconductor nRF2401a transceiver chip and includes all of the necessary components. The TRW-24G (also called the RF-24G and TXRX24G) requires a 3 Volt power supply and 3 Volt logic, so running the transceiver at 5 volts is not a viable option. Information on the chip’s interface cam be found in the following data sheets:
– http://www.sparkfun.com/datasheets/RF/RF-24G_datasheet.pdf
– http://www.sparkfun.com/datasheets/RF/RF-24G.pdf
– http://www.sparkfun.com/datasheets/RF/nRF2401rev1_1.pdf
– https://www.sparkfun.com/datasheets/RF/RF-24G.pdf

Receiver Microcontroller

The microcontroller used was a Microchip PIC18LF2550. I modified the PIC18F2550 Tiny PIC Bootloader assembly file so I could use a 10MHz crystal/resonator at 57,600 baud (the modified bootloader can be found at the bottom of the page). The PIC18LF2550 runs at a maximum speed of 16MHz (4 MIPs) with a 3 Volt power supply; however, I had 10MHz and 20MHz ceramic resonators on-hand, so I ran at the fastest ‘safe’ speed possible (I could overclock the PIC by running it at 20MHz with a 3 volt supply, but it would be running out of spec. so it may not operate reliably). The firmware was written in C (using CCS PICC) and can be found at the bottom of the page, in addition to a generic RF-24G driver for Laipac TRW-24G 2.4GHz transceivers. R1 is a pull-up resistor necessary for operation. C1 is a stabilizing capacitor that is used for the onboard USB voltage regulator (which is not utilized in this project). The component marked ‘RES’ is a 10MHz resonator. The LED connected to pin C4 is used to indicate data reception and can be omitted if necessary (although it is helpful for debugging).

Receiver RS232 Level Converter

The microcontroller USART pins need to be connected to a RS-232 Level Converter to connect to a PC for firmware updates using the Tiny PIC Bootloader. Otherwise, after initial programming they can be left disconnected.

Transmitter Circuit

The circuit for the transmitter is exactly the same as the circuit for the 2.4GHz Serial Link; however, a custom firmware is used for the 2-byte payload of the RF-24G (1 byte for each servo). The firmware for the transmitter can be found below.

Source and Firmware

The PIC must initially programmed with the ‘SAC_tinybld18F2550_10MHz_57600’ hex file to program the bootloader on the PIC. Then, using Tiny PIC Bootloader, the hex files can be placed on the chips using the Tiny PIC Bootloader frontend with ’12h 34h 56h 78h 90h’ in the ‘List of codes to send first:’ in the ‘Options’ menu. Please feel free to contact me if you have any problems.
– SAC_tinybld18F2550_10MHz_57600.asm (hex)
– 18LF2550 RF-24G Serial Servo Transmitter.c (hex)
– 18LF2550 RF-24G Serial Servo Receiver.c (hex)
– RF-24G.c

Update – 02/28/2006

Here are two videos of my camera pan/tilt system under manual control: Manual Control. Here are two videos of my camera pan/tilt system under the control of a simple color tracking algorithm (which is configured to track the brightest red in the room): Color Tracking.

Full circuit

The source and firmware for the circuit can be found at the bottom of the page. Each section of the circuit is labeled in the schematic above. All of the sections and their components are described below. The part numbers for the components are linked to websites for data and more information when available.

Power Supply

The power supply uses a 9 volt battery and a TC1264-3.0V high-accuracy low-dropout linear voltage regulator to provide a stable 3 volt supply for the microcontroller and the transceiver. A 1uF (microFarad) polarized decoupling capacitor is necessary on the output of the voltage regulator to prevent spikes or ripples. A wall wart power supply as low as 3.3V can be substituted for the 9 Volt battery.

RF-24G Transceiver

The Laipac TRW-24G 2.4GHz transceiver uses a Nordic Semiconductor nRF2401a transceiver chip and includes all of the necessary components. The TRW-24G (also called the RF-24G and TXRX24G) requires a 3 Volt power supply and 3 Volt logic, so running the circuit at 5 volts is not a viable option. Information on the chip’s interface cam be found in the following data sheets:
– http://www.sparkfun.com/datasheets/RF/RF-24G_datasheet.pdf
– http://www.sparkfun.com/datasheets/RF/RF-24G.pdf
– http://www.sparkfun.com/datasheets/RF/nRF2401rev1_1.pdf
– https://www.sparkfun.com/datasheets/RF/RF-24G.pdf

Microcontroller

The microcontroller used was a Microchip PIC18LF2550. I modified the PIC18F2550 Tiny PIC Bootloader assembly file so I could use a 10MHz crystal/resonator at 57,600 baud (the modified bootloader can be found at the bottom of the page). The PIC18LF2550 runs at a maximum speed of 16MHz (4 MIPs) with a 3 Volt power supply; however, I had 10MHz and 20MHz ceramic resonators on-hand, so I ran at the fastest ‘safe’ speed possible (I could overclock the PIC by running it at 20MHz with a 3 volt supply, but it would be running out of spec. so it may not operate reliably). The firmware was written in C (using CCS PICC) and can be found at the bottom of the page, in addition to a generic RF-24G driver for Laipac TRW-24G 2.4GHz transceivers. R1 is a pull-up resistor necessary for operation. C1 is a stabilizing capacitor that is used for the onboard USB voltage regulator (which is not utilized in this project). The component marked ‘RES’ is a 10MHz resonator.

RS232 Level Converter

A MAX233 was used to convert the logic level signals of the PIC18F2550 to RS-232 compatible voltage levels. The MAX233 is running at 3 Volts, which is under the nominal operating voltage of 5 Volts; however, the circuit design would necessitate an additional voltage regulator (for the 5 Volt supply) and repeated testing found no problems with communication performance. It is a little hypocritical of me to use the “running out of spec.” argument for the microcontroller, but not for the RS232 level converter; however, the MAX233 was the only chip I had on-hand and there are 3V RS-232 transceivers available (including the MAX3323E), which can easily be substituted.

Source and Firmware

The PIC must initially programmed with the ‘SAC_tinybld18F2550_10MHz_57600′ hex file to program the bootloader on the PIC. Then, using Tiny PIC Bootloader, the ’18LF2550 RF-24G Serial’ hex file can be placed on the chip using the Tiny PIC Bootloader frontend with ’12h 34h 56h 78h 90h’ in the ‘List of codes to send first:’ in the ‘Options’ menu. Please feel free to contact me if you have any problems.
– SAC_tinybld18F2550_10MHz_57600.asm (hex)
– 18LF2550 RF-24G Serial.c (hex)
– RF-24G.c