Skip to content

And Now For Something Completely Different…

March 17, 2011

‘E’s not pinin’! ‘E’s passed on! This parrot is no more! He has ceased to be! ‘E’s expired and gone to meet ‘is maker! ‘E’s a stiff! Bereft of life, ‘e rests in peace! If you hadn’t nailed ‘im to the perch ‘e’d be pushing up the daisies! ‘Is metabolic processes are now ‘istory! ‘E’s off the twig! ‘E’s kicked the bucket, ‘e’s shuffled off ‘is mortal coil, run down the curtain and joined the bleedin’ choir invisibile!! THIS IS AN EX-PARROT!!  –Monty Python’s Flying Circus, “Dead Parrot Sketch”

Let’s take a short break from Snap Circuits.

I have the Spy Gear TRAKR.

It is a remote control tank that comes with a color digital video still camera and microphone. It is also programable. You can use the the TRAKR website to design your own applications (apps) for the TRAKR or you can download apps created by other TRAKR owners. If you are good at C language programming (I’m not unfortunately), you can write and compile your own programs for the TRAKR.

Here’s a link to the TRAKR’s FAQ page:

The most interesting thing about the TRAKR is that the engineers at Wild Planet have designed the TRAKR to be hackable, and lots of folks have been bitten by the TRAKR hacking bug.

Here are some Hackaday articles regarding the TRAKR:

Here are the FCC Pages for the TRAKR

Here’s additional documentation:

W55VA91 Design Guide:

ARM926EJ-S Technical Reference Manual:

ARM926EJ-S Technical Reference Manual Online Version:

Information on the nRF24L01 (Radio Transceiver Chip) :

Data Sheet:

Product Specification:

TRAKR Remote Startup Radio SPI Traffic:

Building Bare-Metal ARM Systems with GNU: Part 1 – Getting Started:–Getting-Started

We’ve also created Wiki for the Trakr:

Alien Trakr:

I decided to try my own hack on the TRAKR based on the Uni-Directional Wi-Fi Extender posted by tm36usa on the Instructables web site:

Here’s what my TRAKR looks like with the strainer attached:

This is only a temporary attachment. I’ll try to test it this weekend to see if I get any better range.

UPDATE: I was able to test the the unidirectional antenna over the weekend. The results were disappointing. I was unable to detect any extension in range with the strainer attached.

If I do say so myself, the TRAKR does look pretty cool with the strainer attached. Unfornuately the strainer serves no other function except aesthetic, but perhaps I should not be discouraged. There may be other ready-made household items that might work  to extened the range of the antenna–a small wok, maybe or some other parabolic item that would help to focus the radio waves on the antenna.

Of course, since this is a blog about Snap Circuits in later blog posts I hope to show you how to connect Snap Circuits to the TRAKR.

Two of the Snap Circuit sets I have are the Snap Circuits Rover (SCROV-10), a radio controlled Snap Circuits vehicle, and Snap Circuits Micro which includes the PICAXE 08M microcontroller. There are some intruguing possibilities given the H-Bridge integrated circuit fromt the Snap Circuits Rover and the PICAXE 08m–we can write programs to control the TRAKR using Snap Circuits!

Adding a Lego Cargo Deck:

Here’s a fun fact: The mounting holes for the TRAKR deck attachment are just wide enough in diameter so that Lego cross axles fit snugly into them, which means a Lego deck can be built for the TRAKR without having to hot glue them to the TRAKR. This should make it easy to attach the Snap Circuits base plate on the TRAKR.

UPDATE: As I said I discovered that lego cross-axles fit snugly into the holes for the deck attachment. Here as a lego deck that I built for the TRAKR:

Flat deck built of lego technic beams

Here are the deck supports made from lego cross-axles:

Deck supports made with lego cross-axles

Adding a Lego Grabber Arm:

I mounted my lego grabber arm onto the deck using the holes in the lego Technic beams:

Trakr with grabber arm

The Lego grabber arm I used was from the book Robot Invasion by Dave Johnson, but here is a link to detailed instructions of another Lego grabber arm using the original Lego Mindstorms (not the NXT) technic parts:

Adding Temporary Jumper Pins to the Mainboard GPIO Lines:

