Microcontroller Programming

This page is a work in progress. The board and source files will soon be available for building and programming to play custom songs. After assembling the board, communication with the programmer was verified, and both the LED and switch functionality were confirmed. The testing phase involved the DAC and buffer, during which an initial error was identified: the resistor ladder was wired with the bit order reversed, leading to higher-order bits on the microcontroller being connected to lower-order bits on the ladder. Software adjustments to correct the bit order proved to be inefficient, requiring either bit-by-bit rearrangement or a 256-entry lookup table for byte reversal. Initial testing with a program counting from 0 to 255 revealed that the output voltage was not increasing linearly and only a few bits were effective. The issue was traced back to a resistor value error due to a decimal point transposition, resulting in incorrect resistance values. After replacing the faulty resistors and rewiring the circuit to correct the bit order, digital audio synthesis was implemented using a precomputed sine wave stored in a lookup table. By iterating through this table at varying speeds, tones of different frequencies can be produced. Chords were created by using multiple pointers into the table, each moving at different speeds to correspond with the notes' frequencies. To simulate realistic sound dynamics, amplitude envelopes, which are also lookup tables, were applied. These envelopes feature an attack phase, decay, sustain, and release, collectively known as an "ADSR" envelope, allowing for a wide range of sound variations.

Digital audio synthesis involves generating sound waves through a structured approach, primarily using a digital-to-analog converter (DAC) to output signals. The sine wave serves as the fundamental waveform, providing a smooth and continuous audio output. The lookup table for the sine wave is critical, as it contains precomputed values that facilitate efficient audio generation. By adjusting the speed at which the program reads through this table, different frequencies can be achieved, allowing for a wide range of musical notes.

In creating chords, the system utilizes multiple pointers, each accessing the sine wave table at varying rates. This method enables the simultaneous generation of different frequencies, which are then summed to produce a harmonious sound. The resulting audio output can be further enhanced by applying amplitude envelopes, which shape the sound's dynamics over time. The ADSR envelope is particularly effective in simulating natural acoustic instruments, as it introduces a gradual increase in volume at the onset of a note (attack), followed by a decrease to a stable level (decay), a sustained volume (sustain), and finally a decrease to silence (release).

The implementation of the amplitude envelope requires careful design, as it functions independently from the sine wave table, operating over a much longer duration. This allows for the creation of complex audio textures, as adjustments to the envelope parameters can yield a variety of sound characteristics. The versatility of this approach makes it suitable for a wide range of applications, from simple tone generation to more advanced audio synthesis tasks. Overall, the described system exemplifies the integration of digital components and software programming to achieve dynamic audio synthesis, providing a foundation for further exploration in electronic music production.This page is a work in progress. ran out of time. Soon the board and source files will be here so you can build your own and program it to play your own songs! After I finished putting the board together, I quickly verified that I could communicate with the board using a programmer and that the LED and the switch were functional.

I don`t use AVR S tudio for any of my actual coding, but it`s great for talking to the chip over debugWIRE and quickly verifying board functionality. Then, I moved on to testing the DAC and buffer, and noticed my first mistake with the circuit. I had wired up the resistor ladder with the bit order reversed: higher-order bits on the microcontroller were wired to lower-order bits on the ladder.

Swapping bit order around in software turns out to be an expensive operation; the options are basically rearranging things one bit at a time (taking many instructions) or using a 256-entry lookup table mapping bytes to their reversed versions. I started with the first approach for testing, and discovered another problem. I wrote a simple program that counted from 0 to 255, and output the value on the DAC. That should generate a nice ramp function. However, what I saw was this: The voltage was increasing, but nowhere near linearly and only with a couple of bits of resolution, certainly not 256 steps.

Further testing revealed that only the top few bits had any effect. When debugging something, one has a tendency to overlook the simple things and focus on the complicated ones. After scratching my head for a while looking at the wrong parts of the circuit, I finally realized that when I picked out the resistors from the shelf, I transposed a decimal point on one of the values and the resistances for one value were ten times higher than they were supposed to be!

I swapped out the bad values for what they were supposed to be, and in the process cut a few traces and added some wire to reverse the order of the bits so it wouldn`t need to be done in software. Digital audio synthesis starts with a waveform. I used a sine wave, one period of which I precomputed using a Python script and stored in a table in my program.

By iterating through the table at different speeds and outputting the values through the DAC, I can produce tones at various frequencies: Not a bad sine wave. You can certainly see some quantization noise, from only using 8 bits of resolution and a sample rate of only about 12kHz, but it will work.

Chords can be formed by having several pointers into the table and moving them along at different speeds corresponding to the different frequencies of the notes in the chord, then summing the values at all of the pointers. Here`s a nice C-major chord: There are no real instruments that instantly start producing sound at some volume level and continue at exactly the same level until the sound stops.

Usually, the volume ramps up (sometimes sharply, sometimes more gradually) when a note is played, and falls off when the note is released. In the synthesizer, we get this effect using amplitude envelopes. The amplitude envelopes are lookup tables just like the sine wave. We start with a pointer at the beginning of the table, gradually moving it along as the sound is played and multiply each sample with the value in the table.

The amplitude envelope doesn`t loop like the sine waveform, and it is played much more slowly (over thousands of samples. ) Here`s an example of the sine wave with an amplitude envelope applied: This envelope follows a pretty common pattern: there`s an upward slope at the beginning (the "attack") reaching a peak value, then falling off to a mid-level (the "decay") where it stays for a while (the "sustain") before falling off to silence at the end (the "release").

Because of these four segments, such an envelope is sometimes referred to as an "ADSR" envelope, and many different sounds can be achieved by adjusting the slopes and levels of 🔗 External reference