Arduino Vocal Effects Box

This Arduino-powered vocal effects box pitch shifts and distorts incoming audio signals to produce a wide variety of vocal effects.  This project is my first experiment with real-time digital signal processing using Arduino.  It samples an incoming microphone signal at a rate of about 40kHz, manipulates the audio digitally, and then outputs 8 bit audio at 40kHz.  To minimize the amount of computation required by the Arduino, I used a technique called granular synthesis to manipulate the incoming audio signal.  Essentially, as audio comes into the Arduino it gets cut up and stored as small (millisecond or microsecond sized) samples called "grains."  These grains are then individually manipulated and played back; they may be lengthened or shortened, stretched or compressed, played back in reverse, copied several times, or mixed with other grains.  You can hear a (somewhat creepy) audio sample from the effects box below:

Granular synthesis creates a unique type of distortion caused by discontinuities between individual grains in the outgoing signal.  Sometimes this distortion creates an effect I can only describe as a "ripping" sound, other times it introduces new frequencies into the audio that were not present before.  Here is an example by Aphex Twin, the granular synthesis is especially prominent in the bridge at around 3min in. Another example of granular synthesis, this time applied to vocals for pitch shifting and textural effects, is from Paul Lansky.  My favorite thing to do with this effects box is to use subtle pitch shifting to achieve an androgynous vocal sound, I got the idea for the project after listening to copious amounts of Fever Ray this past winter, you can hear how she pitch shifts her voice to sound somewhat masculine at times.

PARTS LIST

(1x) Arduino Uno REV 3 Radioshack 276-128
(7x) 10K Ohm 1/4-Watt Carbon Film Resistor (2 packages) Radioshack #271-1335
(9x) 20K Ohm 1/4-Watt Carbon Film Resistor (2 packages)
(1x) 1K Ohm 1/4-Watt Carbon Film Resistor Radioshack 271-1321
(1x) 50K-Ohm Linear-Taper Potentiometer Radioshack #271-1716
(1x) 10KOhm Audio Control Potentiometer with SPST Switch Radioshack #271-215 (this will be used to control volume and turn the device on/off)
(5x) 0.25" Knurled Knob Radioshack 274-424
(2x) 9V Alkaline Battery Radioshack #23-866
(2x) Heavy-Duty 9V Snap Connectors Radioshack #270-324
(1x) PC Board with Copper Radioshack #276-147
(1x) SPST PC-Mountable Submini Toggle Switch Radioshack #275-645
(2x) Male Header Pins Jameco 103393
(3x) 8 pin socket Radioshack 276-1995
(1x) TL082 Wide Dual JFET Input Op Amp Radioshack 276-1715
(3x) 100K Ohm 1/4-Watt Carbon Film Resistor (1 package) Radioshack 271-1347
(1x) 10uF electrolytic capacitor
(1x) 47nF capacitor
(3x) 0.1uf capacitor Radioshack 55047557
(2x) 1M-Ohm Linear Taper Potentiometer Radioshack 271-211
(1x) 1MOhm logarithmic potentiometer
(1x) 2kOhm 1/4-Watt Carbon Film Resistor
(1x) male header pins Jameco 103393
(1x) 10K-Ohm Linear-Taper Potentiometer Radioshack 271-1715
(1x) DPDT Flatted Metal Lever Toggle Switch Radioshack 275-636
(2x) 1/4" stereo jack Radioshack 274-141 or Radioshack 274-312
(2x) 5mm High-Brightness White LED (1 package) Radioshack 276-017
(2x) 100 ohm 1/4W 5% Carbon Film Resistor Radioshack 271-1311
(2x) TS922IN Dual Op Amp Digikey 497-3049-5-ND (one TS924 would also work, but they are not available on digikey at the moment)

Additional Materials:
22 Gauge Wire Radioshack #278-1224
Solder Radioshack #64-013
sand paper
plywood
wood glue
hot glue
screws

Download Arduino IDE

Step 1: Schematic

I've broken the schematic into three parts so it is easier to understand.

The first schematic shows the audio out circuit. This project outputs audio through an 8 bit R2R digital to analog converter through Arduino digital pins 0-7.  This signal is sent through an amplifier, a low pass filter, and a volume control pot before being sent out to speakers.

The second schematic shows the mic input circuit.  The line in the from the mic is sent through an amplifier and a DC offset circuit before being sent into the Arduino via analog input pin A0.

The third schematic shows how all the controls of the effects box are connected to the Arduino.  There are two LED indicators in this project: one clipping indicator and one output indicator.  Three pots on the device control grain size, pitch, and wet/dry mix and a switch controls the direction of sample playback (forward or reverse).

Step 2: Header Pins

Solder header pins to your protoboard so that you can snap the arduino directly to the board.  Unfortunately the spacing between digital pins 7 and 8 on the arduino is not the standard 2.54mm, so I've found that it's best to try to avoid using these pins if possible (anolog pins can also be used as digital I/O).  If you have to use them, try finding long header pins which you can bend into shape (fig 4- from another project).

Step 3: DAC: Part 1

Solder eight 20kOhm resistors to arduino pins D0-D7 as shown in the images above.

Step 4: DAC: Part 2

Solder seven 10kOhm resistors in between each of the 20kOhm's you just soldered.  Add an additional 20kOhm resistor to the 20kOhm connected to arduino D0 (the bottom of the ladder).

Step 5: DAC: Part 3

Connect the other end of the 20kOhm reisistor to arduino ground

Step 6: Test DAC

Connect the output from the DAC up to an oscilloscope, be sure to connect ground as well.  Load the firmware below onto the Arduino.  The DAC should output a sine wave oscillating between 0 and 5V with a frequency of ~63Hz (see image above).  If you need help understanding how to use/read the oscilloscope check out this tutorial.

//63Hz sine wave
//by Amanda Ghassaei 2012
//http://www.instructables.com/id/Arduino-Vocal-Effects-Box/

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
*/

//sends 63Hz sine wave to arduino PORTD DAC
float t = 0;

void setup() {
  //set port/pin  mode. see http://www.arduino.cc/en/Reference/PortManipulation for more info
  DDRD = 0xFF;//port d (digital pins 0-7) all outputs
  
  cli();//stop interrupts

  //set timer2 interrupt at 40kHz
  TCCR2A = 0;// set entire TCCR2A register to 0
  TCCR2B = 0;// same for TCCR2B
  TCNT2  = 0;//initialize counter value to 0
  // set compare match register for 40khz increments
  OCR2A = 49;// = (16*10^6) / (8*40000)-1
  // turn on CTC mode
  TCCR2A |= (1 << WGM21);
  // Set CS11 bit for 8 prescaler
  TCCR2B |= (1 << CS11);   
  // enable timer compare interrupt
  TIMSK2 |= (1 << OCIE2A);
  
  sei();//allow interrupts
}

ISR(TIMER2_COMPA_vect) {
  //increment t
  t+=1;
  if (t==628){//40kHz/628 =~ 63Hz
    t=0;
  }
}


void loop(){
  //sine wave of frequency ~63Hz
  //send sine values to PORTD between 0 and 255
  PORTD=byte(127+127*sin(t/100));
}

Some info about the code- basically what I've done here is set up a timer interrupt that increments the variable t at a frequency of 40kHz.  Once t reaches 627 it resets back to zero (this happens with a frequency of 40,000/628 = 63Hz).  Meanwhile, in the main loop the Arduino sends a value between 0 (00000000 in binary) and 255 (11111111 in binary) to digital pins 0 through 7 (PORTD).  It calculates this value with the following equation:

PORTD=byte(127+127*sin(2*t/100));

So as t increments from 0 to 627 the sine function moves through one complete cycle.  The value sent to PORTD is a sine wave with frequency 63Hz and amplitude 127, oscillating around 127.  The DAC translates this to a voltage between 0 and 5V, where a 0 sent to PORTD equals 0V and a 255 sent to PORTD equals 5V.

Step 7: 8 pin socket and buffer

Solder an 8 pin socket to the breadboard.  Connect ground to pin 4, 5V to pin 8 and the signal from the DAC to pin3.  Solder pins 1 and 2 together (fig 2).  This puts the signal through a voltage follower.  The voltage follower acts as a buffer, protecting the output from the DAC from any loads that are put on it later in the circuit.

Step 8: Wire up pot

Connect three leads to a 10k exponential pot (labelled with an "A") as shown in fig 3.  Solder the red lead to pin 1, the green lead to pin 5, and the black lead to ground/pin 4.  Solder pins 6 and 7 together (fig 2).  This pot will adjust the amplitude of the signal- it is a volume control knob.  It does this by acting as a variable voltage divider.

Step 9: Second 8 pin socket

Solder a second 8 pin socket and connect ground to pin 4 and 5V to pin 8.

Step 10: Voltage divider

Solder a 10kOhm resistor to pin 7 of the first TS922IN.  Connect a 2kOhm resistor in series with the 10kOhm resistor and connect the other end of the 2kOhm to ground.  This is another voltage divider- the purpose of this portion of the circuit is to scale the signal to 2000/(10000+2000) =1/6th its amplitude, I did this so that the max volume would not completely destroy my hearing.  Unlike the voltage divider I set up in the last step with the pot, this voltage divider does not change; it scales the amplitude of the signal permanently.  The scaled signal comes out from the junction between the two resistors.

If you are planning to send the output out as line level into another effects module or amplifier, then do not add this voltage divider.

Step 11: RC low pass filter

The purpose of a low pass filter in this part of the circuit is to remove the digital artifacts from the output of the DAC without losing too much detail in the higher frequencies of the audio signal.
Nyquist's Theroum states that for a sampling rate of x Hz, the highest frequency that can be produced is x/2 Hz.  So if you have a sampling rate of 40kHz (standard for most audio), then the maximum frequency you can reproduce is 20kHz (the upper limit of the audible spectrum).
By using a low pass filter on the signal with a cutoff frequency of 20kHz, you can smooth out the "steps" in your waveform while keeping the overall shape of the waveform intact.  I used a simple RC flow pass filter to achieve this: a resistor and a capacitor in series to ground.  Connect the resistor to the incoming signal and the capacitor to ground, the signal from the junction between these two components will be low pass filtered.
You can calculate the values of the capacitor and resistor you need for a low pass filter according to the following equation:

cutoff frequency = 1/ (2*pi*R*C)

so for a cutoff frequency of 20,000Hz and 1kOhm resistor:

20000=1/(2*3.14*1000*C)
C =~ 8nF

Since 8nF capacitors are hard to come by I rounded up to 0.01uF.  This gives a cutoff frequency of about 16kHz.  You can mess around with different values and see what you like best, I tend to like heavier filtering bc it removes more unwanted noise.

Solder a 1kOhm resistor to the junction from the voltage divider from the last step (if you did not include the voltage divider, solder straight to pin 7).  Solder a 0.01uF capacitor in series with this resistor to ground.  Solder a wire from the junction between the capacitor and resistor to pin 5 of the second socket.
 

Step 12: More buffering

In this step I wired the two op amps on the second chip as voltage followers and wired them in parallel so they could source twice the current.  As in step 7, this voltage follower acts as a buffer, protecting the incoming waveform from the load of the headphones which will eventually be attached to the output of the buffer.

Solder a wire between the two non-inveting inputs of the op amps (pins 5 and 3 of the second socket).  Solder another wire between the two outputs (pins 1 and 7 of the second socket).  On the underside of the board solder the inverting inputs to their outputs (fig 2).

Step 13: DC offset

After all the voltage dividers, the signal coming out of the op amps oscillates between 0 to about 1V (or 0 to 5V if you did not include the voltage divider in step 10).  Before sending the signal out to speakers/headphones, it must be offset to oscillate around 0V.  This is called a DC offset, it is achieved by running the signal through a capacitor.

Solder the - end of a 100uF (or higher) capacitor to the output of the second op amp.  The signal coming from the + end of the capacitor will be DC offset to oscillated around 0V.

Step 14: Audio Jack

Unscrew the plastic case of the audio jack.  Solder a black wire (ground) to the longer lead, and wire a green wire (signal out) to the two shorter leads.  This jack is stereo, but the signal out of the Arduino is mono, so just wire the mono signal to both stereo outputs.

Use hot glue to add some structural support to these connections and prevent short circuits.  Solder the green wire to the + end of the 100uF capacitor and solder the black wire to ground.

Step 15: Microphone Circuit

Fig 2 shows the signal coming straight out of the microphone on an oscilloscope.  The signal is relatively weak, with an amplitude of only 200mV.  Notice how the signal oscillates around 0 volts- this is typical of audio signals.  Ideally, you want to have a signal with a max amplitude of 2.5V oscillating around 2.5V.  This way the signal is completely contained within 0-5V; the Arduino will be able to measure it with maximum resolution and no clipping.  In order to do this, the signal will need to be DC offset and amplified.  DC offset means changing the level that the wave oscillated around (the midpoint of the wave).  Amplification means increasing the amplitude (distance between the center point and max or min) of a signal.  Amplification also buffers the microphone element from any loads that you may put on it later in the circuit, which is a good thing because it prevents distortion.

Fig 3 shows the same microphone signal after amplification, you can see how the height of the peaks has increased so that the wave oscillates between -2.5 and 2.5 V (amplitude of 2.5V).  Fig 4 shows the signal after it has been DC offset; it still has an amplitude of 2.5V, but the center point is 2.5V instead of 0V, so the wave never drops down below 0V.  (Note- the slight change in shape between the signals in figure 3 and 4 is dues to changes in my voice between the two pics, it has nothing to do with the circuit).  The signal in fig 4 is ready to go to an Arduino analog input pin.

Step 16: Batteries

Two nine volt batteries will be needed to power the TL082.  The double pole double throw (DPDT) switch will act as a power switch to both batteries.  DPDT switches actually have two separate switches in them, but they are controlled by the same toggle mechanism (fig 1).  Wire the red ends of two battery snaps to one side (the same side) of each switch (figs 3 and 4).  Solder red wires to the middle leads of each switch (figs 5 and 6).  Use hot glue to secure the solder joints if necessary (fig 7).

Step 17: Amplifier socket and power

Solder an 8 pin socket onto the protoboard (fig 1).  As shown in the pin diagram for the TL082, +V connects to pin 8 and -V connects to pin 4.  Connect on of the red wires from the middle lead of the DPDT switch to pin 8.  Let's call the battery snap that is attached to this red lead snap #1.  Solder the black lead from snap #2 to pin 4 of the socket (figs 2 and 3).  Solder the black lead from snap #1 and the remaining red lead from the center pin of switch #2 together on the protoboard (figs 3 and 4), this is the center tap (0v) between the +9/-9V supply.  Solder this connection to arduino ground (fig 8).

Step 18: Microphone input

Unscrew the plastic case from the 1/4" jack.  If you have a mono microphone, unclip the right lead (fig 2).  I also trimmed some of the metal from the larger lead- the ground lead (figs 5 and 6).  Solder a black wire to the ground lead and a green wire to the other lead.  Cover the leads of the jack with hot glue to prevent short circuiting or breakage.

Step 19: Non-inverting amplifier: part 1

Solder the wires from the 1/4" jack to the protoboard.  Solder the black wire to arduino ground and the green wire to pin 5 of the 8 pin socket.

Step 20: Non-inverting amplifier: part 1

Solder a 100K resistor between pins 6 and 7 of the 8 pin socket.

Step 21: Non-inverting amplifier: part 2

Solder two leads onto a potentiomer (shown in fig 1) so that it acts as a variable resistor.  Solder one side (doesn't matter which) to ground and the other side to pin 6 of the socket.  This pot will control the amplitude of the incoming microphone signal.

Step 22: DC offset: part 1

The DC offset circuit is comprised of two capacitors and a voltage divider.  Solder a 10uF electrolytic capacitor so that the + lead connects to pin 7 of the socket.

Step 23: DC offset: part 2

Solder a 47nF capacitor to the - end of the 10uF capacitor.  Connect the other side of the 47nF cap to ground.

Step 24: DC offset: part 3

Create a voltage divider between Arduino +5V and ground by wiring two 100kOhm resistors in series between 5V and ground.  Connect the middle junction of the voltage divider to the junction between the two capacitors of the DC offset circuit.  This will add 2.5V to the amplified microphone signal.

Step 25: Connect to analog input

Connect analog input 0 to the junction between the two capacitors in the DC offset circuit.

Step 26: Simple audio out

Load the following code onto the Arduino.  This code reads the signal coming into A0, converts it to a number between 0 and 255, and outputs it to the DAC.  On the oscilloscope in the image above you can see the incoming mic signal in blue and the signal straight out of the DAC in yellow.  Notice how each step of the DAC output is about 125us long.  In this simple setup, the sampling rate is 1/125us or 8kHz.  In the next steps I'll be manually setting the ADC counter and lowering the resolution of the Arduino's analog to digital conversion from 10 bit (0-1023) to 8 bit (0-255) to increase speed and get the sampling rate up.

//Simple Audio Out
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Vocal-Effects-Box/
//July 2012

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
*/

int incomingAudio;

void setup(){
  for (byte i=0;i<8;i++){
    pinMode(i,OUTPUT);//set digital pins 0-7 as outputs
  }
  pinMode(A0,INPUT);
}

void loop(){
  incomingAudio = analogRead(A0);//read input from A0
  incomingAudio = incomingAudio/4;//scale from 10 bit to 8 bit
  PORTD = incomingAudio;//send out DAC
}

Step 27:

In the code below I bypassed the function analogRead() in order to increase my sampling rate.  I manually set the ADC counter to 500kHz and read an 8 bit value from analog input 0 from the ADCH directly.  I set the ADC counter to 500kHz because the ADC takes 13 clock cycles to read a new analog value.  500/13 = 38.5kHz which gets me pretty close to 40kHz (standard audio sampling rate) without introducing extra noise.

//Audio out with 38.5kHz sampling rate
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Vocal-Effects-Box/
//July 2012

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
*/

void setup(){
  DDRD=0xFF;//set port d (digital pin s0-7) as outputs
  DDRC=0x00;//set all analog pins as inputs
  
  
  //set up continuous sampling of analog pin 0
  
  //clear ADCSRA and ADCSRB registers
  ADCSRA = 0;
  ADCSRB = 0;
  
  ADMUX |= (1 << REFS0); //set reference voltage
  ADMUX |= (1 << ADLAR); //left align the ADC value- so we can read highest 8 bits from ADCH register only
  
  ADCSRA |= (1 << ADPS2) | (1 << ADPS0); //set ADC clock with 32 prescaler- 16mHz/32=500kHz
  ADCSRA |= (1 << ADATE); //enabble auto trigger
  ADCSRA |= (1 << ADEN); //enable ADC
  ADCSRA |= (1 << ADSC); //start ADC measurements
  
}

void loop(){
  PORTD = ADCH;//send 8 bit value from analog pin 0 to DAC
}

In the code below I triggered the output to the DAC via the ADC interrupt. This interrupt is similar to other Arduino timer interrupts, but it only executed when a new ADC value has been reached (in this case at a rate of ~38.5kHz, or every 26us). The output of the code below is exactly the same as the code above, but it will be more convenient to use the interrupt code moving forward.

//Audio out with 38.5kHz sampling rate and interrupts
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Vocal-Effects-Box/
//July 2012

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
*/

void setup(){
  DDRD=0xFF;//set port d (digital pin s0-7) as outputs
  DDRC=0x00;//set all analog pins as inputs
  
  cli();//diable interrupts
  
  //set up continuous sampling of analog pin 0
  
  //clear ADCSRA and ADCSRB registers
  ADCSRA = 0;
  ADCSRB = 0;
  
  ADMUX |= (1 << REFS0); //set reference voltage
  ADMUX |= (1 << ADLAR); //left align the ADC value- so we can read highest 8 bits from ADCH register only
  
  ADCSRA |= (1 << ADPS2) | (1 << ADPS0); //set ADC clock with 32 prescaler- 16mHz/32=500kHz
  ADCSRA |= (1 << ADATE); //enabble auto trigger
  ADCSRA |= (1 << ADIE); //enable interrupts when measurement complete
  ADCSRA |= (1 << ADEN); //enable ADC
  ADCSRA |= (1 << ADSC); //start ADC measurements
  
  sei();//enable interrupts
}

ISR(ADC_vect) {//when new ADC value ready
  PORTD = ADCH;//send 8 bit value from analog pin 0 to DAC
}

void loop(){
}

Step 28: Half frequency playback

The code below records short section of incoming audio into one of two arrays: buffer1 and buffer2.  It also introduces a variable called "scale."  This variable is used to scale the playback of the stored buffer audio in order to change the frequency.  The code below sets scale to 2, this doubles the length of time it takes for the dac to output the stored audio.  As you can see in the image above, the output from the dac (yellow) is half the frequency of the input from the microphone (blue).

//Half Frequency Playback
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Vocal-Effects-Box/
//July 2012

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
*/

//audio storage
byte buffer1[1000];
byte buffer2[1000];

byte incomingAudio;//storage variable

int i = 0;//index variable
int iscale = 0;//index variable
int scale = 2;
boolean toggle = 0;
boolean rec = 1;
int limit = 1000;


void setup(){
  DDRD=0xFF;//set port d (digital pin s0-7) as outputs
  DDRC=0x00;//set all analog pins as inputs
  
  cli();//diable interrupts
  
  //set up continuous sampling of analog pin 0
  
  //clear ADCSRA and ADCSRB registers
  ADCSRA=0;
  ADCSRB = 0;
  
  ADMUX |= (1 << REFS0); //set reference voltage
  ADMUX |= (1 << ADLAR); //left align the ADC value- so we can read highest 8 bits from ADCH register only
  
  ADCSRA |= (1 << ADPS2) | (1 << ADPS0); //set ADC clock with 32 prescaler- 16mHz/32=500kHz
  ADCSRA |= (1 << ADATE); //enabble auto trigger
  ADCSRA |= (1 << ADIE); //enable interrupts when measurement complete
  ADCSRA |= (1 << ADEN); //enable ADC
  ADCSRA |= (1 << ADSC); //start ADC measurements
  
  sei();//enable interrupts
}

ISR(ADC_vect) {//when new ADC value ready
  incomingAudio = ADCH;
  if (rec){
    if (toggle){
      buffer1[i] = incomingAudio;//store incoming
      PORTD = buffer2[iscale];//send out DAC
    }
    else{
      buffer2[i] = incomingAudio;//store incoming
      PORTD = buffer1[iscale];//send out DAC
    }
  }
  else{
    if (toggle){
      PORTD = buffer2[iscale];//send out DAC
    }
    else{
      PORTD = buffer1[iscale];//send out DAC
    }
  }
  i += 1;
  iscale = i/scale;
  if (i==limit){
    rec = 0;//stop recording
  }
  if (i == (limit*scale)){
    i = 0;
    iscale = 0;
    toggle^=1;
    rec = 1;
  }
}

void loop(){
}

Step 29: RC potentiometers

Since the ADC is busy converting the incoming audio from A0 to digital, the three control pots on the effects box (wet/dry, pitch, and grain size) will have to be monitored using one of the digital pins.  This can be down using an RC circuit.  This circuit uses a digital pin on the Arduino to measure the amount of time it takes to discharge a capacitor.  This time is related to the resistance in the circuit which is set by a potentiometer.  This way, we can indirectly measure the resistance of the potentiometer.

Solder a row to header pins to digital pins 9-13.  Solder a 10kOhm resistor and 0.1uF capacitor in series to pins 10-12.  Solder the free end of the 0.1uF capacitors together and connect to Arduino +5V.  Connect the outside pin of two 1mOhm linear taper pots to the junction between the resistor and capacitor attached to digital pins 11 and 12.  Connect the outside pin of a 1mOhm logarithmic taper pot to the junction between the resistor and capacitor attached to digital pin 10.  Solder the middle pins of each pot to ground.

I you'd like you can increase the resolution of any of these controls by increasing the capacitance of the 0.1uF cap to 1uF or 10uF.  This change will have to be accounted for in the final firmware as well.

Step 30: Switch

This switch allows reverse playback of recorded samples.  Solder a 10kOhm resistor to one of the leads from the switch.  Solder a red wire to the other end of the resistor and connect to ground.  Solder a wire to the junction between the resistor and the switch and connect to Arduino digital pin 9.  solder a black wire to the remaining pin from the switch and connect to ground.

Step 31: Indicator LEDs

Solder 100ohm resistors to the anodes of two white indicator LEDs.  Connect the cathodes of both indicator LEDs to ground.  Connect the anode of one of the LEDs to digital pin 13- this is the clipping indicator.  The other indicator LED will be connected to a switch in the next step.

Step 32: Output switch

this switch will turn on an indicator LED to show that the output is on.  Solder two wires to the back of the 10kOhm pot.  Connect one wire to Arduino 5V and the other to the anode of the indicator LED.  The other end of the indicator LED connects to ground.

Step 33: Enclosure

I designed a triangular enclosure in corel draw and cut it from 1/4" plywood on a laser cutter.  Two sides have holes for the input and outputs controls (jack, indicator LED, and gain potentiometer).  The front panel has holes for the rest of the controls (on/off switch, reverse switch, wet/dry mixer, pitch pot, grain size pot).  The bottom has a hole for easy access to the arduino's usb port.

I coated the plywood in three coats of polycrylic and glued the sides together with wood glue.  I glued three small triangular pieces into the corners of the enclosure so that I could screw the back panel on with wood screws (fig 3). 

Attach the Arduino to the header pins on the protoboard and begin installing the components in the enclosure.  I started by attaching the pots and switches to the front panel and then added the jacks, LED indicators, and pots to the sides.  Finally I pushed the arduino's usb port through the square hole on the bottom of the enclosure. My arduino sat firmly in place, you could screw it to the back panel for an extra secure fit.

I've attaches the corel file for the enclosure that I built.

Step 34: Batteries

Secure batteries in the corners of the enclosure with a battery clip or a piece of velcro.  Screw on back panel of enclosure.

Step 35: Knobs

Attach knobs to potentiometers and secure with a set screw.

Step 36: Final firmware

Here is the final code for the project.  I've already explained the basic ideas behind most of the audio processing in previous steps.  The only changes I've made here is to add some code which allows the pots and switches on the device to change the value of a few variables: "scale," "grain," "forward," and "wet" and "dry."

//Final effects box code
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Vocal-Effects-Box/
//Aug 2012

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
*/

/*
pots:
wet/dry
grain size
pitch shift
*/

//audio storage
byte buffer1[500];
byte buffer2[500];

//buffer recording variables
boolean toggle = 0;
boolean rec = 1;

//pot checking storage
int scale = 20;
int scalePot;
int newScale = scale;
byte multiplier = 0;
int grain = 500;
int grainPot;
int newGrain = grain;
int wetDryPot;
int wet = 16;
int dry = 16-wet;
int newWetDry = wet;

//data retrieval variables
unsigned int i = 0;//index variable
int iscale = 0;//index variable
int iscalerev = grain-1;

//clipping indicator variables
boolean clipping;
int clippingCounter = 5000;

//reverse switch variables
boolean forward = 0;
boolean newForward = forward;


void setup(){
  DDRD=0xFE;//set digital pins 0-7 as outputs
  DDRB=0xFD;//set digital pins 10-13 as outputs, 9 as input
  DDRC=0x00;//set all analog pins as inputs
  
  cli();//diable interrupts
  
  //set up continuous sampling of analog pin 0
  
  //clear ADCSRA and ADCSRB registers
  ADCSRA = 0;
  ADCSRB = 0;
  
  ADMUX = 0;//Clear ADMUX register
  ADMUX |= (1 << REFS0); //set reference voltage
  ADMUX |= (1 << ADLAR); //left align the ADC value- so I can read highest 8 bits from ADCH register only
  //since I'm reading A0, I don't need to specifiy which analog pin I want to read from (0 is default)
  
  ADCSRA |= (1 << ADPS2) | (1 << ADPS0); //set ADC clock with 32 prescaler- 16mHz/32=500kHz
  ADCSRA |= (1 << ADATE); //enabble auto trigger
  ADCSRA |= (1 << ADIE); //enable interrupts when measurement complete
  ADCSRA |= (1 << ADEN); //enable ADC
  ADCSRA |= (1 << ADSC); //start ADC measurements
  
  sei();//enable interrupts
}



ISR(ADC_vect) {//when new ADC value ready
  if (rec){
    if (toggle){
      buffer1[i] = ADCH;//store incoming
      if (ADCH == 0 || ADCH == 1023){//if clipping
        PORTB |= 32;//set pin 13 high
        clippingCounter = 5000;//reset clipping counter
        clipping = 1;//currently clipping
      }
      if (forward){//forward
        PORTD = (wet*int(buffer2[iscale])+dry*int(ADCH))>>4;//send out DAC
      }
      else{//reverse
        PORTD = (wet*int(buffer2[iscalerev])+dry*int(ADCH))>>4;//send out DAC
      }
    }
    else{
      buffer2[i] = ADCH;//store incoming
      if (ADCH == 0 || ADCH == 1023){//if clipping
        PORTB |= 32;//set pin 13 high
        clippingCounter = 5000;//reset clipping counter
        clipping = 1;//currently clipping
      }
      if (forward){
        PORTD = (wet*int(buffer1[iscale])+dry*int(ADCH))>>4;//send out DAC
      }
      else{
        PORTD = (wet*int(buffer1[iscalerev])+dry*int(ADCH))>>4;//send out DAC
      }
    }
  }
  else{
    if (toggle){
      if (forward){
        PORTD = (wet*int(buffer2[iscale])+dry*int(ADCH))>>4;//send out DAC
      }
      else{
        PORTD = (wet*int(buffer2[iscalerev])+dry*int(ADCH))>>4;//send out DAC
      }
    }
    else{
      if (forward){
        PORTD = (wet*int(buffer1[iscale])+dry*int(ADCH))>>4;//send out DAC
      }
      else{
        PORTD = (wet*int(buffer1[iscalerev])+dry*int(ADCH))>>4;//send out DAC
      }
    }
  }
  i++;//increment i
  iscale = i*10/scale-grain*multiplier;
  iscalerev = grain-iscale-1;
  if (i==grain){
    rec = 0;//stop recording
  }
  if (i>=(grain*scale/10)){
    if (scale<10){
      if (i==grain){
        i = 0;
        iscale = 0;
        iscalerev = grain-1;
        forward = newForward;//update direction
        scale = newScale;//update scale
        grain = newGrain;//update grain
        dry = newWetDry;//update wet dry
        wet = 16-dry;
        toggle ^= 1;//try removing this
        rec = 1;
        multiplier = 0;
      }
      else if (iscale>=grain){
        iscale = 0;
        iscalerev = grain-1;
        multiplier++;
      }
    }
    else{
      i = 0;
      iscale = 0;
      iscalerev = grain-1;
      forward = newForward;//update direction
      scale = newScale;//update scale
      grain = newGrain;//update grain
      dry = newWetDry;//update wet dry
      wet = 16-dry;
      toggle ^= 1;//try removing this
      rec = 1;
      multiplier = 0;
    }
  }
  if (clipping){
    clippingCounter--;//decrement clipping counter
  }
}

void checkScale(){
  PORTB &= 251;//set pin 10 low
  scalePot = 0;
  while(digitalRead(10)){
    scalePot++;
  }
  newScale = scalePot+2;
}

void checkGrainSize(){
  PORTB &= 247;//set pin 11 low
  grainPot = 0;
  while(digitalRead(11)){
    grainPot++;
  }
  if (grainPot < 1){
    grainPot = 1;
  }
  else if (grainPot > 20){
    grainPot = 20;
  }
  newGrain = grainPot*25;
}

void checkWetDry(){
  PORTB &= 239;//set pin 12 low
  wetDryPot = 0;
  while(digitalRead(12)){
    wetDryPot++;//from 0 to ~185
  }
  if (wetDryPot < 10){
    wetDryPot = 0;
  }
  else if (wetDryPot > 160){
    wetDryPot = 160;
  }
  newWetDry = wetDryPot/10;//scale down to 16
}

void checkRev(){//check reverse switch
  if (digitalRead(9)){
    newForward = 1;
  }
  else{
    newForward = 0;
  }
}

void loop(){
  if (clipping){//if currently clipping
    if (clippingCounter<=0){//if enough time has passed since clipping
      clipping = 0;//not currently clipping
      PORTB &= 223;//turn off clipping led indicator (pin 13)
    }
  }
  DDRB=0xFD;//set pins 10-12 as outputs
  PORTB |= 28;//set pins 10-12 high
  delay(1);//wait for capacitor to discharge
  checkRev();//check reverse switch
  DDRB= 0xE1;//set pins 10-12 as inputs
  checkScale();
  checkGrainSize();
  checkWetDry();
}

Comments

[knutolai]

For some reason the anti-spam captcha box won't appear when I wish to post a reply. Ill just add my reply as a new post:

I see. Yeah I was actually quite surprised at the relatively high samplerate you managed to achieve! I though the atmega328 was way to slow/simple to handle that. Have you considered using a audio codec (external ADC and DAC) (http://uk.rs-online.com/web/c/?sra=oss&r=t&searchTerm=audio+codec&x=-608&y=-21) for both input and output? I don't think there is very much point in increasing the fidelity after the processing when the audio is compressed to 8-bit fidelity when 'entering' the Arduino.
This could also be something to look into: http://soniccrayon.blogspot.no/2012/08/anti-nautilus-or-autoglitch.html (the schematic, first image below the youtube video)

[knutolai]

Hi Amandaghassaei! First of; Great project! Im gonna have to build one this summer :) Something came to mind though. I saw you mentioned you were looking to increase the fidelity by adding a DAC chip. Have you considered the option of using the output PWM-stream option of the atmega328 chip? That would be a option to building a resistor-ladder as you have done. You would only need one digital output channel and a low-pass filter (preferably a two pole, or steeper, filter).

[amandaghassaei]

theoretically this idea is possible, but I think in practice the arduino is just not fast enough to handle audio input and PWM output at 38kHz. The resistor ladder is the most minimally processing intensive way to get the audio out. This project pushed the limits of what the arduino is capable of, I think you would find some very odd behavior if you tried to push it more. great idea though, would totally work in another context! I'm curious about how the fidelity would compare.

[AJMansfield]

An easier alternative to that would be just buying a resistor pack.

[AJMansfield]

Normally, the pitch of a perf board is actually not 2.54 mm but 0.1 inch (although they are almost exactly the same length) - the standard that established that spacing used inches, not mm, so the size should be quoted in inches, not mm.

[tmdrake]

I might have to try this project...I really want to get my hands dirty with DSP...this looks like the easiest way to learn so far.

[manuel123]

I'm working on a similar project, how did you power the arduino, I see no connection to the Vin pin in any of your diagrams.

[amandaghassaei]

sorry, I must have forgotten to draw that in the schematic, I'll change it asap.  Vin is connected the the +9V supply that is powering the TL082 mic amplifier op amp. It is just a 9V battery supply. be sure to connect the negative terminal of the battery to Arduino's ground. I actually wrote an instructable about it here.

[manuel123]

Also, is it possible to use a ac-dc power supply instead of two batteries? A voltage divider should provide positive and negative current to the op amp but I'm not sure how you'd ground the arduino.

[amandaghassaei]

yes it is possible. you should look up dual rail supply circuitls. Here is a good start:
http://www.instructables.com/id/Split-rail-power-supply-from-a-single-rail-supply/
you can see in this project how there's a +V, -V, an 0V supply. Connect the 0V supply to Arduino ground.

[manuel123]

Got it, thanks a lot. Built a buffered voltage divider using an op-amp to save space. One last question, I want to use a DAC instead of the resistor ladder to save space and improve the sound quality, I have a bunch of DAC0800 ICs and I know the basics of how to work them but my current setup doesn't seem to be getting any sound out of the arduino (I'm using your sine wave generator code) how would you set up the DAC?

[amandaghassaei]

funny you ask me that today, I just posted a relevant project here:
http://www.instructables.com/id/Stereo-Audio-with-Arduino/
your dac setup should be similar, let me know if you still can't get it up and running, I can take a look at the data sheet.

[manuel123]

I got it to run but it turns out the buffer is not doing it's job properly. It works when I invert the voltage inputs but it gives me negative voltage. I tested the divider and I'm getting 4v on one end and 10 on the other I need some kind of buffer that has a small outline (I'm short on space)

[manuel123]

I'm thinking either a rail splitter or a BUF634 buffer.

[AMC92]

Hey so I am currently putting this project together for a class. I am around step 10 and you say to use a 2kOhm resistor, except in the supplies list there is not one listed, or at least not that I can find. I wanted to make sure this is the resistor I need to get. If you could let me know that'd be great! :)

[amandaghassaei]

yes, it's in there. sorry I'll update the parts list!

[Vee20]

Hi, there was just a glitch in my connections. Got my sound working all right :)
I had this hooked up and was messing around with sound on my PC speakers and was wondering if this voice stream could get sent to my PC via ethernet. Say using the ethernet shield connected to the arduino being used?

[amandaghassaei]

I think it could work. The ethernet shield uses pins 10-13 to communicate:
http://www.arduino.cc/en/Main/ArduinoEthernetShield
so you will need keep those pins free. If you keep the clipping indicator, you will need to move it to another digital pin (like pin 9)
Check out this piece of code:
http://www.instructables.com/id/Arduino-Audio-Input/step7/Interrupt/
you should try to send your serial data via ethernet inside the interrupt routine. Hopefully the Ethernet Shield is fast enough to send data at 38.5kHz, I'm not sure.
code with clipping indicator is at the bottom of this page:
http://www.instructables.com/id/Arduino-Audio-Input/step8/Clipping-Indicator/
change all the 13's to 9's

[amandaghassaei]

do you have an amplifier connected to the DAC? your headphones may be putting too much of a load on the DAC and causing the signal to sag. do you have an oscilloscope? is there any way for you to measure the amplitude of the incoming/outgoing signals? maybe even a multimeter in ac mode?

[Vee20]

Hi, such an awesome instructable. Very clear, especially for a novice like me!
I'm working on a project and wondering if this can also work with voice input, via an electret (specifically using this one: http://www.sparkfun.com/products/9964) ?
Thanks for your assistance!

[amandaghassaei]

thanks! yes, this will work. I actually just bought a few of these myself to mess around with, I'm sure I'll be posting more about them soon. I'm not sure how big the signal coming out of these mic elements is, you may need to adjust the gain of the amplifier (by changing the resistor values). I go into a lot more detail about setting up a mic input for an Arduino here. I also did a fun frequency detection project here that you might like.
Let me know what you make! and definitely let me know if you have questions!

[Vee20]

HI, so I got to work connecting up my board, with said electret. As it has the break out board (with 100x gain and dc offset) I just connected it straight to the Arduino. (analogue pin 0, gnd and 5V).
I connected up the DAC as per your instructions. However, using the sketch in step 27, I don't get any sound through to my headphones (zero output). I find this odd as my serial monitor is giving me an endless stream of symbols (input from electret).
Please help, I have no idea what I could be doing wrong, may have missed something.
Oh, for now I'm just working on inputting voice, through a mic and out through headphones, manipulating it with arduino. This seems pointless at the moment but it will be implemented into a larger project with arduino at it's core. Will keep you updated as I go along.
Thanks again for your help :)

[dfodel1]

Hey Amanda... this thing looks great. I am wanting to build one to use to process ambient room sounds that one could then listen to in headphones. I was just wondering if you could try that and post a recording, just so I'd know what the result might sound like?
Thanks for the super clear images and directions.

[amandaghassaei]

thanks, there's a recording in the first step.

[dfodel1]

well... yes i saw the recording... but that's of a song. what i am wondering is what the result of ambient room sound might be through the device. just random sounds of in-room conversation, doors opening and closing etc, etc.
not sure you have the unit sitting around that you could just set it up and go about your business there in the lab/office.

thanks again for the great work.

[amandaghassaei]

unfortunately I've taken it apart, so I can't record anything right now. I'm planning on upgrading to a 8 bit parallel DAC IC instead of the r2r ladder, hopefully to reduce the noise in the signal.... I've been hoping to do something with ambient room/street sounds as well at some point, hopefully I can post something in the next few months. sorry if that's not soon enough!
amanda

[primeq]

Very nice job on this. Concept, execution and - excellent ! - documentation. Outstanding all around

[jakebaldwin]

People on one of my favorite little corners of Reddit seem to like your recording. I'm a big fan of this project, too. Cool stuff! http://www.reddit.com/r/FifthWorldPics/comments/107tck/over_the_granular_rainbow/c6b99hh

[amandaghassaei]

cool thanks! I wonder who that person is who says they went to school with me, their username just isn't ringing a bell

[fungus amungus]

You don't remember Mr. BlowTrees?

[amandaghassaei]

:) I'm sure he is a respectable gentleman

[rifakungen]

Hmm i get a compiler error..

It says "time was not declared in this scope" in the following part.

void checkWetDry(){
PORTB &= 239;//set pin 12 low
time = 0;
while(digitalRead(12)){
wetDryPot = time;//from 0 to ~185

Can someone please help?

[amandaghassaei]

yes sorry, I must have uploaded the wrong piece of code there, this was remnant from when I was testing things. I've fixed it and it is compiling fine now, so I think it's ok. Just to be safe I'm going to upload this code on my hardware again tonight to double check that this is the right file.... this thing went through many iterations as you can imagine.

[rifakungen]

I have now tested all the codes. An there is something borked with the final code. The audio throughput works and that.. But none of the controls work.

[amandaghassaei]

really? hmm, I didn't get a chance to test last night, but I will definitely have time this weekend for sure. Just looking closely at the code right now pitch/ grain size/ forward and reverse look like they're all enabled and fine to me. Do you have an oscilloscope? does the outgoing audio look pitch shifted? if so, by how much? are you using the values of pots that I recommended?

[rifakungen]

Yes i got a scope. I get mostly funky noise out with a lot of 8-bit artifacts. No real wavefom or anything to measure with.. But the DAC and all works.. Here is a video of the setup just throughputting music: https://www.youtube.com/watch?v=brbE3oNshpU

I have used the same values on the componentsa as you. But i am using electrolytic caps for the RC circuitry.. Maybe that doesn't work.

[amandaghassaei]

electrolytic caps are fine, but what value are they? I had to calibrate my numbers from the RCtime to fit the values of components I was working with.

[amandaghassaei]

try commenting out the line:
forward = newForward;//update direction
scale = newScale;//update scale
grain = newGrain;//update grain
is the output working now? it should just following the incoming signal.
try changing int scale = 10
does that give you half frequency playback?

[rifakungen]

Yes the output works when i comment these lines. But no control over anything.
int scale = 10 does not change anything.
The caps are .1µF

[amandaghassaei]

huh, but the code form step 28 works for you fine? are you using atmel 328? I'll take a closer look at the final code this weekend, it's been a month or so since I worked on this last, so I'm going to need some time to refresh my memory. We'll figure it out though, check back on mon.