Yes, that’s me with the Arduino Team at Makerfaire!

If you follow me on twitter, then you’ll certainly know that I spent last weekend in New York City for the 2nd Annual Open Hardware Summit and the 2011 World Maker Faire. I covered the Open Hardware Summit for element14 Electronics (hence the copious tweeting). You can read all about my time at the open hardware summit on my element14 blog. Check it out! In addition to covering the summit, I was also there to enjoy all the amazing talks, and to demo my sudoglove controller, which is naturally all open source.

Makerfaire took place the following weekend, and was equally amazing. I spent much of the time “geeking out” at all the booths, and trying to check out as much amazing technology as I could. I got the opportunity to meet several people in person with whom I had previously only communicated online. On Sunday, I worked at the Makerbot booth, demoing our exciting new MK7 Extruders. It was great to finally show these off, because I had been working with them for much of the summer. I could talk on and on about all the amazing things I did, but you’re probably better off just checking out the photos I took. A slideshow is embedded below, or you can view them on flickr.

Wait… one more thing. Arc Attack, a group that makes music using lightning and tesla coils, performed the Doctor Who theme song. I filmed it and put it up on my secondary youtube channel. You do subscribe to my secondary youtube channel, right? Click Here to Watch the Video.

Performance 1 (watch the whole thing on my second youtube channel)

1. Margaret wears the SudoGlove, and uses it to trigger sound effects, including a gunshot sound.
2. After I wrestle it away, I utilize it to synthesize some of the background music on the fly.
3. RGB light wands cycle colors in a predetermined pattern for this performance.

Download Pure Data Patch for Performance 1
Download the source files for the sudoglove controller

Performance 2 (watch the whole thing on my second youtube channel)

1. Margaret is adding effects to her voice on-the-fly using the desktop computer.
2. A program written in “Pure Data” on my computer captures the live audio data and extracts key frequencies and partials that are used to determine a “mood” for the music.
3. The “mood” data is transmitted wirelessly to the RGB light wands where it changes the color and brightness of the LEDs accordingly.
4. That same data adjusts the hue of the visualizer shown on the projector screen.
5. The program also utilizes live volume information to modulate the size of the visualizer.
6. The visualizer is generated in real-time from a webcam feed of the dancer + light sticks. I wear the sudoglove, and flex my finger to adjust the intensity of the kaleidoscope effect shown on the screen.
7. Moving my hand around in 3D space corresponds directly to the movements of the visualizer on the projector screen. When I sweep my hand to the left, the visualizer moves to the left. I can move it up and down in the same fashion.

Download Pure Data Patch for Performance 2 and Light Wand Code
Download the source files for the sudoglove controller

Contrary to popular belief, Arduino is not the only microcontroller I use for projects. I often program Atmega 8-bit CPUs in C for my research, I’ve played with PICs at various jobs, and I’ve also worked with Parallax Basic Stamp and Propeller chips. This semester, I added the TI MSP430 to my CPU repertoire, thanks to Cornell’s Embedded Systems course. I really enjoyed working with the MSP430, and got to implement some interesting, though very difficult, things on it, including parallel process execution and real time process schedulers. For our final project, my lab partner and I put together a wireless weather station using the MSP430 EZ430-RF2500 Demo Kit. I also developed a Processing application to gather the data via USB and display it graphically on a computer. The station gathers light, temperature, and humidity info and sends it wirelessly to a USB receiver where the data is displayed on a computer. Check out the video below and download the source code and schematics as well. Enjoy!

Licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.

Download the MSP430 Weather Station Code and Schematics

The folders contain all the driver files in the root. ”receive_data.c” and “send_data.c” contain the main functionality. The code is intended to be compiled in Code Composer studio. To be sure it compiles, right-click on the project and go to “build properties”. On the “Tools Settings” page under “MSP430 Compiler > Include Options”, change “CCE_INSTALL_ROOT” to “CCS_INSTALL_ROOT”. Under “MSP430 Linker > File Search Path” change “CCE_INSTALL_ROOT” to “CCS_INSTALL_ROOT”. On the “Build Settings” page uncheck “Use Default Command” and change “CCE_INSTALL_ROOT” to “CCS_INSTALL_ROOT”.