UPDATE: I was able to add jumper pins to the 9 GPIO lines. Sorry for the blurry pictures:

GPIO Jumper Pins


If you are just too squeamish to take the mainboard out of the Trakr and solder the pins down, Sparkfun makes solderless jumper pins that snap into the GPIO holes.

Download and Install the C Language Compiler for the Trakr


I finally got the TRAKR compiler to work (after a bit of tinkering), yay!

What’s a compiler? Have you seen those geeky T-shirts that say “there are only 10 types of people in the world: those who understand binary, and those who don’t?” If you find yourself scratching your head instead of laughing hysterically, then you don’t understand binary. Computers, on the other hand, understand only binary. 1s and 0s. On and off.

I have heard of some people who can do binary code, or machine language in their heads, but the rest of us normal people would have a difficult time writing a computer program out of nothing but 1s and 0s. Instead we use a higher level language like C language to write software.

Have you ever been to a foreign country and didn’t know the language? You can hire a translator to translate what you say into the language that the locals can understand. That’s what a compiler does. Computers can’t understand C language so, a compiler translates the software you write in C language into machine code, or the 1s and 0s that computers can understand.

You’ll need to download and install the C language compiler so that you can write programs for the Trakr and compile your software into machine language that the Trakr can understand. The C Language compiler is included in a fairly complete software development kit (SDK) that the folks at Wild Planet call the “Primer.” So, download the Primer and save it on your computer where it’ll be easy to find by clicking the following link:

Wherever you decided to save the file it will look something like this:


Make a new folder in the root directory of your hard drive (usually the C: drive) called C:\trakr. Then open the Trakr Primer zip file you downloaded from the Trakr web site and copy all the files and folders from the Trakr Primer zip file into your C:\trakr folder. It should look like this:

Next you’ll need to edit the environment variables to include the path to the Primer’s compiler and tools. If you don’t know what environment variables are, don’t worry, you’re just telling your computer where to find the compiler and the tools it needs to compile your Trakr programs.

If you are using a Windows Vista or Windows 7 computer, click the Start button, right-click Computer on the right of the start menu, and select Properties.

If you are using a Windows XP computer, click the Start button, right-click My Computer on the right of the start menu, and select Properties.

If you are using Windows Vista or Windows 7, click the Start button, right-click Computer on the right of the start menu, and select Properties, then select Advanced System Settings at the Control Panel window.

The System Properties window will open. Then click on the Advanced tab.

Click the Environment Variables button.

In the Environment Variables window, look in the System Variables list for the variable called Path, and click it to select it. Click the Edit button to pop up a window to edit the value of the Path variable.

You have to add some extra text to the end of the “Variable value” text box so, click into the text box press the End key on the keyboard to move to the end of the existing text. Add the following, including the semicolon at the end of the stuff that is already in the text box:


When you’re done, click the “Ok” buttons on all the windows you just opened to close them all. You are now finished installing the Primer. That was pretty easy wasn’t it? Next we are going to compile a sample Trakr app that is included with the Primer to make sure everything is working ok.

Open a command prompt, which is a Windows text based interface. Go to Start->Programs->Accessories->Command prompt. You will see a flashing cursor after the “>” and you can type text based commands. When you’re done typing a command press the Enter key on your keyboard to execute the command.

If, for some reason you were unable to set the Environmect Variables as instructed above, you can also set them at the command prompt. At the command prompt, type the following commands:

cd trakr
cd Internals

Your screen should look like this:

So, running the “setup” file executed the command to enter the the Environment Variables for you.

The compiler runs when you type “make” at the command prompt so you need to make sure you navigate to the folder where the makefile you want to run is located. The compiler then follows any instructions in that “makefile” to convert the “app.c” file (the text file containing the source code) into a TRAKR program.

The compiler only looks for the “app.c” file in the current folder so always name your source code app.c. Save your programs in separate folders with names which make sense. This helps to keep all the various “app.c” files organized. In the screen shot below, you’ll want to run “make clean” in the C:\Trakr\Internals folder. It reports all the files it is removing before returning the prompt to you. Then type “make” at the command prompt and the compiler will use the “makefile” to assemble all the parts of your program (which may include many libraries, images and files specified by your code) into a .bin file to write to the TRAKR hardware. At the “C:\Trakr\Internals>” prompt type:

