Introduction: Geek Spinner

Fidget spinners are fun, and you can find one at about any check-out counter for just a few bucks these days, but what if you could build your own? And it had LEDs? And you could program it to say or show whatever you wanted? If that sounds geeky cool, THIS IS THE PROJECT FOR YOU.

I've always been interested in using blinking LEDs to get kids interested in programming. The most simple project with an Arduino microcontroller is to blink an LED on and off. Then you get them to see how fast an LED can blink before it looks like it is on continuously (about 12 millisecond intervals). Then you shake the LED back and forth and you can see it blink again! This phenomena is call "persistence of vision" (POV) and is how this project works. It can lead to discussions of both how the eye works and how incredibly fast computers are.

This project uses a programmable 8-bit microcontroller, eight LEDs, and a coin cell. It spins using a standard skateboard bearing, and uses a Hall-effect sensor and a magnet to determine rotation. It is made using beginner-friendly through-hole parts and can be programmed using the Arduino programming environment. Enough talking, let's get making . . .

Step 1: Gather the Parts, Tools, and Supplies

It is always frustrating to get half-way through a build and find you are missing something. These are the parts I've tried and found to work well. Substitute at your own risk:

Bill Of Materials
=================

Tools and Supplies:
For my workshops, I use SparkFun's Beginner's ToolKit which has everything you need except the tweezers:

  • Soldering iron.
  • SolderWire
  • Flush-cut plyers (I love the $5 Hakko CHP170!)
  • Desoldering braid
  • Super glue

Programming the Attiny (Step 4, not required if you buy this as a kit):

A kit for this project is available on Tindie.com (minus the battery). Purchasing the kit will save you the time and expense of ordering from several different vendors and avoid the minimum PCB order premium. Also, programming an Attiny is not trivial, and if you buy the kit, it will already be pre-programmed. You will also be helping me develop and share other projects in my workshops!

Step 2: Resistance Is Essential.

We are going to assume you have some kit-building experience. If you need some help soldering, head over to www.sparkfun.com/tutorials/213 to brush up or watch the Geek Girl explain it at https://youtu.be/P5L4Gl6Q4Xo. I also have a kit appropriate for beginners at https://www.tindie.com/products/3447/.

I like starting with the resistor because a) they are relatively heat resistant while you are getting into your soldering groove and the iron is coming up to temp, b) they have no polarity, so orientation is not critical, and c) they are the lowest component on the board so sit tight when soldering. There are eight 330-ohm current limiting resistors, one for each of the LEDs. You can do one at a time, or all eight at once.

  • Bend the leads to the width of the pads and insert the resistor.
  • Flip the board over and solder the leads.
  • Trim the leads with flush cuts.
  • Hit them again with the iron if you want them to impress your geek friends.

Step 3: Code?

If you bought my kit, the chip is pre-programmed and can skip to the next step.

Yes, this project needs some code. And, if you were paying attention, in Step 1 I told you that programming an Attiny was not trivial. I use the Arduino, it's programming environment, my AVR programmer, and a pogo pin jig.

The chip can be programmed before soldering in place (photo 2), or after it has been soldered in place using the ISP header on the bottom of the PCB (photo 3). In either case, the programming is as follows:

  • Download the Arduino Programming Environment.
  • Install support for the Attiny 85 from either:
  • Upload the "Arduino as ISP sketch":[File] -> [Examples] -> [Arduino as ISP].
  • Attached the AVR Programming Shield and insert ribbon cable to the Attiny84 position
  • If using the Pogo Adapter, position it on the ISP header on the board. The positive and negative pads are marked so you can orient the header correctly.
  • If using the chip, insert it with pin one toward the USB connector.
  • Select the correct chip:
    • Arduino Tiny: "Attiny 84 @ 8 Mhz"
    • Attiny Core: "Attiny 24/44/84"
      • Chip "Attiny 84"
      • 8 Mhz (Internal)
      • Pin Mapping "Counter Clockwise"
  • Select the Programmer, [Tools] -> [Programmer] -> [Arduino as ISP]
  • Set the programming fuses, [Tools] -> [Burn Bootloader]
  • Upload the attached sketch, [File] -> [Upload using programmer]

The biggest source of errors I get involve not having the pins aligned correctly.

Step 4: Chip It