If you thought I could only use the SudoGlove to drive RC cars and make music (depending on your definition of music), then you’re wrong! It appears that I can also use it to convince TV producers to put me on the discovery channel. Discovery Channel’s Daily Planet show reached out to me about the glove following the presentation I did at BOOM a few weeks ago. Cornell sends out a press release about the projects, and Daily Planet seemed to like the idea.
So, after about 7 hours of filming (no, that’s not a typo) with a crew at Cornell two weeks ago, a segment on the SudoGlove aired this past week! Check out the video here, or directly on Discovery Channel’s website. You won’t regret it!

I had to put “music” in quotation marks, since I’m using a pretty loose definition. I do not consider myself to be a musical person, but I do love music and I’ve always been extremely interested in what it takes to make music. So, I enrolled in a course this semester called “Performing with Computers“. It sounded like a music class that I could actually take and have some idea of what was going on. The class has been really fun so far, and I’m learning all kinds of new things. The class is structured around giving live performances of the music you develop, and doing so in interesting and unique ways. My mind immediately went to the SudoGlove Control System, since I had been trying to think of new applications for the platform. Once our professor introduced us to a programming language called PureData, I knew what I had to do…

The SudoSynth was born! Well kind of… I demonstrated the first version of the software (which I hastily wrote between 1 and 4AM the night prior) at BOOM 2011. It was well received, but clearly needed further work. So, over the last two weeks I’ve been rebuilding the software into a much more complex system capable of synthesizing piano, flute, guitar, electronic beats, bass rhythms, and percussion in just about any combination you can imagine. I also branched the original version of the software into an on-the-fly synthesizer that generates waveforms in real time based on hand movements (instead of using sound clips).

Check out the video below to see how the system works and sounds:

You can download the PureData Patches below. They are licensed via a Creative Commons Open-Source License.

SudoSynth – On The Fly Waveform Synthesizer (ZIP, 3KB)
SudoSynth – Multi Instrument Synthesizer (ZIP, 64MB – Includes .wav audio samples)

You can download the arduino code, schematics, laser cutting files, etc for the glove controller here.

The audio samples used in my patches are from freesound.org, and all have creative commons licenses. Further information about the sound clips used can be found in the downloadable zip files above.

SudoGlove Visual Debugging Software

As I mentioned in a previous post, I recently presented the SudoGlove Control System at Cornell’s BOOM Competition. I was concerned (rightly so) that I wouldn’t be able to drive the RC car around much due to the large amount of foot traffic for the event. So, I put together the simple “Instrument Panel” that you can see in the picture above. It’s written in processing, a programming language that I’ve demonstrated in several of my Arduino Tutorial Videos. By hooking up an XBee wireless module to the computer (the same wireless receiver present in the RC Car that is usually controlled by the SudoGlove), I can interpret commands from the glove and display them on the computer interface, in a fashion similar to how the RC car would interpret them. Whats more, I can even have the glove communicate with the computer and the car simultaneously by setting the ATID values for the two receiving XBees to the same value. If you have no idea what I’m talking about, watch this video about XBee communication.

As usual, you can download the processing source code for this project below. It’s licensed via Creative Commons.

Download Processing SudoGlove Debugging Display

You can download the arduino code, schematics, laser cutting files, etc for the glove controller here.

You can download the arduino code, schematics, laser cutting files, etc for the glove controller here.

BOOM = Bits on our Minds. It’s an annual event hosted at Cornell University by the faculty of Computing and Information Science. It’s a really awesome event, and every year I look forward to attending and checking out the dozens of amazing projects that students have developed. This year, I was encouraged by a previous professor to submit the SudoGlove Control System to BOOM, a project that I had developed with three fellow students in his class last Spring. As usual, I got overly excited about submitting the project, so I turned in the materials very early. Lucky me, Cornell sent out a press release, and before I knew it, the SudoGlove was featured on CNET News! I also took the opportunity to revisit the system we had developed a year ago, and add new features like a music synthesizer and visual display (I’ll post about those soon).

We also won the Bank of America Award at BOOM. I’m pretty sure the only requirements for winning the award were that they reps from Bank of America happened to think our project was cool. My favorite part of the whole experience was getting to talk to the kids from local schools who came visit the showcase – they all seemed genuinely interested in the technology.

Download the SudoGlove BOOM poster shown in the picture above (4.1MB PDF)
Read more about BOOM in the Cornell Chronicle

You can download the arduino code, schematics, laser cutting files, etc for the glove controller here.

For the ReacXion Audio/Visual Project I’ve been working on, it’s necessary to drive 5 speakers independently – each with a variable volume and set frequency (though the frequency of each speaker is different). I examined several methods for generating the 5 square waves in hardware – using a 555 timer, oscillating RC with schmitt trigger, and a bunch of opamp circuits. Unfortunately, none of these generated tones as nice as the ones I got when simply using the arduino tone library. The built-in tone() function allows you to generate a squarewave with 50% duty cycle of your selected frequency on any pin on the arduino. It relies on one of the arduino’s 3 timers to work in the background. Specifically, it uses timer2, which is also responsible for controlling PWM on pins 3 and 11. So you naturally loose that ability when using the tone() function. But I wanted to make 5 tones simultaneously! How to do it?

While the tone() function can only be run one instance at a time, I discovered (after much research), that I could hijack one of the timers (again, I chose timer2), and use some clever math and software interrupts to generate 5 tones simultaneously! I wanted to generate 5 tones of the following frequencies:

1. C = 131 Hz
2. D = 147 Hz
3. E = 165 Hz
4. G = 196 Hz
5. A = 220 Hz

Any music lovers out there will surely recognize this as the pentatonic scale (5 notes that nearly always sound good together). Now, think back to physics, and recall that period = 1/frequency. In other words, each frequency pin will have to cycle from 0V to 5V and back again in the time dictated by the period for that note. See the following picture:

The red portion of the square wave represents one cycle. From the formula above, we can determine the following periods required to generate each note:

1. C = 1/131 Hz = 7.6ms
2. D = 1/147 Hz = 6.8ms
3. E = 1/165 Hz = 6.0ms
4. G = 1/196 Hz = 5.1ms
5. A = 1/220 Hz = 4.5ms

But, remember that we are dealing with a microcontroller, so we need to flip the value twice every period. If you take a look at the green portions on the image above you’ll see what I’m talking about. In one red portion of the wave, the value needs to change twice. So in reality, we actually need to be able to flip bits twice as fast as the times outlined above. Dividing those values by two, we get the following:

1. C = 7.6ms/2 = 3.80ms
2. D = 6.8ms/2 = 3.40ms
3. E = 6.0ms/2 = 3.00ms
4. G = 5.1ms/2 = 2.55ms
5. A = 4.5ms/2 = 2.25ms

So, if we want to generate all these tones at the same time, we’re going to need to have an interrupt service that can activate at a Greatest Common Factor for all these values. This interrupt request will toggle the appropriate pin every prescribed number of milliseconds, and we’ll get the tones we need! So, the least common multiple for the variables above would be: .05ms, or 50μs. If we use this ideal value, we can construct an interrupt service request that will initiate every 50μs during our program. Using some counters, we can flip the bits after the appropriate intervals! Let’s calculate those counters now:

1. C = 3.80ms/50μs = 76 counts
2. D = 3.40ms/50μs = 68 counts
3. E = 3.00ms/50μs = 60 counts
4. G = 2.55ms/50μs = 51 counts
5. A = 2.25ms/50μs = 45 counts

In an ideal world, we would simply have a software interrupt trigger every 50μs, increment 5 separate counters each time, and toggle the associated pin when we reached the right value. For example, every time counter1 reached 76, we would reset it to 0, and toggle the value of that pin. If the only thing you were doing with your CPU was making noises, then this would work quite well. But the whole reason for doing this in an interrupt routine is so that we can do other things simultaneously. For this project, I’m simultaneously controlling a large LED matrix. If the matrix isn’t refreshed often enough, the display looks choppy. Unfortunately, cutting away to an interrupt routine every 50μs was too often, and the display started to look funny. So, I had no choice but to trade off some frequency accuracy for a reduction in how often I activated the interrupt. After some trial and error, I deemed the golden value to be 64μs. It’s a little more than the ideal lowest common denominator, but still close enough that the notes sound good. Using this new value, I calculated new counts, and implemented them in my interrupt routine:

1. C = 3.80ms/64μs ≈ 60 counts
2. D = 3.40ms/64μs ≈ 53 counts
3. E = 3.00ms/64μs ≈ 47 counts
4. G = 2.55ms/64μs ≈ 40 counts
5. A = 2.25ms/64μs ≈ 35 counts

And that’s it! Using these values, I can simultaneously generate all five notes, while maintaining enough time to quickly update my LED Matrix. Below is the final arduino code for making this work. Thanks to Sebastian Wallin for some awesome information on interfacing with arduino timer interrupts.

Licensed via Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
//** ReacXion Source Code **//

//** www.jeremyblum.com **//



/* Timer reload value, globally available */

unsigned int tcnt2;



/* Toggle HIGH or LOW digital write */

int toggle1 = 0;

int toggle2 = 0;

int toggle3 = 0;

int toggle4 = 0;

int toggle5 = 0;



/* Keep track of when each note needs to be switched */

int count1 = 0;

int count2 = 0;

int count3 = 0;

int count4 = 0;

int count5 = 0;



/* Frequency Output Pins */

#define FREQ1 9

#define FREQ2 10

#define FREQ3 11

#define FREQ4 12

#define FREQ5 13



//Setup Function will run once at initialization

void setup()

{



/* First disable the timer overflow interrupt*/

TIMSK2 &= ~(1<<TOIE2);



/* Configure timer2 in normal mode (no PWM) */

TCCR2A &= ~((1<<WGM21) | (1<<WGM20));

TCCR2B &= ~(1<<WGM22);



/* Select clock source: internal I/O clock */

ASSR &= ~(1<<AS2);



/* Disable Compare Match A interrupt (only overflow) */

TIMSK2 &= ~(1<<OCIE2A);



/* Configure the prescaler to CPU clock divided by 128 */

TCCR2B |= (1<<CS22)  | (1<<CS20); // Set bits

TCCR2B &= ~(1<<CS21);             // Clear bit



/* We need to calculate a proper value to load the counter.

* The following loads the value 248 into the Timer 2 counter

* The math behind this is:

* (Desired period) = 64us.

* (CPU frequency) / (prescaler value) = 125000 Hz -> 8us.

* (desired period) / 8us = 8.

* MAX(uint8) - 8 = 248;

*/

/* Save value globally for later reload in ISR */

tcnt2 = 248;



/* Finally load end enable the timer */

TCNT2 = tcnt2;

TIMSK2 |= (1<<TOIE2);



//Configure I/O Pin Directions

pinMode(FREQ1,    OUTPUT);

pinMode(FREQ2,    OUTPUT);

pinMode(FREQ3,    OUTPUT);

pinMode(FREQ4,    OUTPUT);

pinMode(FREQ5,    OUTPUT);



}



/* Install the Interrupt Service Routine (ISR) for Timer2.  */

ISR(TIMER2_OVF_vect) {

/* Reload the timer */

TCNT2 = tcnt2;



count1++; count2++; count3++; count4++; count5++;



if (count1 == 60)

{

digitalWrite(FREQ1, toggle1 == 0 ? HIGH : LOW);

toggle1 = ~toggle1;

count1 = 0;

}

if (count2 == 53)

{

digitalWrite(FREQ2, toggle2 == 0 ? HIGH : LOW);

toggle2 = ~toggle2;

count2 = 0;

}

if (count3 == 47)

{

digitalWrite(FREQ3, toggle3 == 0 ? HIGH : LOW);

toggle3 = ~toggle3;

count3 = 0;

}

if (count4 == 40)

{

digitalWrite(FREQ4, toggle4 == 0 ? HIGH : LOW);

toggle4 = ~toggle4;

count4 = 0;

}

if (count5 == 35)

{

digitalWrite(FREQ5, toggle5 == 0 ? HIGH : LOW);

toggle5 = ~toggle5;

count5 = 0;

}

}



void loop()

{

//Do whatever else you want to do with your arduino!

}