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 least common multiple 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.

This year, I decided to move out of the dorms at Cornell, and rent an apartment with 4 friends.  Naturally, we wanted to have some kind of entertainment system, but didn’t want to pay a monthly cable bill, since we hardly watch live TV anyways (hulu is where it’s at).  So, I set out to build a media PC that we could hook up to a TV, and stream content with.  Naturally, we’re also using it play our combined wealth of downloaded media content, etc.

As it is, I already bring up two computers to college, my main desktop (codename: phoenix, aka Ultimate Computer 5), and my laptop (which I won for free during my time as an Intel STS Finalist).  Considering all the HD content editing I do, I need my desktop for its rendering power and expansive hard drive space.  But did I really want to bring up a 3rd PC!?  Hell yeah!  But wait, my desktop is now 2 years old – that’s ancient in computer terms.  So, I did what any computer geek would do – I upgraded my computer, ripped out the old parts, and shoved them into a much smaller case for our media PC!

Sounds easy, right?  Wrong.  The new Media PC case is a Lian-Li PC-A05NB Micro Case (I’ll be uploading a video review of it soon).  I wanted to squeeze in parts that used to live in a Full Tower PC case!  Getting the PSU to fit was the hardest part – I had to attack the mounting system with a dremel, solder together a new ATX power connection, and rework the front bezel of the case.  The image below on the left is the original bezel for the Power Supply.  Using this caused it to overlap with the Motherboard ATX connector.  So, I dremeled it apart until I got two of the mounts on the right.

Naturally, Modifying this prevented the front of the case from going on correctly, hence why I then had to solder up a new power extension.  Anyways, I eventually squished my “old” computer into the media PC case, and was ready build a new machine inside the Silverstone Temjin TJ-09 that I had previously been using. Here are the specs for my new monster:

Note that the CPU is overclocked to 3.4GHz.  It was a dream to overclock with this motherboard.  The CPU runs super stable and cool, even with its voltage cranked up a little, and its clock bumped up by 800MHz.

Now, check out the super awesome build video below, or visit the project page at ultimatecomputers.net for some pretty pictures!

If you subscribe to my youtube channel, you might know that I’ve been working on a project called reacXion.  Last week, we finished a working breadboard prototype of the project, with a simple sample program running.  Check it out in the video below!  I had initially hoped to get this finished before heading back to college for the semester, but that obviously didn’t happen.  I’ll probably finish it up over winter break.  The final version will be on a printed circuited board, have a nice enclosure, and several modes to choose from.

About two years ago, I posted a tutorial on applying thermal compound to a CPU.  With over a quarter-million views, it’s now my most popular video on youtube.  Due to its huge success, I decided it was time to post a follow-up tutorial, with an improved application technique, and instructions for how to remove existing thermal compound.

Admittedly, the previous tutorial did not employ the best possible application technique, and although it will work just fine, the new technique described in the video below does make for superior temperatures.  This video was filmed by Zach Lynn, and narrated and edited by myself.

In our most recent computer tutorial, we show you how to add a case fan to your computer for improved airflow. My brother, David Blum, guest hosts this episode. As usual, it was filmed by Zach Lynn. Enjoy!

I’m no artist, but I do try really really hard to appreciate art, and I do enjoy a good museum visit. And, while I might suck a painting, sculpting, drawing, and singing, I’m pretty good at building stuff. My girlfriend (an English major), is by no means a geek like me, but she loves art, and is always looking for a new way to portray an emotion or a feeling. From these two seemingly distant interests will be born a (hopefully) marvelous creation! This creation is called “reacXion”, and it’s our attempt at making an interactive artistic display.

ReacXion will make use of 5 speakers, 256 LEDS, 5 distance sensors, and an array of electrical circuitry to synthesize a unique artistic experience. I was orignally hoping that we’d be able to finish it before heading off to the Fall semester, but it’s starting to look like that might not happen. Regardless, I’m trying to take video of my build process as I go so that those of you who are interested in learning more about hobbyist electronic design can gather up some tips! I’ve already posted the first three parts on youtube, and will hopefully be posting part four (first prototype) in the next few days! Check out part 1 below, and hop past the break for parts 2 and 3!

Part 1: Concept

Part 2: Rough Schematics

Part 3: Parts and Datasheets

Just a real quick update. I’m currently in the throes of building two computers, working on an electronics project, getting my Fall classes in order, and organizing Cornell’s new Sustainable Design Team (which is replacing the Solar Decathlon Team).  And I’m trying to do all of this in the next two weeks.  Needless to say, I’m pretty busy – so here’s an update to let you know what videos will be coming up, etc.

Well well… look who has finally decided to move his blog design out of the dark ages!  I’ve spent the last month or two working on this new blog design – I really hope you like it!  It takes advantage of a whole bunch of new wordpress blogging features like nested comments, better tag support, and widgets.  For all you newcomers, here’s a shot of what jeremyblum.com used to look like:

RIP Previous Blog Layout (2007-2010)

Compare that…to this!

The Shiny New Website Design!

If you have any comments on the new design, please feel free to let me know what you think!

Pardon the stupid title for this post.  It’s simply what popped into my head.  Anyways…I’ve got a new episode of techbits!  It’s been several months since the last episode, but hopefully my recent electronics projects have kept you entertained in the meanwhile.  This time, I’m talking about analog and digital signals – Both of which are inescapable in computers and all other electronic devices.  Enjoy!

Update 5/19/10 – I have uploaded the final report, code, schematics, laser-cutting files, and sound effects!  Read on to download them.

Introducing the SudoGlove Control System!  This is my final project for INFO4320 at Cornell Engineering.  It was developed by me and three other students: Joe Ballerini, Tiffany Ng, and Alex Garcia.  You get geek points if you can figure out why we decided to call it the SudoGlove.  Here’s a hint…

SudoGlove aims to bridge the gap between the user and traditional physical hardware devices. Given the high learning curve in understanding how to use foreign technologies, we hope to break away from conventional control mechanisms and explore an intuitive way to control these devices. SudoGlove provides a tangible interface that relies on hand gestures to wirelessly control any device or software. By removing the distance between the user and traditional hardware devices, our goal is for SudoGlove to feel more like an extension of the body as opposed to an external machine.

As an investigation into this idea, the goal of this project is to capture simple hand gestures from the SudoGlove and use that input to wirelessly control a modified RC car. Controlled variables include speed, steering, forward/reverse, headlights, siren lights, siren sounds, and a horn using a combination of flex, force, vibration, and gyroscopic sensors.

News: SudoGlove has been featured on Hack-a-Day!

Read on for a demonstration video, photo gallery, additional information, and downloadable content!

VIDEO DEMONSTRATION

THE TEAM

We’re crazy engineers and there’s no telling what we may do next!

SYSTEM COMPONENTS
The SudoGlove Control system consists of three main components: The actual glove, the control pack, and the RC car.  The glove is a standard Reebok glove with 5 sensors sewn in (thanks to my girlfriend for teaching me how to sew – Picture on the right).  The sensors include a flex sensor on the index finger, two force sensors on the ring and pinky fingers, a vibration sensor in the palm, and a two dimensional gyroscope on the wrist.  A small protoboard houses 3 status LEDs, and a connector for the 12-conductor wire that goes to the control pack.

The control pack contains an arduino mega, prototyping shield, XBee and XBee shield, 9V Battery, illuminated power switch and a connection for the glove.  The case was designed in the Alibre Cad program and laser-cut using the Epilog Laser in Cornell’s Computational Synthesis Lab.  The top of the box was etched using this laser as well.

The final system component is the RC car.  We removed all the original electronics and kept just the two motors and the chassis.  An XBee wireless module receives commands from the glove, and an arduino pro mini processes these and tells the car what to do.   An H-Bridge is commanded by the arduino and drives the motors in the appropriate directions.  We modified the car chassis to include 2 headlights, 4 siren lights, and speaker for playing sound effects.  The speaker is controlled by a SOMO audio module which communicates with the arduino as well.

PHOTO GALLERY

view slideshow

SOURCE CODE, SCHEMATICS, AND DESIGNS
These materials are made available via a Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License. Feel free to modify and improve upon these materials as much as you like, but share your improvements and credit myself, Joe Ballerini, Alex Garcia, and Tiffany Ng as the original authors. Please do not use these materials for commercial purposes.

Download SudoGlove – Final Deliverable
Download SudoGlove – Code
Download SudoGlove – Schematics
Download SudoGlove – Laser Cutting Files
Download SudoGlove – AD4 Sounds (for use with SOMO Audio Module)