The thinking cap

Introducing: My prototype thinking cap! It’s a hat that scrolls a message in changing colors. You can change the message with your smartphone since the hat contains a  bluetooth radio. You can even change the colors and stuff. It runs on 8 AA batteries. I actually wore this at around for a day on campus!

I used the LPD8806 based RGB led strips I purchased earlier, cut into 5 equal length strips stacked one on top of the other to give me a vertical resolution of 5 pixels. I incorporated a basic character set that is 5 pixels high and up to 7 pixels wide to scroll the text across the hat. The text is very hard to make out unless you are at least 5 feet away, unfortunately. The farther you are, the easier it is to read the hat.

Materials and technical stuff:

  • Teensy 2.0 microcontroller
  • 2 x 744052 dual 4 channel multiplexors
  • 1 x 7400 series inverter
  • Sparkfun bluetooth mate gold
  • 8 x AA batteries
  • Diode (6A capable, to drop the voltage on the batteries)
  • Plenty of wires

The Teensy only contains a single SPI interface, which was used to control the led strips. I needed a way to multiplex the SPI between the strips since I didn’t feel like connecting the end of each strip to the beginning of the next strip, so I decided to use the multiplexors. I chose the 744052 since they were dual 4 channels, meaning they behaved like a double pole, single throw switch. This was necessary to switch the SPI data and clock lines between each strip. A problem arose however, because I had 5 strips but the multiplexors were for 4 channels, so I added an inverter and another multiplexor and came up with a cheap scheme to let me multiplex between the 5 using only 3 bits.

Enable Sel X Sel Y Enable Sel X Sel Y
0 0 0 1 0 0
0 0 1 0 0 0
0 1 0
0 1 1
1 Don’t Care Don’t care
B4 B3 B2 Mux 1 output # Mux 2 output # Strip #
0 0 0 1 -  1
0 0 1 2 - 2
0 1 0 3 - 3
0 1 1 4 - 4
1 0 0 - 1 5

The third bit of my output was used to control the enable (which is active low) of the first mux, and I tied the complement of it to the enable of the second mux. This ensured that for values 0 to 3 (000b to 011b) that the first mux was enabled and the second disabled, and when I output 100b, this disabled the first mux and enabled the first input of the second mux. The input select lines on the second mux were both tied to ground, as I only used it to select the 5th strip.

This allowed me to easily index my strips and switch between them when controlling the scrolling text. The text itself was achieved using a framebuffer and a bunch of shifts. The bluetooth radio used was the sparkfun bluetooth mate gold, which allowed me to easily change the text message using the serial port profile and a serial console app on my phone.

Video of hat in action:


I got it in my head to make a digital synthesizer using a leftover microcontroller (Freescale JM128 Coldfire V1) from a class I had taken previously. So off I went. I wanted something that I could use a MIDI keyboard with. While snooping around a local store, I stumbled upon this:

Akai SynthStation 25

It’s a 25 key keyboard which is supposed to work with your iPhone. Additionally, it works as a USB MIDI keyboard! The microcontroller I was using had support for USB device and host mode, though getting it working was a real pain. Freescale supplies a small USB stack for the microcontroller, and after a week of toiling I finally got it working correctly. One of the problems I had run into was that the D+ and D- pins of the USB had to have pulldown resistors in order to work correctly, something that took me a few days to figure out.


I used tusbsnoop with the keyboard connected to my computer to get the vendor and product ID as well as the device class and endpoint information for the USB protocol. I had to put this information into a struct for the USB stack to use it correctly to connect as follows:

static USB_HOST_DRIVER_INFO DriverInfoTable[] =
 {0x09,0xE8}, /** Vendor ID for Akai*/
 {0x00,0x7A}, /** Product ID per synthstation USB kb */
 USB_CLASS_AUDIO , /** Class code */
 USB_SUBCLASS_AUD_MIDI_STRM, /** Sub-Class code */
 0x00, /** Protocol */
 0, /** Reserved */
 SynthStationUsbEvent /** Application call back function */

Anyway, with that all set, I connected everything up. Amusingly, the space in the SynthStation where you put your iDevice into was just about right to slip a small breadboard into, which made my life much easier.

Makin’ noise

Alright, so I got the thing reading the keypresses, but now I have to make some noise. I decided to use a technique called digital direct synthesis (DDS) to generate my waveforms. I used this wonderful guide to help me out, thanks electricdruid! I hardcoded a sine wavetable, and generated the tables for sawtooth, triangle and square waves. All this was great but, how do I get sound out of this thing?

To get sound out of the microcontroller would require using a digital to analog converter (DAC), which is the reverse of an analog to digital converter (ADC) which is found on many microcontrollers as a built in peripheral. I found a guide online on how to use a single PWM pin to create a low fidelity 1-bit DAC, and tried it. I was not too happy with the sound!

Eventually I decided to buy a DAC and settled on the Microchip MCP4921, which is a 12 bit DAC using SPI. I created a basic RC low pass filter to clean up the output and wired everything up nicely.

How is the sound generated? The basic idea is that I had an interrupt on a 22kHz timer that would look into the wavetables to generate a sample, and then this sample was fed to the DAC using SPI. I chose to use 256x1byte entries to store 1 period of each wavetype.

Here’s what it looked like now:

The micro, the DAC, a 24 character LCD for later use, and the RC filter attached


I went ahead and added a character LCD for later use. You can see a small 1/8″ audio jack that I hackishly put in to test the sound synthesis.

More to come later!