JeremyBlum.com » Tech Ramblings

Driving 5 Speakers Simultaneously with an Arduino

Jeremy Blum — Sun, 05 Sep 2010 22:42:10 +0000

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:

C = 131 Hz
D = 147 Hz
E = 165 Hz
G = 196 Hz
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:

C = 1/131 Hz = 7.6ms
D = 1/147 Hz = 6.8ms
E = 1/165 Hz = 6.0ms
G = 1/196 Hz = 5.1ms
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:

C = 7.6ms/2 = 3.80ms
D = 6.8ms/2 = 3.40ms
E = 6.0ms/2 = 3.00ms
G = 5.1ms/2 = 2.55ms
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:

C = 3.80ms/50μs = 76 counts
D = 3.40ms/50μs = 68 counts
E = 3.00ms/50μs = 60 counts
G = 2.55ms/50μs = 51 counts
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:

C = 3.80ms/64μs ≈ 60 counts
D = 3.40ms/64μs ≈ 53 counts
E = 3.00ms/64μs ≈ 47 counts
G = 2.55ms/64μs ≈ 40 counts
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.

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
116
117
118

//** 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()
{

/* Disable the timer overflow interrupt while configuring */
TIMSK2 &= ~(1<<TOIE2);

/* Configure timer2 in normal mode (counting, 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 enable (only overflow) */
TIMSK2 &= ~(1<<OCIE2A);

/* Now 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 timer.
* The following loads the value 248 into the Timer 2 register
* 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 overflow.
* This is normally done by writing the address of the ISR in the
* interrupt vector table but conveniently done by using ISR() */
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!
}

A Taste of Things to Come

Jeremy Blum — Tue, 03 Aug 2010 17:23:08 +0000

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.

Computer Destruction 101

Jeremy Blum — Mon, 15 Jun 2009 05:25:45 +0000

It’s always a good idea to keep your old hard drives. Case and point, if Zach (the one filming this video) hadn’t been looking through his old drive, he never would have found this gem that we filmed a few years ago. It’s basically just 3 minutes of computer carnage, and some bad acting on my part, but I figured some people would enjoy it. Check it out!

YouTube Partner Status Achieved

Jeremy Blum — Tue, 13 Jan 2009 07:25:42 +0000

Great News! After posting my first video to Youtube over 2.5 years ago, I’ve finally been selected to join the youtube partner program. As a member, my videos get priority, I’m eligible for revenue sharing if Ichoose to have ads appear next to my videos, and I get to do a lot of great stuff with my channel page! I’m very excited about this, and my hope is that it will garner even more views for my videos. Check out my fancy new youtube channel HERE.

So you’ve Built a Computer! Now What?

Jeremy Blum — Sun, 11 Jan 2009 00:40:28 +0000

This most recent video tutorial, brought to you by ultimatecomputers.net, answers one of the biggest questions I get: how do you configure a computer once you’ve finished building it? I explain how to maneuver through the BIOS, ensure your temperatures are okay, setup a RAID array, set your default boot device, install Windows, get drivers working, and how to disable Windows User Account Control. As always, you can go check it out in HD on youtube ;)

Sudo Sandwhich (Tech Comic)

Jeremy Blum — Mon, 10 Nov 2008 17:00:13 +0000

I just had to share this comic. It’s not a new one, but I find it particularly amusing. If you don’t already, you should start reading the xkcd comics (xkcd.com). WARNING: They are are for tech geeks. If you don’t get this one, then I refer you here: http://en.wikipedia.org/wiki/Sudo.

TechBits – My new Vlog

Jeremy Blum — Sat, 08 Nov 2008 21:56:53 +0000

I’m starting a Vlog! It will be called TechBits. The idea will be to informally answer tech/computer questions, talk about the technology industry, etc. Below is the introduction video to the series. Be sure to subscribe to my youtube channel! :)

The Description that goes with the video:

TechBits will be my new Vlog. Please comment to let me know what I should change/improve, etc.

Stuff Mentioned in my Video:
ZACH LYNN (CO-CREATOR Of ULTIMATECOMPUTERS.NET)
http://www.youtube.com/zlynn1990
http://www.zachlynn.com

ULTIMATECOMPUTERS (A COMMUNITY FOR COMPUTER-BUILDERS AND TECH ENTHUSIASTS)
http://www.ultimatecomputers.net
http://www.cafepress.com/UComputers (this is where you can buy the shirt I was wearing)

DEEPNOTE (A BOT MADE BY MYSELF AND FRIENDS THAT CAN PLAY GUITAR HERO)
http://www.mechanizedrock.com
Also check out the DeepNote videos in my youtube Profile

MY BLOG (JUST RANDOM STUFF THAT I LIKE TO TALK ABOUT, MOSTLY WHAT I’M UP TO)
http://www.jeremyblum.com

MY TWITTER FEED (FOLLOW ME ON TWITTER; THE FEED IS ALSO DISPLAYED ON THE SIDE OF MY BLOG)
http://www.twitter.com/sciguy14

MY YOUTUBE PROFILE (DUH…AND DON’T FORGET TO SUBSCRIBE!)
http://www.youtube.com/sciguy14

Suggestions for Windows 7

Jeremy Blum — Mon, 18 Aug 2008 00:41:48 +0000

I’ve used a whole lot of operating systems, but for many years, Windows has been my primary mode of computing. I now use Vista on 3 machines and Ubuntu Linux on a 4th (with it also dual-booting on one of my Vista machines). I’ve had a lot of experience with Macs as well, and about a dozen different Linux Distros. Having seen all of these different computing methods, I’d like to offer my insight (even though very few people are probably reading this) into the development of Windows 7.

Backwards compatibility needs to go. By trying to make all aspects of the operating system backwards compatible with other versions, Windows releases have been getting more and more bloated. The old apps usually don’t even work right anyways. Add a virtualization engine that old apps can run in. That way, it only has to be used when old apps are needed.
Vista had way to many SKUs. Ultimate, Home Premium, Business…etc. It was simply ridiculous. Take a page from the linux playbook: Make a single base operating system, and allow the needed packages to be installed on top of it. None of this extra stuff should be installed by default. During the Windows install, it should start very stripped down. You can can either choose a suggested configuration based on what you will use the computer for, or advanced users can pick and choose. For example, any business user would not need to install photo gallery, but they may want remote access. A home use can pick differently to suit their needs. If you decide you want to add or remove a feature later on, just pop in your Windows 7 Disc and choose what you want to add or remove.
Stop giving eye candy priority over features/improvements. In Vista, great features like WinFS were stripped out, while aero remained in tact. That is insane. There is nothing wrong with making the OS look nice, but you shouldn’t need a super computer to run the GUI, and the quality of the OS operations should always come first.
The registry needs to go. Now. I am aware that this means changing a lot, but the Registry is outdated and stubborn. It is the cause for too many problems, and makes moving programs impossible. Try using config files like linux does.
Release driver information. early. like yesterday. Drivers were a major issue with Vista, and while it wasn’t Microsoft’s fault that the developers didn’t write their drivers early, they do need to give them some encouragement by providing info early on.

I’ll probably think of some more things later on and append to this post…

Please post some comments on what you think needs to be different in Windows7.