Now that your chip has code on it, you can install it. The orientation of a DIP ("dual inline package") chip is usually indicated either by a hole adjacent to pin one, or a divot on the end of the chip containing pin one, as is the case here.

  • Bend the leads to 90 degrees by pressing them against a flat surface (photos 1 & 2).
  • Align the chip with the symbol on the PCB and insert the chip (photo 3).
  • Solder one pin on opposite sides, and check that both the chip is flat against the PCB and that the orientation is correct. It gets really hard to fix after this. Trust me on this.
  • Once you are assured it is in correctly, solder the remaining pins and then cut them flush.

Step 5: Switch and Capacitor

The push button goes next to the IC, and the capacitor on the other side.

  • Push the push button into place (ensure it is in the correct orientation).
  • Solder it in place.
  • Clip the leads off the back.

The capacitor does not have an orientation, but if you put the writing side out, your geek friends will know what value you used.

Step 6: Switch and Battery Holder

The switch goes with the level pointing outward. Like the other items, solder two pins in, check that it is seated flat, and then solder the remainder.

The battery holder has marking to show the orientation, but it really doesn't matter. It will, however, require quite a bit more heat than regular leads, and you will want to make sure it seated flat to hold the battery in position (picture 4).

Step 7: LEDs

There isn't a decent project that doesn't include at least one LED. This has EIGHT!

The long lead is positive (anode). There is a "+" mark on the silkscreen, and the pad is square. If you do all eight at once, hold them up to make sure you have all the orientations correct.

  • Solder one lead on each LED.
  • Verify the orientation and that they are seated flat (picture 3).
    • If they are not, press on the case with your thum and re-heat the lead till it snaps in position (picture 4).
  • Solder the remainder.
  • Clip the leads.

Step 8: Check It Out

At this point, we can still check the LEDs and switch out:

  • Insert a battery with the positive side outward.
  • Switch the spinner on and then press the button until all (hopefully) the LEDs are on (see the video).
  • Spin the spinner and see the pattern.If an LED does not light, it may be installed backward, or have been heat-damage. Un-solder it and put a new one in.


Troubleshooting:

  • If no LEDs light:
    • Make sure your battery is good and in the correct orientation.
    • Did you program your chip? Is it in the right orientation? Is it getting hot?
    • Are the LEDs oriented correctly? Use the coin cell across the led solder joints to test them?
  • If the switch doesn't make the LEDs blink:
    • Check the solder joints on the LED.
    • Check the solder joints on the Attiny.
  • If all else fails, take and post high resolution photos of the front and back and ask for help in the comments.

Step 9: Spin Time

The bearing is held in place by soldering the case to the large pad. This takes patience and lots of heat:

  • Use something like coins on a hard surface to position the bearing.
  • Heat both the pad and the bearing shell until you see solder flow onto the case (it takes a bit).
  • Repeat on the other side.
  • Verify that the bearing is aligned correctly by spinning the spinner.
  • Flip the board over and solder two points on the other side.

Step 10: Is This a Revolution?

In order to show messages instead of just patterns, we need to know the position of the spinner in relation to the circle. We will use a Hall-effect sensor and a magnet. This is similar to how combustion engines know when to fire the spark to get the most power. Orientation and alignment of both the sensor and magnet are critical for this to work.

  • The writing on the face of the device faces the bearing matching the silk screen (photo 1).
  • Align the height to just above the bearing (where the magnet in the cap will be).
  • Solder one lead.
  • Verify the height and aliment.
  • Solder the remaining leads.
  • Clip the leads.

If you are using an Omni-pole sensor, you will need to figure out the orientation of the magnet. The best way to do this is to set a mode other than the pattern from the previous step and then find the side of the magnet that starts the LEDs blinking (see video). Glue the magnet with the side that worked facing outward. Double check your work.

Step 11: Balancing Act

If you hold the spinner up horizontally with the battery in, you will see it pivot to the battery side down. Despite my best effort at balancing components, it is still off balance. You can add some weight to the non-battery side using a nut& bolt, or add some solder to the pad.

Step 12: You Are Operational

With your magnet and sensor in place, you are ready to check out the full awesomeness of your Geek Spinner. The mode of the spinner is shown by the LED that is lit on power up or after a button press (D0 - D7). The mode is changed by pressing the button (see video).

