Output devices
Table of Contents
This week, I made a board that can generate sounds. I began the process of learning how to play various notes, chords, and instruments on it, and built a speaker of my own to replace the default speaker. You can hear the board playing the hello-speaker demo, although there's some background noise:
(This video was compressed using a command like:
ffmpeg -i dxh_uncompressed_sound_demo.mp4 -vf scale=400:-2 -vcodec libx264 -crf 20 dxh_sound_demo.mp4
)
1 Designing audio-output board
This design took several iterations. Here's the final result:
Along the way, I made the following mistakes:
I used the wrong footprint for the mosfet — we had small P-type transistors and large N-type transistors. Because I used the wrong footprint, I had to do a little hack — I "deadbugged" by board by attaching the mosfet indirectly to the board through wires that were soldered directly on the too-small footprints.
I rushed designing my first board, and as a result had an extra trace going to the TX pin on my six-pin connector; it shouldn't have been there at all, and contributed to an rc=-1 error when I tried to program the board.
I spent more time designing my second board to be streamlined and compact. I moved the six-pin from to the right of the ATTiny to the top (above pin 1). This allowed me to send the ground trace underneath the microcontroller and the VCC trace around the righthand side, avoiding my original setup which had the two traces going around the board together, separated by some distance. (It's preferrable to avoid putting VCC and ground close together because proximity makes them easier to short.)
With my second board, I was also able to eliminate a 0-ohm resistor that I previously required. (0-ohm resistors are packages in the shape of an ordinary 1206 resistor, but with no (i.e. negligible) resistance; you use them to make an overpass where one trace jumps over another without them coliding. This is called 2.5D design.)
Because my second board was so compact, some traces were too close together and weren't separated when they were milled. I was able to use a rectangular razor blade to sever the traces, but it's risky business. A better fix is to run the design rules checker (KiCad has one; it's the ladybug icon. Eagle presumably has one, but I wouldn't know.) which makes sure that your laid out traces meet the design rules you specify.
(!) Another serious problem was that the FTDI 1x06 pin header didn't have enough room on the board. Its metal feet were on the board, but the rest of the component dangled off. Solder is not load-bearing, so this would have unavoidably led to the FTDI header snapping off. A design fix is to allow ample extra room near the FTDI header. I also routed the VCC line to go under the plastic part so that wouldn't be so close to the feet as to cause a short.
Deciding that compactness wasn't the most important virtue, I made a wider, slightly more spread out circuit. I also added an LED so I could check whether the board was alive or not.
Tool hygiene was a big factor as well. I believe what happened on one board was that I milled with an end mill that I didn't notice had been slightly broken (which led to burrs which I removed by scraping with the long edge of a razor blade.) I also believe I soldered with a dirty soldering iron. The sponge really is indispensable. After struggling with rc=-1 instead of signs of life from that board, I made a replacement. I checked the end mill in great detail before using it, and thoroughly scrubbed the soldering iron before even turning it on, and then again afterwards. The result was patently better.
(!) At some point in this design process, I realized that although I only needed two out of four pins of the 2x02 pin connector for the speaker [see next section], by wiring up all four pins redundantly (in an A/B//B/A pattern) I would make a connector where I didn't have to care about the orientation of the speaker I was plugging in; it would work from many orientations.
(!) I did not take into account the power limitations of the speaker. The off-the-shelf speakers in the inventory are rated for 8Ω of resistance and 0.25 watts of power. I was using USB for power, so around 5V, which meant that the speaker line was drawing 5V*5V / 8 Ω, which is more than 3 watts. Which is more than 12 times the preferred amount of power consumption. Oops.
My short-term fix was to splice a breadboard-style resistor (two wires with a color-coded sausage shape in the middle) onto the speaker wire itself. I cut one of the wires leading to the speaker (see below for speaker design). I stripped insulation off each of the cut ends. Using a soldering iron, I mashed one exposed end of the wire and one wire of the resistor against each other and against the heat-proof ceramic tile underneath. Using a second hand, I applied a heap of solder at the junction. By pulling away carefully (this is an awkward, failure-riddled process), you can get the solder to cool before the two components slip out of the still-liquid solder. Repeat for the other side.
My long term fix was to add a resistor to the board itself, on the trace that's on the speaker side of the mosfet. According to my math, 100Ω (plus the 8Ω from the speaker itself) would basically meet the 0.25 watt limit; I used 150Ω for good measure, and it worked fine. Turns out our eecs lab carries a 150Ω resistor, so I only needed to use one of the two resistor slots on my board. The other one I made a 0Ω resistor (I still wanted the two slots because I imagined needing to swap out various resistances. Turns out 150Ω worked fine though.)
2 Assembling a speaker
2.1 From the inventory
There are speakers available in the inventory. They are basically just coils of copper wire atop a small magnet, and connected to a thin plastic membrane—that's it! It turns out that's all the complexity you need for a speaker. When current passes through the coil, the magnet or coil is moved around. Passing precisely-timed high-frequency bursts of current creates bursts of movment that result in sound waves.
The standalone speaker would attach somewhere to the board. I needed a connecting cable and a place to plug it in on the board. On the board, I used two pins of a 2x02 pin connector (4 pin connector). On the board design, I wired the four pins together so that two were low and went to GND [iirc] and the other two were high and went to a pin of the mosfet.
As for the cable, you can make your own 2x02 ribbon cable. You take ribbon cable and strip off all but four wires. There are toothed 2x02 cable connectors that look like open-mouthed jaws. You thread the end of the ribbon cable into the jaws and take careful note about which teeth will pierce each wire. This tells you which wire will be fed into which hole of the connector.
It's hard to tell later which hole goes to which wire, so I do recommend drawing a very careful reference picture in advance. Once the ribbon is threaded through, you use a vice (you need super-human pressure) to permanently clamp the jaws shut on the ribbon, so the teeth can pierce into the wires forming a connection.
There's a connector on one end. The other end goes to the speaker. By peeling, separate any* two of the four wires from the rest (we only need two of them; one for high and one for low and order doesn't matter). [*]You can pick almost any two, but you must refer to your diagram for the connector and your diagram for your circuit to make sure you're picking two wires that, when the connector is plugged in, are connected to different traces on your board.
Use a wire stripper to remove the rubbery insulation from around the wires, exposing a spray of metallic interior wire. I discovered that I needed to remove a much shorter length of insulation that I initially thought. If you remove too much such that the following soldering stage is too difficult, you can always trim the protruding metal strands to be shorter.
I have little advice for this next part. Basically, I set up a workspace on the relatively heat-proof ceramic soldering tiles. I set down the standalone speaker and fixtured it in place with tape.
2.2 Build your own
I built my own speaker. Note that volume-wise, it was worse than the off-the-shelf type. But part of the problem was that it was such a hefty object (I was going for lots of copper wire and a large magnet), that it probably needed more current than I could supply via USB. Changing power supplies will be my next step.
A speaker, as noted above, is a coil of wire, optionally wound around a magnet for stronger effect, affixed to a membrane so that when the coil goes back and forth, so does the membrane.
We actually had a special setup for creating coils of wire. We had a spool for winding copper wire around, as well as a wire-winding machine. You slide the speaker onto an axel, then tighten it in place, tape one end of wire to your spool (leave enough length so that when you're done, the starting bit of thread is dangling off; leave length on the terminating end when you're finished as well. You want a coil of wire with two long dangling ends to connect to things), then turn a crank to wind wire around it. The device even counts the number of turns! (I saw that others had done 250; I did around 300.)
There's a delicate balance regarding size and force, as I mentioned above. Thin-gauge wire is tiny, which is good because small mass is good. But it is also brittle and unable to tolerate much current. Large magnets increase the amount of electromagnetism in play, but are also heavy.
My wires were very thin and rather brittle. The hard part was getting them to interface with the four-pin connector, and also ensuring that they did not snap in the process. They did snap in the process—at one point, they snapped off one end so that I didn't have the requisite two wires exposed and I had to start over and wind it again.
My basic solution was as follows. First, what's obvious in retrospect but surprised me at first, is that the shiny copper wire is covered in a thin layer of insulation—overlapping wires don't speak to each other. So if you attempt to solder the wires directly, they'll appear dead (and a multimeter will confirm that no current is flowing from [the outside surface of] one end of the wire to [the outside surface of] the other.) You have to remove the external surface. I imagined using acetone, but we didn't have any at hand — perhaps that would have worked. Fine sandpaper worked passably well.
It's hard to tell if you've sanded properly. There's only a subtle visual difference between sanded and unsanded wire. The exposed copper wire is copper-colored like its covering, but it appears perhaps whiter and shinier. You only really need to expose the ends. The wire snapped a few times when I was sanding, even carefully, so I encourage gentleness and sanding only the smallest end that you need; this way if it snaps, you still have more length to use up.
I soldered the copper wire to the four-pin ribbon cable just like I did for the standalone connector. This felt janky and fragile — and it was. The thin wire snapped several times. A sort-of solution was to tape the copper strands to the surface of a small plastic cup I was using as a membrane. This helped protect the copper from being jostled by the environment.
3 Composing sound software
I taught the speaker how to play many different sorts of sounds and only wish I had had time for more.
Neil's hello-speaker example was a good start.
(!) Important. Please note that, as of the time of this writing, Neil's hello-speaker example uses the internal timers/pwm of the attiny microcontroller in order to generate sound. As such, /the device itself constrains sound output to a particular, pre-determined pin./ You can't use Neil's code to produce output at an arbitrary pin, so you should design your board so that the mosfet is connected to the right pin.
Although you can change the
MOSFET_PINvariable in the code, this can't change everything you'd expect: The code does two things. First, it sets the mosfet pin to be an output pin (changingMOSFET_PINchanges this), then it sets up a counter which produces sound waves on the OC1A (overflow) pin. Check your datasheet to see which pin is the OC1A pin. The OC1A pin and theMOSFET_PINshould be the same pin in order for the code to work as intended.
I actually didn't realize this at first. I had connected it to pin OC1B on my tiny44 (not Neil's tiny45) because I knew that pin could be used for pwm output and I didn't realize it mattered exactly which one. I had to do find-and-replace throughout the code to replace many instances of As with Bs. Read about counters elsewhere for more details.
I was able to test the speaker code on an LED I had included for just such debugging purposes. (It's a good idea.) Amusingly, it produces the visual equivalent of the hello-speaker result: flickers of light at various levels of brightness instead of flickers of sound. My LED, as I eventually found out, was coincidentally connected to the OC1A pin, which meant that hello speaker worked out-of-the-box exactly as I expected it to, even though I had the wrong mental model of how it worked. After some serious confusion, I figured out the OC1A vs OC1B thing.
Here's code for doing various things, assuming your mosfet's gate is connected to pin OC1B (check your datasheet) :
Play Neil's Hello Speaker example
// For brevity, I'm leaving out the various other macros defined in
// Neil's hello speaker code. Put them at the beginning of your
// document and call this function from your main function.
// This code only works if the gate of your MOSFET is connected
// to the OC1A pin which is also pin PB2 on ATTiny44s.
// Neil's original code is for the OC1B pin on Attiny45s.
#define MOSFET_pin (1 << PB2)
#define MOSFET_port PORTB
#define MOSFET_direction DDRB
int minimal_speaker(void) {
//
// main
//
static uint16_t frequency,period,cycle,cycles,delays;
static uint8_t amplitude;
//
// set clock divider to /1
//
CLKPR = (1 << CLKPCE);
CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
//
//
//
TCCR0A = ((1 << COM0A0) | (1 << COM0A1) | (1 << WGM01) | (1 << WGM00)); // set OC0B on compare match and set fast PWM mode, 0xFF TOP
TCCR0B = (1 << CS00); // set timer 0 prescalar to 1
//
// initialize MOSFET pin
//
clear(MOSFET_port, MOSFET_pin);
output(MOSFET_direction, MOSFET_pin);
clear(MOSFET_port, MOSFET_pin);
output(DDRA, (1 << PA7));
set(PORTA, (1 << PA7));
while (1) {
//
// loop over amplitudes
//
for (amplitude = amax; amplitude >= amin; amplitude -= astep) {
//
// loop over periods
//
for (period = pmax; period >= pmin; period *= pstep) {
//
// loop over square wave cycles
//
cycles = duration/period;
for (cycle = 0; cycle < cycles; ++cycle) {
//
// set PWM current on
//
OCR0A = amplitude;
// loop over delay
//
for (delays = 0; delays < period; ++delays)
cycle_delay;
//
// set PWM current off
//
OCR0A = off;
//
// loop over delay
//
for (delays = 0; delays < period; ++delays)
cycle_delay;
}
}
}
}
}
Play a single square wave tone
int atune_simpler(void) {
// initialize MOSFET pin
//
clear(MOSFET_port, MOSFET_pin);
output(MOSFET_direction, MOSFET_pin);
clear(MOSFET_port, MOSFET_pin);
// SET clocks same as usual
CLKPR = (1 << CLKPCE);
CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
TCCR0A = ((1 << COM0A0) | (1 << COM0A1) | (1 << WGM01) | (1 << WGM00)); // set OC0B on compare match and set fast PWM mode, 0xFF TOP
TCCR0B = (1 << CS00); // set timer 0 prescalar to 1
int j;
int pin_on = 0;
while(1) {
OCR0A = 255 - pin_on * 55;
// Changing this maximum value 110 changes the pitch
for(j=0;j<110;j+=1) {
cycle_delay;
}
pin_on = 1-pin_on;
}
}
Play custom waveforms using a wavetable (here: triangle wave)
int wavetable_simpler(void) {
// initialize MOSFET pin
//
clear(MOSFET_port, MOSFET_pin);
output(MOSFET_direction, MOSFET_pin);
clear(MOSFET_port, MOSFET_pin);
// SET clocks
CLKPR = (1 << CLKPCE);
CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
//
//
//
TCCR0A = ((1 << COM0A0) | (1 << COM0A1) | (1 << WGM01) | (1 << WGM00)); // set OC0B on compare match and set fast PWM mode, 0xFF TOP
TCCR0B = (1 << CS00); // set timer 0 prescalar to 1
int j;
int pin_on = 0;
int wavetable_size = 1024;
// This is a triangle wave; its amplitude goes linearly from 0 to
// 255 then repeats back at 0.
// !! Note: You must include #include <avr/pgmspace.h> to use
// the extended PROGMEM (program memory) of your device. It's
// needed here because otherwise there isn't enough space in
// run-time memory to store it all in a variable. PROGMEM is
// actually stored in a different physical place on the chip.
static const uint8_t wavetable[] PROGMEM = {0, 0, 0, 0, 1, 1, 1, 1,
2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7,
7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12,
12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16,
16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20,
20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24,
25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29,
29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31, 32, 32, 32, 32, 33, 33,
33, 33, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 37, 37, 37,
37, 38, 38, 38, 38, 39, 39, 39, 39, 40, 40, 40, 40, 41, 41, 41, 41,
42, 42, 42, 42, 43, 43, 43, 43, 44, 44, 44, 44, 45, 45, 45, 45, 46,
46, 46, 46, 47, 47, 47, 47, 48, 48, 48, 48, 49, 49, 49, 49, 50, 50,
50, 50, 51, 51, 51, 51, 52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54,
54, 55, 55, 55, 55, 56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58,
59, 59, 59, 59, 60, 60, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 63,
63, 63, 63, 64, 64, 64, 64, 65, 65, 65, 65, 66, 66, 66, 66, 67, 67,
67, 67, 68, 68, 68, 68, 69, 69, 69, 69, 70, 70, 70, 70, 71, 71, 71,
71, 72, 72, 72, 72, 73, 73, 73, 73, 74, 74, 74, 74, 75, 75, 75, 75,
76, 76, 76, 76, 77, 77, 77, 77, 78, 78, 78, 78, 79, 79, 79, 79, 80,
80, 80, 80, 81, 81, 81, 81, 82, 82, 82, 82, 83, 83, 83, 83, 84, 84,
84, 84, 85, 85, 85, 85, 86, 86, 86, 86, 87, 87, 87, 87, 88, 88, 88,
88, 89, 89, 89, 89, 90, 90, 90, 90, 91, 91, 91, 91, 92, 92, 92, 92,
93, 93, 93, 93, 94, 94, 94, 94, 95, 95, 95, 95, 96, 96, 96, 96, 97,
97, 97, 97, 98, 98, 98, 98, 99, 99, 99, 99, 100, 100, 100, 100,
101, 101, 101, 101, 102, 102, 102, 102, 103, 103, 103, 103, 104,
104, 104, 104, 105, 105, 105, 105, 106, 106, 106, 106, 107, 107,
107, 107, 108, 108, 108, 108, 109, 109, 109, 109, 110, 110, 110,
110, 111, 111, 111, 111, 112, 112, 112, 112, 113, 113, 113, 113,
114, 114, 114, 114, 115, 115, 115, 115, 116, 116, 116, 116, 117,
117, 117, 117, 118, 118, 118, 118, 119, 119, 119, 119, 120, 120,
120, 120, 121, 121, 121, 121, 122, 122, 122, 122, 123, 123, 123,
123, 124, 124, 124, 124, 125, 125, 125, 125, 126, 126, 126, 126,
127, 127, 127, 127, 128, 128, 128, 128, 129, 129, 129, 129, 130,
130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132, 133, 133,
133, 133, 134, 134, 134, 134, 135, 135, 135, 135, 136, 136, 136,
136, 137, 137, 137, 137, 138, 138, 138, 138, 139, 139, 139, 139,
140, 140, 140, 140, 141, 141, 141, 141, 142, 142, 142, 142, 143,
143, 143, 143, 144, 144, 144, 144, 145, 145, 145, 145, 146, 146,
146, 146, 147, 147, 147, 147, 148, 148, 148, 148, 149, 149, 149,
149, 150, 150, 150, 150, 151, 151, 151, 151, 152, 152, 152, 152,
153, 153, 153, 153, 154, 154, 154, 154, 155, 155, 155, 155, 156,
156, 156, 156, 157, 157, 157, 157, 158, 158, 158, 158, 159, 159,
159, 159, 160, 160, 160, 160, 161, 161, 161, 161, 162, 162, 162,
162, 163, 163, 163, 163, 164, 164, 164, 164, 165, 165, 165, 165,
166, 166, 166, 166, 167, 167, 167, 167, 168, 168, 168, 168, 169,
169, 169, 169, 170, 170, 170, 170, 171, 171, 171, 171, 172, 172,
172, 172, 173, 173, 173, 173, 174, 174, 174, 174, 175, 175, 175,
175, 176, 176, 176, 176, 177, 177, 177, 177, 178, 178, 178, 178,
179, 179, 179, 179, 180, 180, 180, 180, 181, 181, 181, 181, 182,
182, 182, 182, 183, 183, 183, 183, 184, 184, 184, 184, 185, 185,
185, 185, 186, 186, 186, 186, 187, 187, 187, 187, 188, 188, 188,
188, 189, 189, 189, 189, 190, 190, 190, 190, 191, 191, 191, 191,
192, 192, 192, 192, 193, 193, 193, 193, 194, 194, 194, 194, 195,
195, 195, 195, 196, 196, 196, 196, 197, 197, 197, 197, 198, 198,
198, 198, 199, 199, 199, 199, 200, 200, 200, 200, 201, 201, 201,
201, 202, 202, 202, 202, 203, 203, 203, 203, 204, 204, 204, 204,
205, 205, 205, 205, 206, 206, 206, 206, 207, 207, 207, 207, 208,
208, 208, 208, 209, 209, 209, 209, 210, 210, 210, 210, 211, 211,
211, 211, 212, 212, 212, 212, 213, 213, 213, 213, 214, 214, 214,
214, 215, 215, 215, 215, 216, 216, 216, 216, 217, 217, 217, 217,
218, 218, 218, 218, 219, 219, 219, 219, 220, 220, 220, 220, 221,
221, 221, 221, 222, 222, 222, 222, 223, 223, 223, 223, 224, 224,
224, 224, 225, 225, 225, 225, 226, 226, 226, 226, 227, 227, 227,
227, 228, 228, 228, 228, 229, 229, 229, 229, 230, 230, 230, 230,
231, 231, 231, 231, 232, 232, 232, 232, 233, 233, 233, 233, 234,
234, 234, 234, 235, 235, 235, 235, 236, 236, 236, 236, 237, 237,
237, 237, 238, 238, 238, 238, 239, 239, 239, 239, 240, 240, 240,
240, 241, 241, 241, 241, 242, 242, 242, 242, 243, 243, 243, 243,
244, 244, 244, 244, 245, 245, 245, 245, 246, 246, 246, 246, 247,
247, 247, 247, 248, 248, 248, 248, 249, 249, 249, 249, 250, 250,
250, 250, 251, 251, 251, 251, 252, 252, 252, 252, 253, 253, 253,
253, 254, 254, 254, 254, 255, 255, 255, 255};
int wavetable_index = 0;
int m;
j=0;
while(1) {
j = (++j)%110;
if(j == 0) {pin_on = 1-pin_on;}
wavetable_index = (wavetable_index+3)%wavetable_size;
//OCR0A = 255 - pin_on * 55;
OCR0A = 255 - wavetable[wavetable_index] * 20;
cycle_delay;
}
}
Play a chord
int parametric_chord(void) {
static uint16_t i,period,cycle,cycles,delays;
static uint8_t amplitude;
static uint16_t steps_per_second = 100000; // 100 000
int k = 4; // a global multiplier to change all note frequencies
// These are the frequencies
uint16_t freqs[] = {440, 466, 493, 523, 554, 587, 622, 659, 698, 740, 784, 830, 880, 350};
int num_notes = 3;
uint16_t notes[] = {0, 4, 7};
//uint16_t notes[] = {0, 12, 8};// {0, 4, 7};
uint16_t periods[num_notes];
uint16_t periodT = 1;
for(i=0;i<num_notes;i++) {
periods[i] = steps_per_second/(freqs[notes[i]]*k);
periodT *= periods[i];
}
static uint8_t waveform;
// initialize MOSFET pin
//
clear(MOSFET_port, MOSFET_pin);
output(MOSFET_direction, MOSFET_pin);
clear(MOSFET_port, MOSFET_pin);
// SET clocks
CLKPR = (1 << CLKPCE);
CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
TCCR0A = ((1 << COM0A0) | (1 << COM0A1) | (1 << WGM01) | (1 << WGM00)); // set OC0B on compare match and set fast PWM mode, 0xFF TOP
TCCR0B = (1 << CS00); // set timer 0 prescalar to 1
int j=0;
while(1) {
j = (++j)%(periodT);
amplitude = 0;
for(i=0;i<num_notes;i++) {
// The following (j/periods[i])%2 == 0 math
// makes a square wave shape:
// up for the period length,
// then down for the period length,
// then repeat.
amplitude += (j / periods[i]) %2 == 0;
}
OCR0A = 255 - amplitude * 20;
cycle_delay;
}
return 0;
}
White noise (using linear shift register) (This is a work in progress. It uses a linear shift register to make pseudo-random numbers between 0-255 which it sends to the speaker)
int white_noise(void) {
// LINEAR SHIFT GENERATES RANDOM NOISE
uint16_t start_state = 0xACE1u; /* Any nonzero start state will work. */
uint16_t lfsr = start_state;
uint16_t bit; /* Must be 16bit to allow bit<<15 later in the code */
unsigned period = 0;
// SET clocks
CLKPR = (1 << CLKPCE);
CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
TCCR0A = ((1 << COM0A0) | (1 << COM0A1) | (1 << WGM01) | (1 << WGM00));
TCCR0B = (1 << CS00);
static uint8_t amplitude;
while(1)
{
/* taps: 16 14 13 11; feedback polynomial: x^16 + x^14 + x^13 + x^11 + 1 */
bit = ((lfsr >> 0) ^ (lfsr >> 2) ^ (lfsr >> 3) ^ (lfsr >> 5) ) & 1;
lfsr = (lfsr >> 1) | (bit << 15);
++period;
amplitude = (lfsr & 0xff)
OCR0A = amplitude;
cycle_delay;
}
}
Wavetables through calculation instead of lookup
If instead of random numbers you use:
amplitude = (period & 0xff);
or
amplitude = (period > 0x80) ? 0xff : 0x80;
you can make triangle waves and square waves, respectively, by calculation instead of lookup. Due to memory constraints on the ATTiny44, this may be a good idea in lieu of upgrading the chip to a mega.