Editing Compass Vibro Anklet Directions

How to make a vibrating compass anklet

These steps describe how to make a vibrating compass anklet which lets you tell absolute direction all day long.  The project is described in [[Compass Vibro Anklet]] which is mostly a description of Eric and Skory's work.

Skory took the time to sit down with me at [[Sensebridge]] and explain how they did it, so I wrote this up so that others can see it too.

I’m going to work on assembling an anklet myself using these steps.  When I do, I’ll update the directions with what I find.

If you want to make a compass belt instead of a compass anklet, it should be easy: use a longer ribbon cable, space the motors out wider, and cut longer strips of fabric.  Everything else would be the same.

Hope this is helpful!  Feedback on this document is very welcome.--[[User:Ted|Ted]] 01:29, 4 May 2009 (PDT)

==Components==

You’ll need all the following components:

'''Arduino:''' a controller to run everything.  (I’m using the Arduino-clone [www.moderndevice.com Really (RBBB) Bare-Bones Board])

'''Shift Register:''' regulates power and switches which pager motor is running.  (I’m using part number TPIC6B595)

'''Compass Chip:''' determines compass direction and feeds that information to the Arduino.  
(I’m using an HM55B from Parallax)

'''Battery:''' For power.  You’ll need something that will source at least 3.325V and about 700mAh. (I bought a Polymer Li-Ion Battery 3.7V 875mAh from [http://www.all-battery.com/polymerli-ionbattery37v875mah383562.aspx here)

'''Pager Motors:''' Eight vibrating motors.  Whichever one is northmost will vibrate.  (I bought ROB-08449 vibration motors but they were crazy overpriced - $7 each, it's better to get them from [www.pagermotors.com pagermotors.com])

'''Proto-board''' a thin board with a grid of pads into which one can solder the components, which you will need to cut down to size (available at an electronics store).

'''Ribbon Cable:''' One or possibly two twelve inch lines of Ribbon Cable wire to connect the controller to the pager motors. (available at an electronics store)

'''Connector/Switch:''' A power switch or connection for the power supply to act as an on/off switch for the device (available at an electronics store)

'''Connector:''' A 9-pin connector to connect the shift register to the pager motor assembly.  (available at an electronics store)

'''Wiring:''' Wire & solder & electrical tape to connect everything  (available at an electronics store)

'''Elastic:''' The main body of the anklet armature.  Two inches wide.  About 12 inches of elastic, plus a few three inch pieces to make pockets for the controller and the battery. (get from a fabric store)

'''Zipper:''' A zipper so that you can close every up when you’re not tinkering.  About 12 inches of zipper. (get from a fabric store)

'''Velcro Strip:''' To close the anklet.  About an inch wide, and three or four inches long. (get from a fabric store)

'''Felt Strip:''' To connect to the ankle on the other side and hold onto the Velco-backed motors.  About an inch wide and twelve inches long.

'''Foam:''' A thin strip of foam. Goes between the felt and the elastic to absorb vibration (making it easier to distinguish which motor is vibrating and to make the device quieter).  About an inch wide and twelve inches long.

'''Velcro Patches:''' Eight little patches of Velcro, about half an inch square each.  These will attach the pager motors to the anklet in a way that lets you move them around the anklet so that each motor is in the right place.

'''Cloth Patches:''' Eight little patches of cloth, about half an inch square each.  These will connect to the Velcro patches to make little pockets for each pager motor.  The cloth patch will be the part that touches your ankle, so pick something soft.

'''Casing for controller assembly:''' Casing to hold the final controller assembly.  It may be possible to adapt this from a scrounged plastic box of some kind. (make or improvise)

==Tools== 
Computer to program Arduino

FTDI Cable (or BUB Board from Modern Device) to program Arduino

Soldering tools

Breadboard for initial controller build

Possibly LEDs for initial controller build

Saw to cut the proto-board to size

Wire stripper

Scissors

Sewing machine


==Overview of Compass Vibro Anklet==
The vibrating compass anklet has three basic parts: a '''controller''', a '''pager motor array''', and an '''armature'''.

The '''controller''' controls the motors, provides power and data and sensory input.  The controller consists of an Arduino (a programmable board that uses the ATMega processor + Arduino bootloader, which is designed for exactly this kind of project), a Shift Register (which takes a single byte of data from the Arduino and uses this to trigger a single motor), the compass chip (which connects to the Arduino), and the battery (which connects to the Arduino).  Basically, everything in the controller connects to the Arduino, and then the shift register connects to the pager motor array.

The '''pager motor array''' consists of eight pager motors (little vibrating motors) and the wire to connect them up.  The pager motor array receives power and signal from the shift register, which activates one of eight pager motors.  The pager motors are little vibrating motors that come out along the length of the ribbon cable.  All of the motors get power from the same line, but only one will be grounded at a time, so only one will run at a time.

The '''armature''' is the housing for the whole thing.  It’s an elastic anklet, with a zipper and housing for the controller and the pager motor array.  The motors go on the inside of the armature, and will need to have an adjustable location.

==Assembly Summary==

There are four basic parts to making the Vibrating Compass Anklet.  After each part, test everything to make sure it works.  Probably you’ll go through each step several times to get it right, and hopefully you’ll find ways to improve the design and the creation.

'''Part One: Assemble Controller on Breadboard'''

'''Part Two: Build Pager Motor Array'''

'''Part Three: Make Armature'''

'''Part Four: Assemble Controller on Board'''

'''Part Five: Put Assembly Into Armature'''

==Part One: Assemble Controller on Breadboard==

The controller has five parts: the Arduino, the shift register, the compass chip, the battery, and the pager motor connector.  The pager motor connector connects to the shift register.  Everything else connects to the Arduino.

Here’s a really fake diagram of that:

          
    compass chip
          |
   Arduino   ---   Shift Register ---  pager motor connector
          |
      battery

To assemble the controller on the breadboard:

1. Connect the battery to the Arduino.  The wires from the battery go into the power and ground for the Arduino.  If the battery includes a connect, you may just want to get a matching connector for the other side and attach that to the Arduino.  Alternately, if you’re feeling ambitious you could add a power switch here.

2. Connect the compass chip to the Arduino.  You’ll connect three data pins, plus power and ground, to the Arduino.  One pin is input/output: bridge together the “in” pin and the “out” pin from the compass and connect them to the same pin on the Arduino.  The other two are the clock pin and the enable pin.  These all connect to the Arduino’s output pins.  Note which pins you use, since you’ll need to update the code with that information.

3. Connect the shift register to the Arduino.  You’ll connect five data pins, plus power and ground.  One of the data pins on the shift register is the enable pin.  This pin must connect to a pin on the Arduino which is capable of PWM.  (PWM lets a digital signal simulate analog, and the enable pin needs analog input if you want to be able to vary the speed of the motors.)

4. Connect the shift register to the header socket.  Solder ribbon wire to the shift register’s output and give it a few inches of wire.  On the other side of the ribbon wire, solder a 9-pin header socket.

5. Install the Arduino IDE on your computer.  You can get the IDE here: http://www.arduino.cc/en/Main/Software

6. Connect your computer to the Arduino with a data cable (it is recommended to unplug the battery when you do so).  Make sure you’ve got a data connection.  Try running Hello World or a similar program to make sure you’ve got everything working.

7. Download the code into the Arduino.  The code is on the wiki.  (link?)  You will probably need to modify the Arduino code based on what you connected on the Arduino: if you connect anything differently, change the Arduino code so that it connects to the right place.  This shouldn’t be a very difficult change in the code: just change the constants to reflect where you attached each wire.

8. For testing purposes, you may want to connect the shift register to LEDs and try moving around with the breadboard.  Each LED in turn should light up as you turn around.    Note that the light will go off if you hold it in one place for a while.  This is intentional: when the motors are vibrating against your ankle, they can get very annoying and itchy if they run all the time!

When you’re done with this, you’ll have a breadboard that includes all the logic to make the device work.  You’ll have a powered digital compass.  Most likely, you’ll want to test the compass with LEDs instead of motors at this point because they’re easier.

This is a working sensor!  Now you need a display and an armature.

==Part Two: Build Pager Motor Array==

The pager motor array is logically pretty simple, but it’s tricky to solder together properly.

The pager motor array consists of a ribbon cable, eight motors, and a connector with at least nine pins: one for power and eight for ground.  Each pager motor will connect to one of the ground lines, and all pager motors connect to the power line.  The pager motors are spaced somewhat evenly along the length of the ribbon cable.

Note that the exact dimensions will depend on the size of the finished product.  Your ribbon cable may be shorter or longer than twelve inches.  If you’re making this for yourself, measure the circumferences of your own ankle.  Plan on making something that big, and add a few inches for connections and extra space.

1. Connect the ribbon cable to the connector.  Strip the ends of the ribbon cable and solder them into the connector.

2. Peel off a little bit of the bottom ground wire of the ribbon cable.  Strip the end of the wire.  Solder the line to the ground line of the first pager motor.

3. Splice off a wire from the power line: strip some of the cable, solder another wire to the exposed metal, and wrap the connection with electrical tape for stability.  Connect the spliced wire to the power line of the first pager motor.

4. Repeat steps 2-3 for each pager motor along the length of the ribbon cable.  Peel of a little more from the next ground wire of the ribbon cable and strip the wire to solder to the ground line of the next pager motor.  Splice another wire from the power line in the same place and solder the spliced wire to the power line of the next pager motor.

NOTE: There may be an easier way to solder all this together.  Instead of using one cable and splicing power off for each pager motor, use two separate ribbon cables: one for power and one for ground.  At each pager motor, peel off one wire from each ribbon cable.  Eight pins will connect to the ground, and all of the ribbon cable for power will get connected together at the end, and all connect to a single pin.  This is harder to describe, but easier to assemble.  If this works well, the instructions will be updated with steps for how to do this instead.

When you’re done, you should have a ribbon cable that gets thinner and thinner as it moves away from the connector, as wires split off to connect to each of the eight pager motors.  Connect it to the controller and try it out!  

To really test it, make a quick armature with some elastic and walk around with it.  This is actually a fully functional vibrating compass!  It’s just that it would be impossible to wear for long periods, so you need to put the compass into something more complex, and make an armature suitable for wearing long-term.

==Part Three: Make Armature==

The armature is cloth part that will house everything.  It consists of a folded-over piece of elastic, a zipper, felt and foam to contain the pager array comfortably, a Velcro strap to close the anklet, and elastic pockets for the controller and battery.

Note that the exact dimensions will depend on the size of the finished product.  Your strip of cloth may be shorter or longer than twelve inches.  If you’re making this for yourself, measure the circumferences of your own ankle.  Plan on making something that big, and add a few inches for connections and extra space.

1. Cut a twelve-inch length of elastic and fold it in half.

2. Sew each end of the elastic closed.  You should now have something like a long floppy canoe.

3. Sew the zipper onto the elastic on each side of the fold, at the top.  You should have a long tube that you can unzip into a long floppy canoe.

4. Pick one side of the elastic to be the inner side, which will go against your ankle.  Lay a thin layer of foam onto this side, and then a layer of felt.  Sew this down so that it all stays in place.

5. Cut vertical slits into the inner side, through the elastic, the foam and the felt.  Sew these open so that they’re stable.  They should end up a little like button holes.  The vibrating motors are the buttons: they’ll poke out through these button holes to press against your leg.

6. On the outer side of the elastic, on one end of the anklet, sew two strips of elastic to make pockets.  One will hold the controller, the other will hold the battery.  It’s better to sew these on like a loop, rather than a wave: loop them back under so that the stitching is on the inside of the battery.  This is a little harder to do, but it means that the pressure from the pockets will pull the elastic out instead of bunching it up.

7. On one end of the anklet, on the outside of the elastic, sew a couple inches of fuzzy velcro. On the other end, sew a couple inches of pointy Velcro out past the edge. Ensure that the dimensions of these allow you to wrap the armature around your ankle and then fasten it on.

You should now have an anklet that can hold all the wiring on the inside of a zipped-up pocket, which allows pager motors to poke into your ankle to vibrate, which has two elastic pockets for the controller and battery, and which you can wear comfortably with the Velcro strap.

NOTE: Skory is working on an better design for this, where the foam and felt are inside the belt.  With this improvement, the only thing that touches your skin will be the armature, so it should be easier to take all the electronics out and wash all the cloth so it doesn’t get gross and sweaty.  If this works well, the instructions will be updated with steps for how to do this instead.

==Part Four: Assemble Controller on Board==

This step pretty much involves putting the controller together again in a way that is more compact so you can wear it around.

The compass chip still needs to be horizontal, even though the rest of it will probably end up vertical.  Compass chips needs to be horizontal to work.  At least, two-axis compass chips do.  A good three-axis chip wouldn’t necessarily need to be horizontal to work, but 3D compass chips are prohibitively expensive.

1. Solder the shift register onto a minimally sized rectangle of proto-board.

2. Solder the Arduino board on top so that the shift register is sandwiched in between.  If you do this right, most of the data connections will actually fit together perfectly.

3. Solder the compass chip at the tip of the other two boards so that the compass chip is horizontal while the Arduino is vertical.  Connect the compass chip to the Arduino.

4. Make a connection from the Arduino to the battery (again, this should probably involve your switch).  The battery will go in a separate pocket, so use a few inches of wire on each side.

5. Make a connection from the shift register to the connector for the pager motor array. Again, one pin needs to have power, and the other eight will connect to the eight drains on the shift register. Soldering the little wires in for this step is absolutely horrible, but don't worry too much if you don't solder the pins in the right order, you can change to code later to compensate.

At this point, you should have a compact little stack of electronics plus a battery.  It should still work the same way it did when everything was on the breadboard, but now it will fit in the armature.

You will need some kind of casing for the stack of electronics.  You may be able to modify an existing plastic box for this, or make your own.

NOTE: Skory and Eric are working very hard on a PCB which will make this step a lot easier and remove a lot of the wiring and difficult soldering and hassle for this.  If this works well, the instructions will be updated with steps for how to do this instead, along with how to purchase these PCBs.

==Part Five: Put Assembly Into Armature==

Now put it all together.

1. Glue squares of Velcro and cloth onto the end of each pager motor. Any good fabric glue will do, but be patient if it's slow-setting. (Alternatively, for another dollar or two, you can by square-inch velcro stickers, the adhesive on which seems to be good enough to hold the cloth on the other side of the motor.)

2. Put the whole pager motor assembly into the pouch, with just the connector sticking out of one end of the zipper.

3, Put the controller assembly and batteries into the appropriate pockets and connect them up.

4. Push the pager motors through the button-holes in the armature.  Wear the anklet and test it a little to find where each motor should go.  Since ankles are so irregularly-shaped, you’ll need to adjust which button-holes get pager motors by trial and error.

You should now have a compass anklet that you can wear comfortably in daily life!