At the “C:\Trakr\Internals>” prompt type:

make clean

Your screen will show the following:

Your newly compiled program or app for the Trakr is called “Test.bin” and the file will need to be copied to the Trakr. Make sure the Trakr is switched off and connect it to your computer using the yellow USB cable that came with the Trakr. Copy Test.bin to the APPS folder inside the Trakr folder. Disconnect the Trakr from your computer and switch the Trakr on. Switch the Trakr remote on, click the home button, and select Test from the menu. It’s just a little app that tests all the various functions that your Trakr can do such as motor tests, screen functions and so on.

First Compile of Test App:

The following was my humble attempt at writing code in C Language for the TRAKR:

                                 //LED flash program for Spy Video TRAKR
                                 //Program scans to see if button A was
                                 //pressed on TRAKR remote and sets GPC0 high
                                 //and GPC1 low to send current through LED
                                 //in forward bias direction (switched on).
                                 //If button B is pressed, it sets GPC0 low
                                 //and GPC1 high to send current through
                                 //LED in reverse direction (switched off).

#include "svt.h"                 //include Official API
#include "JAPI.h"                //include "Secret sauce" API

#define GPC0 (1<<0)              //bitmask for pin GPC0 = 00000001
#define GPC1 (1<<1)              //bitmask for pin GPC1 = 00000010
#define GPC2 (1<<2)              //bitmask for pin GPC2 = 00000100
#define GPC3 (1<<3)              //bitmask for pin GPC3 = 00001000
#define GPC4 (1<<4)              //bitmask for pin GPC4 = 00010000
#define GPC5 (1<<5)              //bitmask for pin GPC5 = 00100000
#define GPC6 (1<<6)              //bitmask for pin GPC6 = 01000000
#define GPC7 (1< 0) 
     {                           //if keystate is greater than 0
        {                        //Button A pressed (motor forward)
            JAPI_SetIoHigh(GPC0);//Set GPC0 pin high (3.3v)
         } else {
            JAPI_SetIoLow(GPC0); //Switch off pin GPC0
        {                        //Button B pressed (motor reverse)
            JAPI_SetIoHigh(GPC1);//Set GPC1 pin high (3.3v)
         } else {
            JAPI_SetIoLow(GPC1); //Switch off pin GPC1
        {                        //if Home button pressed
         return false;           //this will end the loop
    return true;                 //loop will repeat until false
void End() 
{                                //Program end - switch off both pins

The following is the make file (please note that I have named the program “trakrmotorcontrol” since the same program can be used to flash an LED or drive a motor):

# Makefile for TRAKR Toy
# Trakr Project

PROGRAM_NAME = trakrmotorcontrol
PRETTY_NAME = trakrmotorcontrol
OUTPUT_PATH = ./Intermediate
INTERNALS_PATH = ../Internals

SOURCES = app.c 


SHELL = sh
CC 	= arm-elf-gcc 
AS 	= arm-elf-as 
BIN = arm-elf-ld 
LD 	= arm-elf-ld 

CFLAGS = -O0 -I../Internals/Include -I../Internals -Wall -gstabs+  
TARGET_FLAG = -mcpu=arm926ejs -mapcs-32 -mlittle-endian -specs=specs.semi  
LDFLAGS = -T ../Internals/WJ_APP_8M.ld -Wl,--defsym -Wl,__stack_base=$(TOPMEMORY) -Wl,-Map -Wl,$(basename $@).map -nostartfiles -static  

all: prebuild $(OUTPUT_NAME) postbuild 

	@echo "Linking... "
	@echo "Creating file $@..."
	@$(CC) -u _start -o $@ $(INTERNALS_PATH)/trakr_start.a $(OBJECTS) $(TARGET_FLAG) $(LDFLAGS)

$(OUTPUT_PATH)/app.o:app.c Makefile
	@echo "Compiling $<"
	@$(CC) -c -o "$@" "$<" $(TARGET_FLAG) $(CFLAGS)

.PHONY: clean prebuild postbuild

	$(RM) -f $(PROGRAM_NAME).bin
	$(RM) -f "$(PRETTY_NAME).bin"
	$(RM) -f $(OUTPUT_PATH)/app.o
	$(RM) -f $(OUTPUT_NAME)
	$(RM) -f $(MKDEPFILE)

	arm-elf-objcopy -O binary $(OUTPUT_NAME) "$(PRETTY_NAME).bin"
	@if [ -d "E:/" ] ; then \
		cp "$(PRETTY_NAME).bin" e:/APPS/ ; \

# End of Makefile

When you compile the above code with the above make file, this will create a Trakr App file called “trakrmotorcontrol.bin” and the file will need to be copied to the Trakr. Make sure the Trakr is switched off and connect it to your computer using the yellow USB cable that came with the Trakr. Copy trakrmotorcontrol.bin to the APPS folder inside the Trakr folder. Disconnect the Trakr from your computer and switch the Trakr on. Switch the Trakr remote on, click the home button, and select trakrmotorcontrol from the menu.

I simply connected an LED to GPC0 and GPC1.  I got the LED from an old computer. The LED was a power indicator LED and connectected directly to the PC motherboard with jumper connectors. Thus I was able to connect the LED to the headers in GPC0 and GPC1. Pressing button A on the Trakr remote turned the LED on and and pressing button B turned it off as expected.

To show what is happening when pushing the buttons on the Trakr remote I created the following LED circuit using Snap Circuits:

The black Snap Circuit jumper wire is connected to GPC1. It is connected to a 100 ohm Snap Circuit resistor block that is connected to a Snap Circuit green LED block by a two snap conductor. The red Snap Circuit jumper wire is connected to GPC0.

When I push button B on the Trakr remote GPC1 is pulled high and GPC0 is pulled low. Current flows through the LED in the “forward bias” direction (the direction of the arrow printed on the green LED Snap Circuit block)  and the LED lights up. Why do you suppose the LED will not light up when I press button A?

To get the LED to light up when I press button A, I have to reverse the circuit. When I push button A, GPC0 is pulled high, GPC1 is pulled low, and with the circuit reversed current can now flow in the forward biased direction of the LED and light it up.

Next I connected a Snap Circuits motor. Pressing button A turned the motor in forward direction and pressing button B turned the motor in the reverse direction as expected.

Now the motor will turn in forward direction as long as I hold button A down and stop when I release it. It will turn in the reverse direction as long as I hold down button B and will stop when I release it.

I used my HDD indicator LED to connect my Lego Technic motor. I cut the wires to the LED and stripped the ends and connected them to my Lego motor. Unfortunately, trying to power my lego motor with only 3.3 volts is not sufficient power to operate my lego grabber arm–it moves very slowly and opens or closes he grabber but stops when the additional torque is required to raise or lower the grabber arm.

Since a lego motor requires 9 volts I decided to start actually hacking the TRAKR and that meant taking apart the TRAKR and breaking out the soldering iron.  Since this is a blog about Snap Circuits, I decided to incorporate snap circuits into the hack.

First I took a red and black Snap Circuits Jumper wires

Snap Circuits Black Jumper WireSnap Circuits Red Jumper Wire

Snap Circuits Red Jumper Wire

…and cut them in half.

I stripped the insulation from a red jumper wire half and soldered it to the TRAKR positive input solder point from the TRAKR batteries on the TRAKR main board. I stripped the insulation from a black jumper wire half and soldered it to the TRAKR negative input solder point from the TRAKR batteries on the TRAKR main board.

TRAKR Power Solder Points

Now I had a 9 volt source of power from the TRAKR batteries.

Next I needed and external circuit to take an input from the GPIO pins on the TRAKR main board which is only 3.3v and then drive the Lego motor that needs 9 volts. Luckily Snap Circuits has just the block I needed. If you have the Snap Circuits Rover, SCROV10, then you can use the Motor Control IC for the Snap Rover:

Motor Control IC for Snap Rover

Here’s a description of the motor control block, including pinouts, from the Elenco website:

Snap Circuits Motor Control Pinouts

If you are familiar with H-bridge ICs you’ll notice that the Snap Circuits Motor Control block is very similar to an H-Bridge IC.

I connected the red Snap Circuits jumper wire that was soldered to the TRAKR mainboard 9 volt power to the “+” snap on the Snap Circuits Motor Control block. I connected the black Snap Circuits jumper wire that was soldered to the TRAKR mainboard ground to the “-” snap on the Snap Circuits Motor Control block.

I took the other half of the red Snap Circuits jumper wire and stripped some of the insulation and connected it to the wire that was connected GPC0 (after disconnecting it from my lego motor). I did the same with the other half of the black Snap Circuits jumper wire and connected it to the wire connected to GPC1.

Then I was able to connect GPC0 to the LF snap on the Snap Circuit Motor Control block and GPC1 to the LB snap  on the Snap Circuit Motor Control block.

Unfortunately I was out of Snap Circuits jumper wires so, I had to connect alligator clips to my Lego motor and used the alligator clips to L- and L+ on the Snap Circuits Motor Control block.

Here are some pictures of my TRAKR with the Snap Circuits Motor Control block connected:

TRAKR With Lego Grabber Arm and Snap Circuits Montrol Control block closeup. The alligator clips are connected from L- and L+ on the Snap Circuits Motor Control block to the Lego motor on the Lego Grabber arm. The red Snap Circuits jumper wire is connected from "+" on the Snap Circuits Motor Control block to the 9 volts solder point on the TRAKR mainboard. The Black Snap Circuits jumper wire is connected from "-" on the Snap Circuits Motor Control block to the Ground solder point on the TRAKR mainboard.

GPC0 and GPC1 connected to LB and LF snaps on Snaps Circuits Motor Control block

 Click the link below to see the grabber arm in action:

My approach was to have a grabber arm for the trakr  and see if it could be built from ordinary toys or other items that people might already have as apposed to having to buy special electronic items from Frye’s or Radio Shack or Sparkfun.

So, I was able to use the TRAKR, Legos, and Snap Circuits for the grabber arm.

The only electronic Items that I had to buy were the header pins to insert into the gpio holes on the TRAKR mainboard (BTW the solderless pins are now in stock at spark fun–I plan to get some soon) and shrink tubing.

I got the header pin connector from an old computer I took apart (the LED and header pin connector I used for my intial test was the hard disk drive LED from that computer).

Of course, I already had the soldering iron and some solder.

Elite Trakr Hacker “cpt_hans” Demonstrates How to Solder GPIO Headers:


For you hardcore hackers, elite Trakr hacker who goes by the handle cpt_hans has kindly provided detailed instructions (with pictures) for taking apart the Trakr and soldering the header pins down:

In this section, I’m going to briefly explain (with the aid of several photos) how I disassembled the Trakr and installed the headers. Please note that this project is not difficult, but it does require some patience and some soldering skill. If you are inexperienced or uncomfortable soldering on a printed circuit board, you can follow the instructions to disassemble the Trakr, and then take it to someone who can solder it for you.

The GPIOs and the A-to-D converter are inputs and outputs that can be used to control things. They share a .1″ pitch header. The JTAG is a programming/testing port that uses a 2mm header. I plan on exploring the JTAG port, to see if I can access some capabilities there…but not everyone may be interested in doing that. I’m going to show both, but you can do just the GPIO if you want.

I ordered part # PRT-10112 ($0.95) from Sparkfun for the JTAG header. It’s 10 pins; we only need 7, so we can just snip off the extras. For the GPIO, I ordered part # PRT-00116 ($1.50). It is a 40-pin header. Since we only need 9 pins, that one part is enough for 4 Trakrs!

Here’s the two parts:


You’ll need these additional items for this project:
– Trakr (duh!)
– #1 Phillips screwdriver
– Fingernail polish remover
– Cotton swabs
– Exacto knife (or similar hobby knife)
– Soldering iron
– Solder
– Vacuum desoldering tool (aka ‘solder sucker’…hey, nobody’s perfect, and you may have to fix a mistake!)

Start by removing the two screws for the back cover. Throughout this project, be mindful of the antenna, and don’t break it!

When that’s done, you can look in at the mainboard, and see where we’re going to install the headers.

You’ll want to fold the antenna over and then flip the Trakr over so you can get at the screws that fasten the Trakr case together. Use a philips screwdriver to remove all the case screws (you can ignore the battery and reset compartment screws). There are a total of 12 screws to remove. Note that the screw marked with a star is shorter than the other 11, so keep track of it.

Once the cover screws are removed, you can pull the upper and lower housings apart. When you do, the emblem on the front will fall out. No worries. There’s also another piece behind it that will now be loose. Set them both aside, and remember to replace them when reassembling the Trakr.

With the upper housing moved aside, you can see the shiny screws holding in the mainboard. Resist the temptation and don’t remove them yet!

Once the cover screws are removed it’s easy to lift the cover enough to see most of the main board. When opening up the cover remember to be careful. There are a number of wires that are connected between the cover and the mainboard. The connectors for the wires are modular, but to make the Trakr more rugged, the connectors have been glued together. I don’t know what kind of glue Wild Planet used, but it must be UFO technology from Area 51! It’s tough stuff! This is where the fingernail polish remover and patience are employed.

With a cotton swab, apply fingernail polish remover to the glue to soften it up. It will probably take more than one application. Allow the polish remover time to soak into the glue. Use the hobby knife to trace along the connector joints, and to peel the glue away from the connectors. Note that the connectors also have two tabs molded into the plastic so they’ll latch together. I used the knife to release the tabs, once the glue was cleaned away.

Here’s a couple of views of the connectors that need to be unglued:

With the connectors unglued and separated, you can now set aside the upper housing. If while trying to separate the connectors, you end up pulling the whole thing off the board, don’t fret. The pins on the board will still be okay. If you look at the pic below, you’ll notice that I accidentally pulled the whole connector for the speaker off of the left front leaving the pins sticking up from the board. It was easy to reattach the connectors to the naked pins once I got the connector separated. I just used a hot glue gun to reattach it to the mainboard. Your Trakr will now look like this:

Before you take the mainboard screws out, there’s another connector to unhook. This flat white ribbon cable is on the right front of the Trakr, and is for the camera assembly. It’s a pressure-type connector that holds the ribbon cable against the contacts of the socket. To release, slide the little brown tabs (they’re actually connected and run underneath the ribbon cable) forward about 1/8″…the cable will slide right out.

Remove the five mainboard screws, and unhook the connector to the USB port from the bottom. I left the power leads from the battery pack soldered on, since I had enough freedom of movement even with them connected.

I trimmed the headers to the required number of pins needed. It was easy, since both of them are scribed between each pin for just that reason!

At this point, it’s a simple matter to insert the headers into the holes on the mainboard, and solder them in. Good solder joints are smooth and shiny like these. Ensure that none of them are soldered to their neighbor (solder bridge).

Now reverse the disassembly process to put your Trakr back together!

So you ask, “I have pins, now what do I use for plugs?” You can order connectors online to fit the headers, although Sparkfun doesn’t carry any. I did some scrounging in my parts box and found that various cables from old computers will connect to the headers. The connector on the left is an audio connector used to hook CDROM drives to sound cards or motherboards. It fits the GPIO spacing. The connector on the right is the type used for internal audio connections, like video capture cards to sound cards, etc. This will fit the JTAG spacing.

I’m not saying these connectors will meet all your needs, but it at least you can modify them, and it gives you an idea of what to look for in your junk box. In the pic below, I have two CDROM audio cables on the GPIO…this would give me A-to-D and five GPIO connections; certainly enough to play around with. Other .1″ connectors from an old computer case or motherboard (e.g. front panel switches, USB headers, chassis fans) should be of compatible spacing as well.

I also found that there’s enough clearance from other components for a standard IDE cable to connect to the GPIO header. Of course, you’re only using one row of the connector, and you may want to trim it down…but hey, be a hardware hacker!


From → Uncategorized

  1. Dean permalink

    Thanks for the info. I have been looking for something cool to do with this rover and I have finally found a site with a lot of good documentation to help me learn and explore robotics at an affordable price.

Trackbacks & Pingbacks

  1. Spy Video TRAKR Claw Attachment Hack - Hacked Gadgets - DIY Tech Blog
  2. Spy Trakr gets a claw! « BuildLounge
  3. Bomb disposal robot with Lego gripper - Hack a Day
  4. Bomb disposal robot with Lego gripper | CisforComputers

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: