PFR3: Build Complete

I finally finished building the rig about 10 days ago. What an adventure! I last left off having completed Group 2 and started on a group 3. Finishing group 3 was actually pretty straightforward: wind and install a bunch of torroids, and solder in a few more components to complete the transmitter and BLT tuner. The only really tough aspect was winding the monster torroid in the transmitter. Wow--3 interleaving windings, with heavy gauge wire. More on that later...

Recycling an old photo of the board, let me assure you of one thing: random lead clippings that short pins on the programable chip can be quite annoying. I must have re soldered 10 different components before I saw the lead clipping laying there. Assemble, disassemble, reassemble, disassemble... That cost a good 20 minutes. But finally I have the main board complete!

Next, it was time to kit the box. The instructions recommend not kitting until the rig has been fully tested. In retrospect, that makes sense... sigh. Here's how it looks now that it's kitted, though!

The circuit board mounts into the top of the case, with 4 screws which seem to provide ground. That will become important shortly... Kitting everything was pretty straightforward, although I was surprised that the power tap didn't fit. I had to ream out the hole just a bit (nothing a really sharp tempered steel knife couldn't handle). Remember the comment about the external power? Well, if you look really close you'll see I connected the center pin on the external power jack to the ground (white lead), and the outside of the jack to the board's power. Yes, I'm sure you did the math and arrived at the conclusion I overlooked: this causes a short and can really heat up a battery quickly. I'm actually lucky I tested with 8 AA's at 12v rather than a larger 12v SLA battery that could have delivered a bigger punch!

The internal battery pack has sticky tape on it. It needs to be soldered to a wire. This is one of two complaints I have about the entire kit: the plastic battery case melts before the contacts are warm enough for the solder to flow. (My other complaint is about the documentation on T1 and on the monster torroid.) You can barely see it my workaround, but I ended up soldering to the spring inside the battery pack (topmost row, on the far right).

This is the rig, no decals yet. That yellow color is pretty bright--selected to help you find or avoid stepping on the rig while operating in the field.

Connection points. From left to right: power, BNC antenna, switch from BNC to balanced line, and balanced line contacts.

Well at this point I'm pretty happy. My buddy WB6YOK and wrapped up around 10:30 Saturday--another quite long evening and I know my wife will be happy when I'm done disappearing for half a day at a time. I know I will be!

Evidence: it runs on external power. It runs on internal power. It runs!

My preliminary testing was indeterminate--lower power reading on the SWR/power meter, but the antenna was poorly tuned. My Elecraft T1 tuner showed 5+ watts on 40 and 30 (the tuner has LEDs to indicate 1, 5 and 10 watts, so if the rig puts out 4.5 watts it's still not possible to know anything other than the righ puts out more than 1 watt). More testing yet to be done.

Next steps:

1. More output testing: I'd like to buy a few $0.50 50 Ohm resistors, build a dummy load, and test on a matched "line".

2. Install decals

3. Clear coat

4. I'm toying with spraying some reflective clear paint I have on various spots around the rig, to aid discoverability during nighttime

5. I would love to find some small rubber "covers" to put over the 4 switches. The rest of the through holes are actually sealed, but these 4 aren't. We swapped out cable boxes recently, but kept the old remote and it has a few rubber covers which just might work.

6. Build a balanced line and test the BLT

7. QSO! 

I broke this out a couple days ago and tuned around the bands. I was swapping back and forth between my 817 and the PFR. I got a report later from a ham in Oregon that he'd heard me call CQ on 40 but he couldn't get his rig set up in time to answer me (I QSY'ed a bit too quickly). I don't know which radio I was on at the time). 

Between the dummy load and figuring out the "recipe" for my Buddistick, I think I'll have this dialed in shortly.

PFR3 Continues

Just an update: successfully finished group 2, all tests passed (although due to some unplanned massive remodeling at my buddy's, we couldn't get the oscilloscope out). Happy happy! So of course, I soldiered on and started group 3, which begins with a few soldered components and then a pretext. It was on the protest that I completely fell apart. The mistakes?

1. There are two "U8" markings on the board. Pins 1 and 13 are supposed to be at zero volts with the power on and the rig in straight key mode, then 1.2 volts with the key closed. Odd, I was seeing 4 volts on pin 1. Oops... Wrong U8. On the correct U8, I see 0 volts with the key opened and 2 with it closed. The group weighed and said 2 volts is fine--less important the voltage vs. the fact that the circuit is open or closed.

2. Wrong resistors. As I posted to the reflector:

* Manual R6 & R7 should be YEL/VOL/YEL
* Errata: ORG/ORG/YEL
* Installed: YEL/VOL/YEL

Which is right? The errata and the manual agree on 470k, which is YEL/VOL/YEL. Press onward.

3. While troubleshooting the voltage issues, I literally went back to the beginning and checked every single component. Oops, I installed the wrong captor C24. Desoldering, replace, resolder in C56. Oh, whoopsies... Omitted R35 (I remember now I couldn't find it on the board when I was doing stage 2, and apparently I forgot to look again).

Needless to say, I have now checked every component, looked at every solder joint, and made sure everything works. Finally, time to press forward wih L7 to finish the transmitter, so I can start the BLT.

Lessons? Go slow. Mark your questions. Pay very close attention to markings, esp on your caps. If you're tired, stop--rushing won't get it done sooner.

I cannot wait till this is done, if only to put my quirky tom-foolery behind me!

The blue cap on the right side, next to the LCD? Yah, it goes about 5 o'clock from the Dove treat (my wife is the best!). You can see the big trace, right next to the little yellow 104 cap.

See the LCD display? See the conspicuously large resistor spot traced out in white marking, much like a victim's profile at a murder scene? Yah, I don't know how I missed it either!

See the vertical chip just next to the Dove treat? That's U8. Oh, but wait--see the other U8, just below the LCD. Hello, I'm Daryl. This is my brother, Daryl and this is my other brother Daryl. No offense to the boys at Hendricks. I'm sure this is my careless reading of the manual and/or errata. I've made enough dumb mistakes to prove them the experts! And hey, every problem is an opportunity to learn!

American Morse KK2 Paddle

This Christamas had a special treat for me. I told my wife that all I wanted for Christmas was an American Morse KK-2 CW paddle, because in 2014 I have a goal to learn CW. She worked with Santa, and the two of them came through for me!

Background: American Morse is a US-based manufacturing company which builds CNC-shaped precision products. They can be found at www.americanmorse.com Their approach is to keep it simple and build a few things really well. I was looking for a solid base station iambic paddle, and the KK-2 seemed like just the thing. It is!

The folks at American Morse build everything as a kit, and can ship kits or built product. I wanted the kit, of course. "I build, therefore I am..." Assembly was a snap--took about 15 min to prebuild, after which I disassembled, sanded out burrs, and did final assembly. This is the final product:

American Morse KK-2 paddle kit, assembled

The paddle arms are machined brass. It's not visible in the picture, but the arms are actually hollowed. The paddle tips are nylon. Everything else is high grade steel. As you can see, I've done nothing to "protect" the steel base--there are some rust spots appearing. I'm tempted to brush the base with my grinder and put a quick clear coat on it. That would look cool, but of course have no effect on the paddle's performance.

The paddle does not ship with a cable. I was toying with building one from scratch but when I got to Radio Shack and priced options, buying a stereo cable turned out to be cheaper vs buying wire and plugs and building it. In keeping with the garish color scheme of the Hendricks PFR3, I bought a lime green cable.

 American Morse KK-2 with cable

Wiring was simple -- first I cut one end off (leaving a couple inches of factory wire, in case I ever need that tip), then I made sure which wires went where on the plug, then I wired them up based on iambic paddle wiring guides online. The outcome is rather nice, I believe:

KK-2 cable wiring

The black wire holder fit the factory cable perfectly. Everything feels solid.

The real question is, how does it work? I'm an absolute beginner when it comes to CW, so all I can say is that it's been a joy to use during my CWOps "CW Academy" training class. The rubber feet you see in the photo leave something to be desired when using the paddle on a Formica desktop. My buddy WB6YOK recommended I cut a mousepad to fit inside the rubber feet, and while I haven't done it yet, the idea has merit. But keying is precise and the device works great. 

According to American Morse, the KK-2 weighs in at 1.5 pounds (24 oz). I haven't weighed it yet, but that seems accurate. As I will be operating in the backcountry as well as from home, having a "mid-weight" unit was important (although I am seriously considering their DCP or Port-a-Paddle kits for lightweight backcountry use).

You can find this paddle online at http://www.americanmorse.com/kk2.htm

Elecraft T1 Tuner Repair

I've been kind of "radio inactive" whilst sorting out a few things over the last 3 years or so. First time operating in quite a while was back in October up in the Fish lake National forest with my sons. Just prior to leaving, I visited my buddy Chuck to run my gear through its paces. We hooked up my T1 QRP tuner (actually a max of 20 watts) to his FT-897 and my PRC74 military radio whip antenna. I keyed an AM carrier, pressed the tune switch and man--that old military whip tuned up in about 1.5 seconds. Well, that's what I thought... In actuality, I either hit it with too much RF (might have turned down the wrong power settings on the 897) or the tuner just hadn't been used in a long while... Regardless, I fried two diodes. They are barely visible on either side of the right-most torroid on the bottom of this photo. Small blue components aligned horizontally in this snap.

I looked all over and found replacement diodes at Mouser. Ironically, they are fifty cents each, and shipping is $6 (and it's no wonder--my two diodes were shipped in a mid-sized cardboard box!).

I've been stabbing away at desoldering these diodes, but no joy. I'm taking them to my buddy's. He's got a beautiful desoldering station (no joke--I seem to use it a lot). This repair should go quickly! Along wth testing my PFR, we're doing the repair in the next couple days. Hopefully my next post will be of a successful tuning sequence with my 817 and his Gap Titan antenna.

By the way: the trip to Fish Lake wasn't a total bust. That old whip is resonant on 10m (when switched to the antenna's 40m configuration), and 10m was wide open. At 5 watts with right around 1:1.5 antenna matching, I was using PSK to contact France and several US stations. It could have been worse!

73's de K7JTO

Hendricks PFR3 build, groups 1 & 2

If you've read my other blog posts here, you know I'm really interested in light-weight portable operations. That's what led me to buy the Yaesu FT-817, but eventually I realized that was good for park bench or quick day-trip summit work, but it just wouldn't work for a long (3+ days) backcountry hike. 

I reviewed a ton of radios annd came to the conclusion that I needed to learn CW and move to a dedicated QRP rig. After a lot of research, I was about ready to buy an Elecraft KX-1 (http://www.elecraft.com/KX1/KX1.htm). It's highly rated, well-crafted, and quite popular. Then someone turned me onto the Hendricks PFR3 (http://www.qrpkits.com/pfr3.html). The owner of the company was at a QRP meeting listening to someone discuss backcountry QRP operation. An audience member asked what the best rig for backcountry is, and the presenter said it didn't exist yet. He proceeded to list out the features of the dream rig, and Hendricks wrote it all down. He and Steve Weber design, prototyped, and started selling the rig. Not only is it better designed for the backcountry, but it's also much cheaper (the PFR3 currently sells for $240).

About 3 years ago, in 2011, I ordered my kit. I think I sorted the kit the first day I received it, but that's about it. Life got very busy for me, I went through some ups and downs, and now three years later I'm finally building it. In researching the kit, I found there's very little available on the Internet on how to build this rig. If you can't figure it out in the manual, there aren't many resources other than the group. I decided to document the build process so others might benefit.

I am about 4 hours into the build, done with the first two stages.

Basically stage 1 is the LED and power switch. The receiver, stage 2, is most of the right half of the circuit board. The build is very straightforward, except for one item: there's a torrid with a 5-turn primary winding and a 40-turn secondary winding:

I discovered in the course of winding that there is only room for a 40-turn winding, but the manual calls for 40 turns followed by 5 turns. It was all very confusing, until I emailed the PFR3 Yahoo group. A group member clarified: the 5 turns go over the 40 turns. This is probably the least clear portion of the manual.

Another point of conversation: some people have had issues with torroid wires breaking due to the jostling of backcountry travel (shaking in the pack). After discussion with list members, I decided to drop some wax under each torroid. That's what you can see in the shot above. The torroid a are installed on what will be the bottom of the board.

It's difficult to tell, but the radio is powered up and showing 30.0 on the right three digits.

My kit arrived with every component, but unfortunately I lost one of the RF chokes. A list member sent me a replacement. In the lower left of the photo you can see the stock choke--it looks like a fat resistor, just below C42. In the middle of the photo, between the blue and green caps, is the replacement choke. I love the way amateurs help each other out all the time!

Just another random shot of the main board. The kit is very well laid out and goes together quickly--most people estimate 6-8 hours to build. I'm probably 4 hours in, but a lot more considering the head scratching I went through over that torroid!

The manual lists a modification to stage two which address noise in the receiver. It requires two caps to be added--one in a through-hole, and on jumping a couple pins on another component. I was in Seattle on business so I grabbed the components at Frys and installed them with Group 2.

Next step is to dial in the receiver, then build out stage 3 (transceiver). Finally, prep the case and finalize the install.

TrunkTrackerino v .9 finished

OK I can officially put this down for a while! TrunkTrackerino .9 is finally working - I'm recording GPS coordinates and writing them when I have a valid fix. I had issues with the log file, but I've worked those out. All that's left now:

• Have to fix an issue with the log file time stamp
• Have to add in logic to sleep when speed ! >= 1
• Have to slow down the read (it's every .5 seconds right now)
• Bonus: add logic to put the device to sleep for 5 min when speed !>=.5, to save on battery power

Once those changes are done (and I'm kind of burned out on the Arduino now), then I'm ready to throw this in the trunk of my car and do a little 'applied testing' before I let my boys show me how they manage their driving.

After that, my next addition will be an APRS shield so I can start communicating geo-loc over radio. That is the base bundle for the balloon instrument pack.

Code:

// TrunkTracker sketch combines code from GPSTest_RMC and SD_GPSLogger
// Throw your Arduino in the trunk to see where your teens really go
// and how fast they really drive.

#include "Arduino.h"
//#include "GPSconfig.h"
#include <avr/sleep.h>
#include <SD.h>

// If running Arduino < 1.0, add references to WProgram.h and NewSoftSerial.h
#include "SoftwareSerial.h"

// Set this to 0 when in production; all serial output will be diasabled
#define DEBUG 0

// My shield is wired with RX/TX swapped
//SoftwareSerial mySerial = SoftwareSerial(2, 3);
SoftwareSerial mySerial = SoftwareSerial(3, 2);

// power saving modes
#define SLEEPDELAY 0    /* power-down time in seconds. Max 65535. Ignored if TURNOFFGPS == 0 */
#define TURNOFFGPS 0    /* set to 1 to enable powerdown of arduino and GPS. Ignored if SLEEPDELAY == 0 */
#define LOG_RMC_FIXONLY 0  /* set to 1 to only log to SD when GPS has a fix */

// Set up pins used
#define powerpin 4      // Use pin 4 to control power to GPS
#define led1Pin 5
#define led2Pin 6

// Set GPSRATE to 4800 for my GPS
#define GPSRATE 4800

// Create a buffer of 90 to store GPS data. Usually about 80 chars so 90 is plenty
#define BUFFSIZE 90

// Create an int for iterating
uint8_t i;

// Create instance of logfile
File logFile;

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 10;

// Global variables
char buffer[BUFFSIZE];     // string buffer for the sentence
char *parseptr;            // a character pointer for parsing the GPS sentence
char buffidx;              // an indexer into the buffer
bool fix = false;          // current fix on data
bool gotGPRMC = false;             // true if current data is a GPRMC string

// The time date, location, data, etc.
uint8_t hour, minute, second, year, month, date;
uint32_t latitude, longitude;
uint8_t groundspeed, trackangle;
char latdir, longdir;
char validity;

// Setup the sketch
void setup()
{
  // First set up GPS comms
  if (powerpin)
  {
    pinMode(powerpin, OUTPUT);
  }
  // Use the pin 13 LED as an indicator
  pinMode(13, OUTPUT);
  // connect to the serial terminal at 9600 baud
  Serial.begin(9600);
  // connect to the GPS at the appropriate rate
  // IF THIS IS WRONG for your GPS, change it above
  mySerial.begin(GPSRATE);
  // print title with ending line break
  if (DEBUG)
     Serial.println("GPS Parser started");
  digitalWrite(powerpin, LOW);  //pull low to turn on
 
 
  // Now set up SD for logging
  // This code lifted from "Datalogger" sample sketch
  if (DEBUG)
    Serial.println("Initializing SD card...");
 // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(10, OUTPUT);
 // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card init. failed!");
    error(1);
  }
  // Now create a unique file
  strcpy(buffer, "GPSLOG00.TXT");
  for (i = 0; i < 100; i++) {         
    // Keep iterating till you find unique file name
    // Create if does not exist, do not open existing, write, sync after write
    buffer[6] = '0' + i/10;
    buffer[7] = '0' + i%10;
    if (! SD.exists(buffer)) {
      break;
    }
  }
  // Now open the file just created
  logFile = SD.open(buffer, FILE_WRITE);
  if( ! logFile ) {
    if (DEBUG)
    {
       Serial.print("Couldnt create "); Serial.println(buffer);
    }
    error(3);
  }
  if (DEBUG)
  {
     Serial.print("Writing to "); Serial.println(buffer);
  }
  // Done opening log file
}

uint32_t parsedecimal(char *str)
{
  uint32_t d = 0;
 
  while (str[0] != 0)
  {
    if ((str[0] > '9') || (str[0] < '0'))
       return d;
    d *= 10;
    d += str[0] - '0';
    str++;
  }
  return d;
}

// Read line from GPS unit
void readline(void)
{
  if (DEBUG)
    Serial.print("Input from GPS: ");
  char c;
  buffidx = 0; // start at beginning of line
  while (1)
  {
    c = mySerial.read();
    if (c == -1)
       continue;
    // Output status to screen
    if (DEBUG)
       Serial.print(c);
    if (c == '\n')
       continue;
      
    // if we're nearing the end of buffer, terminate
    if ((buffidx == BUFFSIZE-1) || (c == '\r'))
    {
      buffer[buffidx] = 0;
      return;
    }
    // Write each char into buffer
    buffer[buffidx++] = c;
  }
}

// Main program - keep doing this over and over
void loop()
{
  uint32_t tmp;
 
  if (DEBUG)
     Serial.print("\n\rRead: ");
  readline();
 
  // Check if $GPRMC (global positioning fixed data)
  if (strncmp(buffer, "$GPRMC",6) == 0)
  {
    // Set gotGPRMC
    gotGPRMC = true;
    //hhmmss time data
    parseptr = buffer+7;
    tmp = parsedecimal(parseptr);
    hour = tmp / 10000;
    minute = (tmp / 100) % 100;
    second = tmp %100;
   
    parseptr = strchr(parseptr, ',') + 1;
    validity = parseptr[0];
    parseptr +=2;
   
    /*
    // Break out if "validity" = "V"
    if(validity = 'V')
    {
      if(DEBUG)
         Serial.print("\nGPS navigation error. Trying again...");
      return;
    }
    */
   
    // grab latitude & longitude data
    // latitude
    latitude = parsedecimal(parseptr);
    if (latitude != 0)
    {
      latitude *= 10000;
      parseptr = strchr(parseptr, '.') + 1;
      latitude += parsedecimal(parseptr);
    }
    parseptr = strchr(parseptr, ',') + 1;
   
    // read latitude N/S data
    if (parseptr[0] != ',')
    {
      latdir = parseptr[0];
    }
   
    // longituide
    parseptr = strchr(parseptr, ',')+1;
    longitude = parsedecimal(parseptr);
    if (longitude != 0)
    {
      longitude *= 10000;
      parseptr = strchr(parseptr, '.') + 1;
      longitude += parsedecimal(parseptr);
    }
    parseptr = strchr(parseptr, ',') + 1;
    // read longitude E/W data
    if (parseptr[0] != ',')
    {
      longdir = parseptr[0];
    }
   
    // groundspeed
    parseptr = strchr(parseptr, ',') + 1;
    groundspeed = parsedecimal(parseptr);
   
    // trackangle, just 'cause
    parseptr = strchr(parseptr, ',') + 1;
    trackangle = parsedecimal (parseptr);
   
    // date
    parseptr = strchr(parseptr, ',') + 1;
    tmp = parsedecimal(parseptr);
    date = tmp / 10000;
    month = (tmp / 100) % 100;
    year = tmp % 100;
   
    // OK - we've parsed the full string. Now let's print to serial if in debug mode
    if (DEBUG)
    {
        Serial.print("\n\tTime: ");
        Serial.print(hour, DEC); Serial.print(':');
        Serial.print(minute, DEC); Serial.print(':');
        Serial.println(second, DEC);
        Serial.print("\tDate: ");
        Serial.print(month, DEC); Serial.print('/');
        Serial.print(date, DEC); Serial.print('/');
        Serial.println(year, DEC);
        Serial.print("\n\tStatus: "); Serial.print(validity);
       
        Serial.print("\n\tLat: ");
        if (latdir == 'N')
           Serial.print('+');
        else if (latdir == 'S')
           Serial.print('-');
   
        Serial.print(latitude/1000000, DEC); Serial.print("* ");
        Serial.print((latitude/10000)%100, DEC); Serial.print('\''); Serial.print(' ');
        Serial.print((latitude%10000)*6/1000, DEC); Serial.print('.');
        Serial.print(((latitude%10000)*6/10)%100, DEC); Serial.println('"');
      
        Serial.print("\tLong: ");
        if (longdir == 'E')
           Serial.print('+');
        else if (longdir == 'W')
           Serial.print('-');
        Serial.print(longitude/1000000, DEC); Serial.print("* ");
        Serial.print((longitude/10000)%100, DEC); Serial.print('\''); Serial.print(' ');
        Serial.print((longitude%10000)*6/1000, DEC); Serial.print('.');
        Serial.print(((longitude%10000)*6/10)%100, DEC); Serial.println('"');
       
        Serial.print("\tGroundspeed: ");
        Serial.println(groundspeed);
       
        Serial.println("Now writing to SD card...\n\t");
        Serial.println(buffer);
    }
   
    // Now log tab separated string
    digitalWrite(led2Pin, HIGH);    // First turn on LED2 to indicate writing to SD
    logFile.write((uint8_t *) buffer, buffidx);  // write the string to the SD card
    logFile.println("");
    logFile.flush();
   
    digitalWrite(led2Pin, LOW);    // turn off LED2 (write to SD is finished)
   
    buffidx = 0;                 // reset buffer pointer
   
    if(fix)
    {
      if ((TURNOFFGPS) && (SLEEPDELAY))
      {
        digitalWrite(powerpin, HIGH); // turn off GPS
        delay(100);                   // wait for serial monitor write to finish
        sleep_sec(SLEEPDELAY);         // turn off CPU
       
        digitalWrite(powerpin, LOW);  // turn on GPS
      }  // if (TURNOFFGPS)
    } // if (fix)
   
    return;
  } // if(gotGPRMC)
   
}

// Handling Errrs HERE
// blink out an error code
void error(uint8_t errno) {
  if (DEBUG)
  {
    /* Need to investigate
      if (SD.errorCode()) {
        putstring("SD error: ");
        Serial.print(card.errorCode(), HEX);
        Serial.print(',');
        Serial.println(card.errorData(), HEX);
      }
      */
     Serial.print("Error writing to SD card. ");

  }

  while(1) {
    for (i=0; i<errno; i++) {
      digitalWrite(led1Pin, HIGH);
      digitalWrite(led2Pin, HIGH);
      delay(1000);
      digitalWrite(led1Pin, LOW);
      digitalWrite(led2Pin, LOW);
      delay(100);
    }
    for (; i<10; i++) {
      delay(200);
    }
  }
}

void sleep_sec(uint16_t x) {
  while (x--) {
     // set the WDT to wake us up!
    WDTCSR |= (1 << WDCE) | (1 << WDE); // enable watchdog & enable changing it
    WDTCSR = (1<< WDE) | (1 <<WDP2) | (1 << WDP1);
    WDTCSR |= (1<< WDIE);
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
 //   sleep_enable();
    sleep_mode();
//    sleep_disable();
  }
}

 

TrunkTrackerino

It's simple, really:
I have teens...
They drive my car...
They are boys...
I am an engineer...
I like life hacks...
I have an Arduino...
And a GPS logging shield....

Therefore, TrunkTrackerino.

More than two years ago I started a push to get my Arduino working with the GPS logger shield. It failed, mostly because I had some other life pressures. I recently pulled out my Arduino and started messing with it again, not really sure why... And I got the GPS working. And then I thought... I can build a simple device to throw in the trunk that will record driving speed! And thus TrunkTrackerino was born.

There are sketches for using a GPS. There are also sketches for logging GPS data to a card reader. But I really didn't like any of them individually, so I have merged them together. And as of today, I believe I have it working (not entirely sure, since I'm in my hotel and can't pick up signal--I will know more tomorrow).

The goal is to build an Arduino-based device which
* tracks speed and location
* sleeps when there is no motion
* logs nothing when there's no valid data
* stores data on an SD card
* can be imported into XL to view historical speed data
* can be imported into Google Earth for bread crumb data

Eventually this project will end up as the base for the APRS balloon tracking system. For now, it's enough to know my boys are as honest as they say they are.

Update: I took a brief stroll around the hotel entrance today. For some reason, the logging code is logging an empty file. The GPS is working great--when I watch in Arduino's serial monitor, I can see good valid strings which are being parsed great. I'd say I'm 10 lines of code from a working beta.