Skip to content

Fun With Snap Circuits 8: I, Roverbot

1. A robot may not injure a human being or, through inaction, allow a human being to come to harm.

2. A robot must obey the orders given to it by human beings, except where such orders would conflict with the First Law.

3. A robot must protect its own existence as long as such protection does not conflict with the First or Second Laws.

–Isaac Asimov

It has been a while since I have updated Fun With Snap Circuits, but I have been busy with creating some Instructables. Also, my hack adding a grabber arm to the Spy Video Trakr  has been featured on several blogs:

Hack A Day:

http://hackaday.com/2011/11/03/bomb-disposal-robot-with-lego-gripper/#more-60341

Dangerous Prototypes:

http://dangerousprototypes.com/2011/10/22/spy-video-trakr-with-lego-robot-arm/

Hacked Gadgets:

http://hackedgadgets.com/2011/09/19/spy-video-trakr-claw-attachment-hack/

Build Lounge:

http://www.buildlounge.com/2011/09/20/spy-trakr-gets-a-claw/

So, in this blog post I have decided to introduce the subject of robotics using Snap Circuits. You will learn how to build a simple Snap Circuits programmable robot.


First, you will learn how to install the PICAXE Programming Editor (the PICAXE is the microcontroller, or computer brain for your Snap Circuits programmable robot, or Roverbot). Next, you will learn what a simple PICAXE program looks like and what it does. Then you will learn about the various parts and electronic components used to build  the Roverbot. You will then assemble the Roverbot. Finally you will learn how to program and test the Roverbot.

To build the Roverbot, I used parts from three different sets, the Snap Circuits Motion Detector, Snap Circuits Rover, and Snap Circuits Micro. Elenco does not currently have a Snap Circuits programmable robot product. I find this surprising since Elenco has developed the Snap Circuits Rover, which is a remote controlled rover and the Snap Circuits Micro that teaches you how program the PICAXE microcontroller and how to build circuits for the PICAXE, but Elenco has yet to develop a product that combines the PICAXE with the Snap Circuits Rover.

I designed the Roverbot to be easy to build completely out of Snap Circuits parts and easy to program.

The following are the Snap Circuits parts you will need to build the Roverbot (parts can be ordered separately from Elenco http://www.elenco.com/product/productlist/snap_circuits®; or C & S sales http://cs-sales.net/sncirepa.html):

Software CD from the Snap Circuits XP or Snap-Micro I kit (if you do not have either of these kits you can download the PICAXE Programming Editor from http://www.picaxe.com/Software/PICAXE/PICAXE-Programming-Editor/)

10 X 7 Plastic Base Grid
Snap Circuits Rover
9 volt Battery Block B5
Motor Control IC U8
8 Pin Socket U14 With PICAXE 08m Installed
4 1K Ohm Resistors R2
Slide Switch S1
USB Programming Cable
(You may substitute the Snap Circuits USB to DB9 Converter and the Snap Circuits DB9 Programming Cable if you do not have the USB Programming Cable)
Snap Circuits Micro Software CD
3 Single Snaps
9 Two Snap Conductors
1  Three Snap Conductor
2 Four Snap Conductors
1 Seven Snap Conductor
1 Orange Jumper Wire (Orange)
1 Yellow Jumper Wire (Yellow)
1 Green Jumper Wire (Green)
1 Purple Jumper Wire (Purple)
1 Gray Jumper Wire (Gray)
1 White Jumper Wire (White)

Installing The PICAXE Programming Editor
 
The PICAXE Programming Editor is the software you will use to program the PICAXE micro-controller installed on the Snap Circuits 8 Pin Socket U14 block (the PICAXE chip carrier). The software contains the flowcharting software, the editor that you can use to write BASIC programs and the compiler for the micro-controller.BASIC is an acronym that stands for Beginners All-purpose Symbolic Instruction Code. It was created way back in the 1960s as an easy to understand programming language to introduce students to computer programming.
 
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 BASIC 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 BASIC so a compiler translates the software you write in BASIC into machine code, or the 1s and 0s that computers can understand.
 
Part needed for this step:
 
Software CD from the Snap Circuits XP or Snap-Micro I kit (if you do not have either of these kits you can order the CD from Elenco or download the PICAXE Programming Editor from http://www.picaxe.com/Software/PICAXE/PICAXE-Programming-Editor/)
 
Install the PICAXE Programming Editor from the Snap Circuits XP or Snap-Micro I software CD (Windows XP/Vista/7). The setup program will auto run when you put the CD in the drive. Click the large button that says “Install the PICAXE Programming Editor software.”
 
 
Insert the Snap Circuits USB Programming Cable into an empty USB port on your computer. Click on the PICAXE Programming Editor icon on your desktop to open the editor.
 
The Options dialog will automatically open (if the “Show options on startup” check box is checked). If it does not, go to View > Options. On the Mode tab, select 08M–this is your PICAXE microcontroller.
 
 
Click on the Serial Port tab and select the COM port where your USB Programming Cable is connected. Click the Ok button to go to the programming editor.
 
In the Programming editor click File and then click New Flowchart to start entering your flowchart.
 
 
This is what a PICAXE Programming Editor flowchart looks like. The flowchart in this example is very simple–can you guess what it does? It will turn a motor that is connected to pin 4 on the PICAXE for 10 seconds. We can take a look at how each step is processed.
 
The “start” terminator is ignored by the compiler, but is useful to you to easily locate the start of your program.
 
The “pause” process tells the PICAXE to wait 1000 miliseconds, or 1 second before proceeding to the next step in the program. When you tell the PICAXE to execute the program, you will notice a 1 second pause before anything happens.
 
The parallelogram flowchart symbol represents data, or input/output. It contains the command “high 4″ and this command will set pin 4 high, which means the microcontroller will send voltage to that pin, or output current to that pin. If you have a motor connected to pin 4 then current from this pin will pass through the motor and the motor will begin to spin.
 

The “pause” process tells the PICAXE to wait 10000 miliseconds, or ten seconds. This means pin 4 will remain high for 10 seconds thus continuing to send current to the motor for ten seconds (the motor will spin for ten seconds).

The data flowchart symbol contains the command “low 4.” It tells the PICAXE to turn the pin off, or to output 0 volts. This will cut power to the pin and the motor connected to it will stop spinning.

If you want to see what the BASIC code looks like, you can click Flowchart and then click Convert Flowchart to BASIC. The code will look like the the following (Note: I added the in-code comments for clarity):

‘BASIC converted from flowchart:
‘C:\DOCUMENTS AND SETTINGS\DESKTOP\SNAPROVERBOT.CAD
‘Converted on 10/30/2011 at 20:53:11

main:
pause 1000     ‘Tells the PICAXE to wait 1000 miliseconds (1 second)
high 4                ‘Sets pin 4 high, which sends current to pin 4 (if there is a motor connected it will spin)
pause 10000   ‘Tells the PICAXE to wait 10000 miliseconds (10 seconds–motor will spin for 10 seconds)
low 4                  ‘Sets pin 4 low, or ouputs 0 volts. This cuts the power to the pin and the motor stops spinning.

 
The PICAXE Microcontroller
 
What’s this PICAXE thingy? The PICAXE is a micro-controller, or a computer on a microchip. It is the computer brain of your Roverbot. It’s not as powerful as the computer in your video game console, or your laptop computer, but it does have circuits for processing, memory, logic, input and output. You can find micro-controllers in many toys, your DVD player, your TV, your microwave oven, and nowadays even in your washing machine and dryer. In your microwave, for example, the micro-controller processes what you punch in on the keypad, outputs information on the display screen, controls the cooking time, the turntable, and the bell when your dinner has finished cooking.
The Snap Circuits block (U14) that serves as the PICAXE carrier is specially labeled to more easily identify the pins on the PICAXE microcontroller chip. Think of the chip as a square bug with eight legs. There is a notch in the top to help you orient the chip and a little dot marks leg 1. Legs and pins can sometimes get confusing, but on the U14 block the legs (and the corresponding snaps the legs are connected to) are labeled in red 1-8 going in the counterclockwise direction. The functions of each leg are labeled in blue.
 
Leg 1 (snap 1): This is the postive (+) voltage input. It can take from 3 volts to 5 volts. You will want to avoid putting more than 5 volts through the PICAXE since this might damage it.
 
Leg 2 (snap 2): S-In. Serial In pin–it is used to download your program to the PICAXE.
 
Leg 3 (snap 3): This pin 4! Luckily the snaps are labeled or the pin numbers could get confusing. Pin 4 can be used as an Input pin or an output pin. In the previous step this is the pin the program set to high to send current to the motor for ten seconds. then the program set the pin low to cut the power to stop the motor from spinning.
 
Leg 4 (snap 4): This is pin 3. It is an Input only pin.
 
Leg 5 (snap 5): This is pin 2. It can be used as an Input pin or an output pin.
 
Leg 6 (snap 6): This is pin 1. It can be used as an Input pin or an output pin.
 
Leg 7 (snap 7): This is pin 0. It is an Ouptut only pin. It is also the Serial Out pin. This pin will also be used when downloading your program to the PICAXE.

Leg 8 (snap 8): This is GND or Negative (-) for the PICAXE

 
Snap Circuits Rover
 
Now that you have installed the PICAXE Programming Editor and learned how to write a simple program, its time to starte building your robot. There are three basic parts that you need to build a robot: a power source, a brain (the PICAXE of course) and a means of locomotion.
The Snap Circuits Rover is one example of locomotion. It has advantages and disadvantages.Advantages:It is a ready-made vehicle. In other words, you don’t have to build a vehilce–it is already built for you.It has two motors, one on the right side and one on the left side. Each motor is connected to the front and rear wheels by a series of geers (the geering was added in to slow the Rover down rather than a need for extra torque) so that the right motor turns the right front and rear wheels, and the left motor turns the the left front and rear wheels. In the first picture You can see the front of the rover as well as the gears that connect the left side wheels to the left side motor.
 
It is designed to have the Snap Circuits base plate connected directly to it. It is also designed so that power and motor control are easily connected with Snap Circuits jumper wires. The following picture picture explains the function of each snap. on the back of the rover:
 

The rover has a battery compartment for six AA batteries to power the motors with 9 volts.Disanvantages:It is not designed to have attachments such a robotic grabber arm attached to it.You must be careful to design your circuit so that you do not accidently pass the 9 volts from the rover’s battery pack through the PICAXE microcontroller since this will most likely damage the PICAXE.
 
The Voltage Regulator
 
The simplest way to power the rover and power the PICAXE is to use two different power supplies that share a common ground. To power the PICAXE, you can use the Snap Circuits B5 block. The advantage to using this block is you can connect a standard 9 volt battery to the block and it will deliver a reliable 5 volts to the PICAXE through L7805 voltage regulator circuit (see circuit schematic). The B5 also has two 5 volt outputs–one to power the PICAXE and one that you can use to power another device.
Now you have a convenient way of powering your PICAXE with a reliable 5 volts from the B5 block. As a safety feature for the PICAXE, it would also be a good idea to keep the 9 volts from the rover separate from the PICAXE in case while you are building and testing the circuit something gets connected the wrong way. Thus for this build you will use an H-bridge. It has special circuitry inside it that will prevent the 9 volts from the rover’s battery pack from accidently passing through the PICAXE.
 
The H-bridge
 
This  is a simplified diagram of an H-bridgecircuit:
 The motor in the center is connected to 9 volts of power and ground by four switches (S1, S2, S3, and S4). With all four switches off, the motor will not get any power and the motor will not turn.
 
The switches can be turned on in pairs:
 
S1 and S4 or S3 and S2 to allow current to pass from the 9 volt batteries through the motor to negative or ground.
 
If you close switches S1 and S4, current will flow through the motor and it will turn in one direction.
 
If you close switches S3 and S2, current will flow through the motor and it will turn in the opposite direction.
 

The H-bridge is a very simple circuit. Unfortunately it would be impractical to use manual switches to drive a motor. Several companies make H-bridge integrated circuits (ICs) that are easy to use by simply applying power to a particular pin also called “setting the pin high” to drive the motor in one direction. Cutting the power to that pin and applying power to another pin will drive the motor in the opposite direction. The circuitry inside the H-bridge ICs is somewhat complicated, so most folks will choose to use an H-bridge IC rather than building the circuit themselves.

Above is the Snap Circuits Motor Control IC, or H-bridge. At the top of the figure you can see the electronic schematic of the Motor Control block. On the lower left you can see a picture of the block. The lower center shows the function of each snap for the block and on the lower right is a description of what each snap does.
 
Build the Circuit for the Roverbot
 
Build the circuit as shown in the diagram.
 
 
Parts needed:
 

10 X 7 Plastic Base Grid
Snap Circuits Rover
9 volt Battery Block B5
Motor Control IC U8
8 Pin Socket U14 With PICAXE 08m Installed
4 1K Ohm Resistors R2
Slide Switch S1
USB Programming Cable
(You may substitute the Snap Circuits USB to DB9 Converter and the Snap Circuits DB9 Programming Cable if you do not have the USB Programming Cable)
Snap Circuits Micro Software CD
3 Single Snaps
9 Two Snap Conductors
1  Three Snap Conductor
2 Four Snap Conductors
1 Seven Snap Conductor
1 Orange Jumper Wire (Orange)
1 Yellow Jumper Wire (Yellow)
1 Green Jumper Wire (Green)
1 Purple Jumper Wire (Purple)
1 Gray Jumper Wire (Gray)
1 White Jumper Wire (White)

Here’s what the roverbot will look like:

Program the Roverbot
 
Create this flowchart in the PICAXE Programming editor.


I’ve divided up each function into columns to make the flowchart easier to read.

 
In the first column under “start” are the commands to test the Roverbot’s left forward motor. This will cause the Roverbot to turn right.
 
Under the label “Test left backward” are the commands to turn the Roverbot’s left motor backwards. This will cause the Roverbot to turn left.
 
The next four columns are the commands to test the right motor turning forward and backward, then turn both left and right motors forward (Roverbot rolls forward), and finally turns both motors backwards (Roverbot rolls backwards).You can also convert the flowchart into BASIC program code.
 
Click Flowchart and then click Convert Flowchart to BASIC. The following is what the code will look like in BASIC (I added the comments in the code to describe what the code does):
 
‘BASIC converted from flowchart :
 
‘C:\DOCUMENTS AND SETTINGS\DESKTOP\SNAPROVERBOT.CAD
‘Converted on 10/30/2011 at 20:53:11
main:
‘Snap Rover programmable robot

‘Test left forward
  pause 1000
  high 0
  pause 2000
  low 0
‘Test left backward
  pause 1000
  high 1
  pause 2000
  low 1
‘Test right forward
  pause 1000
  high 2
  pause 2000
  low 2
‘Test right backward
  pause 1000
  high 4
  pause 2000
  low 4
‘Test forward
  pause 1000
  high 0
  high 2
  pause 2000
  low 0
  low 2
‘Test backward
  pause 1000
  high 1
  high 4
  pause 2000
  low 1
  low 4
‘End program
  stop
 
The code is very simple but should demonstrate how easy it is to program the Roverbot.
 
To run the program, make sure the Snap Circuits Slide Switch S1 is switched off else the program will execute while the program is still downloading to the PICAXE and may accidentally disconnect the programming cable as the Roverbot runs through the motor tests. Next, make sure that the Snap Circuits 9 volt Battery Block B5 is switched on or the program will not download to the PICAXE. Connect the Snap Circuits USB Programming Cable to your computer.
 
(Using the DB9 to USB cable):
1.  Connect the yellow snap to the S-In snap on the Snap Circuits 8 Pin Socket U14 block (the PICAXE chip carrier).
 
2.  Connect the red snap to the S-Out snap on the Snap Circuits 8 Pin Socket U14 block (the PICAXE chip carrier).
 
3.  Connect the black snap to the GND, or negative (-) snap on the 8 Pin Socket U14 block (the PICAXE chip carrier).
 
In the Programming Editor click PICAXE and then click Run. A status bar will display to show the progress of the download of the program to the PICAXE.Wait a minute or so after the program finished downloading, then place the Roverbot on the floor a safe distance from any obstacles. Then switch the Snap Circuits Slide Switch S1 to on. When you are ready to watch the motor tests, switch on the Snap Circuits 9 volt Battery Block B5 and watch the Roverbot perform the motor tests.
 
 
For further activities with you Roverbot, see my Instructable, Dance Dance Roverbot! Use a PICAXE 08M to create a simple, programmable, light activated, dancing robot out of Snap Circuits:
 
 
 
 
 

Fun With Snap Circuits 7: History is a relay of revolutions

In 1947, Grace Murray Hopper was working on the Harvard University Mark II Aiken Relay Calculator (a primitive computer). On the 9th of September, 1947, when the machine was experiencing problems, an investigation showed that there was a moth trapped between the points of Relay #70, in Panel F.  The word went out that they had “debugged” the machine and the term “debugging a computer program” was born.

[Although Grace Hopper was always careful to admit that she was not there when it actually happened, it was one of her favorite stories.]

CLICK ON DIAGRAM TO SEE BETTER DETAIL! (Source: How Stuff Works)

 

What’s a relay? You’ve probably seen a relay race where one runner hands off a baton to another runner. Similarly, an electronic relay hands off control from one circuit to another. A relay is a very simple device consisting of an electromagnet, an armature (a switch that closes when attracted by the electromagnet), and a spring that is connected to the armature. You can see in the diagrams above how the relay works.

In Figure 1 above, there are two circuits. The first circuit is a battery (3 volts), a switch and an electromagnet. The second circuit is a battery (6 volts), a light bulb and the relay’s armature. While the switch to the electromagnet is off, no current can flow from the 3 volt battery through the electromagnet. So, the armature-switch is off and no current can flow from the 6 volt battery to power the lamp in the second circuit.

In Figure 2 the switch to the electromagnet circuit is switched on. When current from the 3 volt battery flows through the electromagnet, the electromagnet creates a magnetic field that attracts the armature to close the circuit to the lamp. Now current can flow from the 6 volt battery to the lamp, and the lamp lights up.

If you look closely at Figure 2, you’ll notice that while the armature-switch is closed allowing the current in the lamp circuit to flow from the 6 volt battery to the lamp, it does not come into contact with the electromagnet so, the 6 volts from the lamp circuit cannot flow into the electromagnet circuit. Thus, the 3 volts in the electromagnet circuit and the 6 volts in the lamp circuit remain separate.

CLICK ON DIAGRAM TO SEE BETTER DETAIL!

Above is the electronic schematic diagram of a relay. The curly line represents the electromagnetic coil and the vertical lines represent the metal core the coil is wrapped around. The switch at the top of the diagram represents the armature.

CLICK ON DIAGRAM TO SEE BETTER DETAIL!

Above is the electronic schematic of the circuits from figures 1 and 2.

The above diagram shows how to build the circuit from Snap Circuits.

When you press the press switch (S1) you will hear the relay click as current passes from the 3 volt battery block (B1) through the electromagnet. The electromagnet creates a magnetic field that attracts the metal armature and closes the circuit to power the lamp. This allows current to flow from the two 3 volt battery blocks (also labeled B1)connected in series (for a total of 6 volts) through the lamp and it lights up.

When you release the press switch you will hear the relay click again since the current has been cut from the electromagnet. This causes the electromagnetic field to collapse so the armature is no longer attracted by the electromagnet and the spring attached to the armature returns the armature to its rest position. This opens the lamp circuit which cuts the current from the batteries to the lamp and the light goes out.

Here’s another circuit you can build that includes the snap circuits motor:

Here’s a video of the circuit in action:

 

Fun With Snap Circuits 6: Resistance Is Futile. You Will Be Assimilated.

We cannot, by total reliance on law, escape the duty to judge right and wrong…. There are good laws and there are occasionally bad laws, and it conforms to the highest traditions of a free society to offer resistance to bad laws, and to disobey them.  ~Alexander Bickel

While you were building the LED project from my last post you noticed that you had to add a 100 ohm resistor to limit the current flowing through the LED to protect it. If you put too much current through an LED, it will burn out. With a POP! And sometimes pieces of plastic will fly off (“you could put an eye out with that”). And it will stink. Then you’ll have to buy a new LED.

Going back to the waterpipe analogy:

When water flows through a pipe, the pipe offers very little resistance to the flow of water.

If, however, a bunch of rocks are inserted into the pipe, this will increase the resistance against the flow of water through the pipe:

As electrons flow through a wire or conductor, there is very little resistance to the electron flow. If you were to connect an LED directly to the Snap Circuits battery block without a current limiting resistor too much current will flow throught the LED and POP! Another way to think of it is filling a water balloon with a garden hose. If you put a kink in the hose this will limit the flow of water making it easy to fill the water balloon, but if you let go of the kink in the hose, the water balloon will fill too quickly and burst.

There are five Snap Circuits resistors: the 100 ohm (the one you used in the LED circuit),  1K ohm (“K” stands for “Kilo” which means “one thouand” so, 1K ohm means “one thousand ohms”), 5.1K ohm, 10K ohm, and 100K ohm resistors.

100 Ohm Resistor

1K Ohm Resistor

5.1K Ohm Resistor

10K Ohm Resistor

100K Ohm Resistor

The greek letter Omega is used to represent the ohm unit

Ohm is a unit of electrical resistance. The higher the ohm value, the higher the resistance. The Snap Circuits 100K ohm resistor (100,000 ohm resistor) has a much greater resistance value than the 100 ohm resistor.

There are wirewound resistors, metal film resistors, and several other ways to manufacture resistors, but the most common is the carbon resistor and appears to be the kind of resistor used in Snap Circuits. The materials used in carbon compositon resistors are a combination of finely ground carbon dust similar to the graphite in your pencil (the conducting material) and clay powder (the non-conducting material). By mixing different amounts of carbon and clay together resistors are made to have different resistance values. If more carbon (the conducting material) is added, the resistor will have lower resistance. Which Snap Circuits resistor will have more conducting carbon powder and therefore lower resistance, the 100 ohm resistor or the 100K ohm resistor?

Metal wires, or connecting leads are attached at each end of the resitor and the resistor is protected by a plastic or paint insulating coating.

 

Connecting Resistors in Series 

Since there are only five kinds of Snap Circuits resistors, what would happen if you needed to limit the current flowing through an electronic component but didn’t have a single resistor that matched the value of the resistance that you needed? Let’s say that you needed 200 ohms of resistance. If you used the 100 ohm resistor, it won’t limit the current enough and you might burn out the component. If you used the 1K ohm resistor, it might limit the current too much and the circuit might not work. To solve this problem you can connect two 100 ohm resistors in series to limit the current by two hundred ohms.

In the diagram below, imagine that the battery is a pump and the paddle wheele is a resistor limiting the current:

 

In the next diagram, there is still a single battery, but a second paddle wheel has been added to represent a second resistor connected in series:

 

If the first paddlewheel, or resistor labeled “R1″ is 100 ohms and the second resistor  labeled “R2″ is 100 ohms, then the total resistance introduced into the circuit is 200 ohms.

Connecting Resistors in Parallel 

Now let’s say that you only needed 50 ohms resistance, but the lowest ohm value Snap Circuits resistor is 100 ohms. You can connect two 100 ohm resistors in parallel and reduce the resistance to 50 ohms. The diagram below may help you to understand what is happening with the two 100 ohm resistors in parallel:

 
The resistor is a useful electronic component. Resistors can be connected in series to increase resistance and they can be connected in parallel to reduce resistance. They can be used to protect other electronic components from overvoltage and they can be used in combination with other components to change the behavior of these components in a circuit.

Fun With Snap Circuits 5: Let There Be Light–The Sequel

“On life’s journey faith is nourishment, virtuous deeds are a shelter, wisdom is the light by day and right mindfulness is the protection by night. If a man lives a pure life, nothing can destroy him.”

–Buddha

In my previous post where I hacked the Spy Video TRAKR, I needed to test the program that I wrote using a Light Emitting Diode (LED) that I scavenged from an old computer. When I pressed button A the LED lit up, but when I pressed button B the LED did not light up. LEDs allow current to flow in on direction but not in the reverse direction. To understand why, build the circuits in projects #7 and #8:

Here’s some additional information about Light Emitting Diodes by Ariel Churi from Sparkle Labs:

Light Emitting Diode from Sparkle Labs on Vimeo.

 

And Now For Something Completely Different…

‘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: http://www.spygear.net/help/faq.php

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:

http://hackaday.com/2010/05/24/bamf2010-spy-trakr-no-lasers-14861-cheaper/

http://hackaday.com/2010/08/27/spy-video-trakr-first-impressions/

http://hackaday.com/2010/08/30/spy-video-trakr-the-teardown/

http://hackaday.com/2010/09/02/spy-video-trakr-software-and-first-hack/

Here are the FCC Pages for the TRAKR

https://fjallfoss.fcc.gov/oetcf/eas/reports/ViewExhibitReport.cfm?mode=Exhibits&RequestTimeout=500&calledFromFrame=N&application_id=545152&fcc_id=%27N3ESPYVIDEOTRAKR1%27

https://fjallfoss.fcc.gov/oetcf/eas/reports/ViewExhibitReport.cfm?mode=Exhibits&RequestTimeout=500&calledFromFrame=N&application_id=884190&fcc_id=%27N3ESPYVIDEOTRAKR2%27

Here’s additional documentation:

W55VA91 Design Guide:

http://dl.dropbox.com/u/4295670/W55VA91_DesignGuide%28fullset%29%20-%20A4.pdf

ARM926EJ-S Technical Reference Manual:

http://infocenter.arm.com/help/topic/com.arm.doc.ddi0198e/DDI0198E_arm926ejs_r0p5_trm.pdf

ARM926EJ-S Technical Reference Manual Online Version:

http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0198e/index.html

Information on the nRF24L01 (Radio Transceiver Chip) :

Data Sheet: http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01

Product Specification: http://docs.google.com/viewer?a=v&q=cache:ANWvWgCEyaMJ:www.nordicsemi.com/eng/content/download/2730/34105/file/nRF24L01_Product_Specification_v2_0.pdf+nordic+nRF24L01+pdf&hl=en&gl=uk&pid=bl&srcid=ADGEESjvGkOhVwt8_Dp3LKqfqZeASZGVzVX04R0alriMhtZwfG4NXR5ufvPKsYPNKC-FgnVFwibbZbhyXNJ_YDYMNdSkiMG-LrY544m2CsxP1ApsJ3LVzEBT2u_mmwS8yxC39q1PbF6R&sig=AHIEtbR-xbXuUy0jM2aGhlFt8V7WVd9QHw

TRAKR Remote Startup Radio SPI Traffic: https://raw.github.com/gist/1250231/trakr-remote-startup.txt

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

http://www.eetimes.com/design/embedded/4007119/Building-Bare-Metal-ARM-Systems-with-GNU-Part-1–Getting-Started

We’ve also created Wiki for the Trakr:

http://www.trakrhakr.com/wiki/

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: http://www.instructables.com/id/Uni-Directional-WIFI-Range-Extender/

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:

http://pille.iwr.uni-heidelberg.de/~mindstorms/data/GrabberArm.pdf

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

UPDATE:

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.

http://www.sparkfun.com/products/10527

Download and Install the C Language Compiler for the Trakr

UPDATE:

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:

http://www.spygear.net/help/files/TRAKR_APP_PRIMER_V1.2.zip

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:

;C:\Trakr\Tools\bin;C:\Trakr\Tools\utils

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
setup
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
make

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
       if(keyState&KEY_INPUT1)
        {                        //Button A pressed (motor forward)
            JAPI_SetIoHigh(GPC0);//Set GPC0 pin high (3.3v)
         } else {
            JAPI_SetIoLow(GPC0); //Switch off pin GPC0
        }
       if(keyState&KEY_INPUT2)
        {                        //Button B pressed (motor reverse)
            JAPI_SetIoHigh(GPC1);//Set GPC1 pin high (3.3v)
         } else {
            JAPI_SetIoLow(GPC1); //Switch off pin GPC1
        }
       if(keyState&KEY_HOME)
        {                        //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
 JAPI_SetIoLow(GPC0+GPC1);
}


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

TRACKR_PATH = C:/Trackr
PROGRAM_NAME = trakrmotorcontrol
PRETTY_NAME = trakrmotorcontrol
OUTPUT_PATH = ./Intermediate
OUTPUT_NAME = $(OUTPUT_PATH)/$(PROGRAM_NAME).elf
INTERNALS_PATH = ../Internals

SOURCES = app.c 
S_OBJECTS = $(OUTPUT_PATH)/app.o 

OBJECTS = $(S_OBJECTS) $(INTERNALS_PATH)/trakr.a

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

TOPMEMORY=0xFFE7C000
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 

$(OUTPUT_NAME): $(OBJECTS) 
	@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

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

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



# 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:

http://vimeo.com/24143672

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:

UPDATE:

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 http://www.sparkfun.com 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!

Fun With Snap Circuits 4: Let There Be Light!

“Some people believe that when you die there is a wonderful light. As bright as the sun but it doesn’t hurt to look into it. All the answers to all the questions you want to know are inside that light. And when you walk to it… you become a part of it forever.” –Poltergeist

So far we’ve taken a look at the Snap Circuits basic components such as the battery holder, switches, and wires (snap Conductors). We probably ought to try putting together a simple circuit, which will give us an opportunity to take a look at how each project is discussed in the Snap Circuits manuals. One of the first Snap Circuit projects (depending on the Snap Circuits set you have) is a simple circuit that will switch a lamp on and off. Here’s what the manual page looks like:

Snap Circuits Project #1 (Source: http://manuals.elenco.com/manuals/sc-100%201-101.pdf)

As you can see the projects in the manuals are self explanatory. Three electronic components, the battery holder, the slide switch, and a lamp are connected together with snap Conductors on the plastic base grid.

The next series of photos are a step by step build of the circuit:

Base Grid

3 Snap Conductor on Base Grid at C2, E2

Snap Circuit Lamp at C3, C5

Snap Circuit Slide Switch at E3, E5

Snap Circuit 3 Volt Battery Pack at C6, E6

2 Snap Conductor at C5, C6

2 Snap Conductor at E5, E6

2 Snap Conductor at C2, C3

 

2 Snap Conductor at E2, E3

When you are done connecting all the components you’ll notice that the labeling on the Snap Circuits blocks look almost exactly like the electronic schematic.

Lamp Circuit Schematic

You can click on this link to see an animation of the current moving throught the circuit (place your mouse cursor and left click on the switch to turn the circuit on or off).

You can also build the lamp circuit online by clicking on this link. Here’s what the circuit might look like when you are done:

When you flip the switch watch what happens!

Unfortunately the Java applet has only a few components to use to build circuits, but is useful right now to help you understand current moving through a circuit.

Fun With Snap Circuits 3: Get Wired!

If hairs be wires, black wires grow on her head. –William Shakespeare (Sonnet 130)

Snap Circuits has several ways to connect the various electronic components together. Each component could be snapped to another, but often, becuase the components are different physical sizes or may be separated by a distance, you will need to use a Snap Conductor–the snap circuits equivalent of an electrical wire.

In the water pipe analogy, electrical wiring is the pipe through which the current flows. Some Snap Circuits conductors actually look like electrical wires with snap connectors attached at the ends and are called “Jumper Wires.”

Yellow Snap Circuits Jumper Wire

Mostly, however you will use “Conductors” with one or more snaps.

Conductor With Two Snaps

Conductor With Three Snaps

Snap Circuits Conductors come with a single snap all the way up to seven snaps. A conductor with a single snap is often used when electronic components need to be stacked on top of each other).  A Conductor with seven snaps may be used used when two electronic components are far from one another on the base grid.

Follow

Get every new post delivered to your Inbox.