int modes = 8;  // number of modes available  
  // 0 -> text "Hello World!"  
  // 1 -> RPM
  // 2 -> time in seconds
  // 3 -> spin count
  // 4 -> spin count (total)
  // 5 -> "lilly pad" pattern
  // 6 -> shape 1 (heart)
  // 7 -> shape 2 (smile)

Step 13: But Wait, There Is More . . .

The "heart" and "smiley" patterns were created by using a polar graph to show how the eight segments would look every 5 degrees of rotation.

By Hand:

  • Download and print the full-resolution image (picture 1).
  • Fill in the blocks to make your image (picture 2).
  • Along the radial, starting a 0, calculate the byte using black = 1, white = 0;
    • The first radial of the heart is 1, 0, 0, 0, 0, 0, 0, 0, so the byte = 0b100000000;
  • Continue until you are done (hint, if your image is symmetrical, you only need to do half).
  • Paste your bytes into the "textAndShapes.h" section of sketch under "shape_1[]" or "shape_2[]".

Using Python:

  • Install Python.
  • Install Python's Image library.
  • Download the attached "readGraph.py" script.
  • Download full-resolution image (picture 1).
  • Open the image in your favorite editor (GIMP or MS Paint).
  • Use the "Fill" command with black color selected to fill the segments you want lit (picture 2).
  • Save the image in the same directory as the "readGraph.py" script and change the file name in the script to match it:
im = Image.open('heart.png')
  • Run the script and paste the output into "textAndShapes.h" section of sketch under "shape_1[]" or "shape_2[]".

Either way, feel free to share your creation (picture and code) in the comments!

Step 14: Credits and Final Thoughts

I certainly didn't come up with this all on my own. Not by a long shot.

No project is ever complete or perfect. Here are some thoughts I have going forward:

  • Balance: Data sheets rarely have information about the weight of the components, so it is hard to make even an educated guess about the balance without just building it. The battery is obviously the heaviest component. I added holes on each end so I could add weight as needed to balance it.
  • Clockwise? If you noticed, the text only displays correctly if you spin in the clock-wise direction. Spinning the other direction creates a mirror image. Adding a second Hall sensor or magnet would allow you to derive rotation direction (Sean's project did this).
  • Color? Using programmable RGB LEDs would allow you to do colors. They are typically surface mount though.

Comments

author
solaria137 made it! (author)2017-09-08

Looks like there's an error in the code:

int LEDS[] = {10, 9, 8, 7, 6, 5, 3, 4}; // Port A

Kind of messes up the display. It should be:

int LEDS[] = {10, 9, 8, 7, 6, 5, 4, 3}; // Port A

Also: when it compiles, it generates many warning messages:

sketch/textAndShapes.h:94:1: warning: narrowing conversion of '128' from 'int' to 'const char' inside { } [-Wnarrowing]

You can get rid of those by changing "const char" to "const byte", e.g.:

const byte PROGMEM shape_1[] = { //heart

spinner.jpg
author
MakersBox (author)solaria1372017-09-08

Yup. Rev 1.0 boards should be

int LEDS[] = {10, 9, 8, 7, 6, 5, 4, 3}; // Port A

My bad.


Not sure about the other error. What version of Arduino IDE are you using?

author
solaria137 (author)MakersBox2017-09-08

I'm using Arduino 1.8.2

It might be related to the ATTiny Core - I'm using version1.1.4 "ATTinyCore Universal" (https://github.com/SpenceKonde/ATTinyCore)

By the way: the code for mode 7 doesn't look right: It's stepping through shape_1, but reading from shape_2?

author
anverxt (author)2017-09-04

Great project! It would be cool to swap out AT Tiny for Espressif ESP8266 module (esp7 or esp12), the price is comparable, but you get loads more processor/ram/flash. Also it is much easier to program (with same arduino tools). You get wifi as a part of a package, can for example list of visible SSIDs.

Someone suggested an RTC, which would turn the spinner into a clock, that would be cool, though battery life might be a problem.

author
tacoff (author)2017-09-02

This is a really cool project. Good stuff man

About This Instructable

2,659views

59favorites

License:

More by MakersBox:Geek SpinnerProgrammable POV Fidget SpinnerI Can Surface Mount Solder
Add instructable to: