Arduino Audio Input

Send sound into your Arduino.  This Instructable will show you how to prepare audio so that it can be sampled and processed by an Arduino to make sound responsive projects and audio effects.  (This article is a companion to another Instructable I've written about building an audio output circuit for an Arduino, find that here)

Some ideas that come to mind include:

beat detection- trigger lighting effects, build a set of turntables that beat match themselves, or make a robot that dances along with the music you play for it
amplitude detection- make a simple vu meter with LEDS
frequency analysis- you could make a project that reacts to different frequencies in different ways, recognizes certain melodies, turns audio into MIDI data, or translates incoming frequencies into square waves with the tone() library
digital effects boxes/digital signal processing- check out what I did with my vocal effects box (all processing done with Arduino), lots of possibilities here: pitch bending, distortion, sampling, delay, reverb, granular synthesis, mixing, and much more...  I've provided code in this Instructable that lets you sample at up to 38.5kHz.  Here is another instructable describing how to set up a simple audio out circuit with Arduino.
digital recorder- with the addition of an SD card of course (the Arduino has very limited memory by itself), this opens up the possibility of looping large samples and doing lots of other digital manipulations to pieces of stored audio  The circuits and code provided here are compatible with SD card shields that communicate via SPI.
graphical representations of sound- Arduino oscilloscope/visualizer

Feel free to use any of the info in this Instructable to put together an amazing project for the DIY Audio Contest!  We're giving away an HDTV, some DSLR cameras, and tons of other great stuff!  The contest closes Nov 26.

Parts list:
(x1) Microphone Radioshack 33-3038
(x1) TL072 Digikey 296-14997-5-ND or TL082 Digikey 296-1780-5-ND (TL081/TL071 are fine too)  I used a tl082 in my examples
(x2) 9V battery
(x2) 9V battery snap connector Radioshack 270-324
(x1) mono audio jack 1/4" Radioshack 274-340  or Radioshack 274-252 or 1/8" Radioshack 274-333 or Radioshack 274-251
(x1) LED Digikey C513A-WSN-CV0Y0151-ND
(x1) 10kOhm potentiometer linear Digikey 987-1301-ND
(x3) 100kOhm 1/4watt resistors Digikey CF14JT100KCT-ND
(x1) 10uF electrolytic capacitor Digikey P5134-ND
(x1) 47nF ceramic capacitor Digikey P4307-ND
(x1) Arduino Uno (Duemilanove is fine too) Sparkfun DEV-09950

Additional Materials:
22 gauge wire
solder

Step 1: Preparing audio signals for Arduino

If  you've ever recorded audio on your computer, you may have seen it represented as a waveform like the one in fig 1.  If you zoom in on this wave (as in fig 2) you will see that the shape is made of thousands of tiny oscillations back and forth.  This is called an audio signal and when we are dealing with audio signals in electronics, these oscillations represent oscillating voltages over time.

When we look at an audio signal with an oscilloscope, we see a similar picture (fig 3).  Notice how the audio signal in fig 3 oscillates around a center voltage of 0V; this is typical of audio signals.  The amplitude of an audio signal is the distance between its center voltage and its high or low peak.  The amplitude of the wave in fig 3 is 2V: it reaches a maximum voltage of +2V and a minimum voltage of -2V.  This is a problem if we want to measure the audio signal with one of the Arduino's analog inputs because the Arduino can only measure voltages between 0 and 5V.  If we tried to measure the negative voltages in the signal from fig 3, the Arduino would read only 0V and we would end up clipping the bottom of the signal.  In this Instructable I'll show you how you can amplify and offset audio signals so that they fall within this 0-5V range.  Ideally you want a signal with an amplitude of 2.5V that oscillates around 2.5V (like in fig 7) so that its min voltage is 0V and its max voltage is 5V (see the calculations below).

Min voltage = Center Voltage - Amplitude
Min voltage = 2.5V - 2.5V = 0V

Max Voltage = Center Voltage + Amplitude
Max Voltage = 2.5V + 2.5V = 5V

Fig 4 shows the signal coming straight out of the microphone on an oscilloscope.  The signal is relatively weak, with an amplitude of only 200mV, you may find that signals from other sources (ipods, guitars, record players...) also produce audio signals with small amplitudes.  These signals need to be amplified to get them up to the amplitude we want (2.5V).  Amplification means increasing the amplitude (distance between the center point and max or min) of a signal.  Amplification also buffers the audio source (in my case this was a microphone) from any loads that you may put on it later in the circuit, which is a good thing because it prevents distortion.

Fig 5 shows the same microphone signal after amplification, you can see how the height of the peaks has increased so that the wave has an amplitude of 2.5V.  But since the center voltage of the wave is still 0, the wave is oscillating between -2.5 and +2.5V.  It will need to be DC offset to correct this.  DC offset means changing the center voltage that the wave oscillates around (the average voltage of the wave).  Fig 6 shows the signal after it has been DC offset; it still has an amplitude of 2.5V, but the center voltage is 2.5V instead of 0V, so the wave never drops down below 0V.  (Note- the slight change in shape between the signals in figures 5 and 6 is dues to changes in my voice between the two pics, it has nothing to do with the circuit).  The signal in fig 6 is ready to go to an Arduino analog input pin.

Step 2: Prepare audio jack

In this Instructable, I'm only going to talk about how to route one channel of audio into an Arduino.  It is possible to copy the same circuit I've proposed here many times to add multiple channels, but it can complicate/slow things down in the code and at some point you will probably have to lower your sampling rate.  I'll leave it up to you to figure out the details, but please post what you learn in the comments!  Almost all microphones and electronic instruments are mono, meaning they only have one microphone element or pickup which is generating a signal (as opposed to stereo).  You can tell for sure by looking at the plug and comparing it to the image above.  My microphone has a 1/4" plug on it so I used a 1/4" jack for this instructable, you may find that you need a 1/8" jack, but the main ideas here still apply.

Solder a black wire to the ground pin of the mono jack.  The ground pin is usually the larger pin on the jack, test for continuity with the threaded portion of the jack to make sure that you have located the ground pin correctly (see fig 3).  Solder a green wire to the signal pin of the mono jack.  Test for continuity with the clip that extends out from the jack (fig 3).

If you have an oscilloscope handy, connect the reference to the black wire, connect the probe tip to the green wire, plug the microphone in the jack and look for a signal (fig 5).  The signal from my microphone has an amplitude of about 200mV.

Step 3: Non-Inverting Amplifier

The amplifier is the first step in the circuit, it increases the amplitude of the signal from around + or - 200mV to + or - 2.5V (ideally).  The other function of the amplifier is to protect the audio source (the thing generating the audio signal in the first place) from the rest of the circuit.  The outgoing amplified signal will source all its current from the amplifier, so any load put on it later in the circuit will not be "felt" by the audio source (the microphone element in my case).  Do this by setting up one of the op amps in the TL072 or TL082 package in a non-inverting amplifier configuration. 

The datasheet of the TL072 or TL082 says that it should be powered with +15 and -15V, but since the signal will never be amplified above + or - 2.5V it's fine to run the op amp with something lower.  I used two nine volt batteries wired in series to create a + or - 9V power supply.

Wire up your +V(pin 8) and -V(pin 4) to the op amp.   Wire the signal from the mono jack to the non-inverting input (pin 3) and connect the ground pin of the jack to the 0V reference on your voltage supply (for me this was the junction between the two 9V batteries in series).  Wire a 100kOhm resistor between the output (pin 1) and inverting input (pin 2) of the op amp.  In this circuit I used a 10kOhm potentiometer wired as a variable resistor to adjust the gain (the amount that the amplifier amplifies) of my non-inverting amplifier.  Later in this Instructable, I'll show how you can add an LED indicator to Arduino pin 13 to let you know when you have this pot turned up too high (resulting in clipping of the incoming signal by the Arduino); this way you know when you should turn the pot down and get the signal back in the range you want (amplitude of ~2.5V).  Wire this 10K linear taper pot between the inverting input and the 0V reference.

The following equation describes the relative amplitudes of the signal before and after the non-inverting amplifier:

Vout =~ Vin * (1 + R2/R1)
or
Vout/Vin =~ 1 + R2/R1
where R2 is the feedback resistor (between the output and non inverting input), R1 is the resistor to ground, Vout is the amplitude of the outgoing signal (the output from the amplifier), and Vin is the amplitude of the incoming signal (the input to the amplifier)

In this circuit R2 is a 100kOhm resistor and R1 is a 10kOhm potentiometer (variable resistor).  By turning the pot you can change the resistance of R1 from 0Ohms to 10KOhms.  Here are some example calculations:

When the pot is turned all the way to the left the resistance of R1 is 10kOhms and the ratio of Vout to Vin is about:
1+ 100/10 = 11
A signal coming out of the microphone with an amplitude of 200mV (which is fairly loud on my microphone) will be amplified to:
200mv * 11 = 2200mV = 2.2V
this is right in the range we want (amplitude close to 2.5V without going over)

Turning the pot to its halfway position will give it a resistance of 5kOhms, we can calculate the ratio of Vout to Vin again:
1+ 100/5 = 21
now the amplitude gets multiplied by 21
this is too much amplification for the 200mV signal:
200mV * 21 = 4200mv = 4.2V >> 2.5V
but this amplification would be perfect for a 100mV signal:
100mV *21 = 2100mV = 2.1V =~ 2.5V

Turning the pot farther to the right will keep decreasing the resistance of R1 and increase the amplification (also called gain) of this amplifier theoretically to infinity.  Obviously at some point the amplifier will not be able to power a signal with a huge amplitude, but you get the idea.  By adjusting the potentiometer you can adjust the gain of the amplifier and tune the sensitivity of the microphone while still keeping it in a range that the Arduino likes.

Note: As you can see in the circuit above, this project only uses one of the two available op amps in the TL072/TL082 package.  I used this chip because they are easily sourced (you can even buy the TL082 at Radioshack these days), they are basically the same price as the single op amp packages (TL071 and TL081), and you may want to use the extra op amp somewhere else on your circuit (another channel of input, an audio out circuit...).  But if you have a TL071 or TL081, it will do fine for this project.

Step 4: DC Offset

The next portion of the circuit DC offsets the output from the amplifier.  As I explained in step 1, this +2.5V DC offset causes audio signal to oscillate around 2.5V so that it stays within the acceptable range for the Arduino's analog inputs (0-5V).  Compare the non dc offset signal is fig 2 with the dc offset in fig 3.  Specifically, notice how the signal in fig 3 always stays within the 0-5V range.

The DC offset circuit has two main components:  a voltage divider and a capacitor.  The voltage divider is made from two 100k resistors wired in series from the Arduino's 5V supply to ground.  Since the resistors have the same resistance, the voltage at the junction between them equals 2.5V.  This 2.5V junction is tied to the output of the amplifier via a 10uF capacitor.  As the voltage on the amplifier side of the capacitor rises and falls, it causes charge to momentarily accumulate and repel from the side of the capacitor attached to the 2.5V junction.  This causes the voltage at the 2.5V junction to oscillate up and down, centered around 2.5V.

As shown in figs 3-8 and the schematic, connect the negative lead of a 10uF capacitor to the output from the amplifier.  Connect the other side of the cap to the junction between two 100k resistors wired in series between 5V and ground.  Also add a 10nF capacitor from 2.5V to ground.

Step 5: Simple Analog In

Load the following code onto the Arduino.  This code reads the voltage of the incoming audio signal using analogRead(A0) as a number between 0 and 1023 and stores it as the variable "incomingAudio."  From here you could store this value for later use, perform mathematical operations to it, or do any other manipulations you can think of.

//Simple Audio In
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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(){
}

void loop(){
  incomingAudio = analogRead(A0);//read input from A0
  //do stuff with the variable "incomingAudio"
}

In the images above I set up a really simple 8 bit digital to analog converter (read more about it here, or check out fig 4) so that I could visualize the data points that the Arduino was storing as the variable "incomingAudio" and see how close it was to the original signal.  You can see from fig 2 (zoomed in view of fig 1) that the Arduino is taking one sample every 125us from A0.  We can calculate the sampling rate as follows:

sampling rate = 1/125us = 1/0.000125s = 8000hz

To give you a point of comparison, normal audio sampling rates are at least 40kHz.  If a sampling rate of 8kHz or less is good enough for your purposes then you should probably go ahead and use analogRead() to measure your signal, as it keeps things very simple.  You can see in fig 1 that it actually does a pretty good job of tracing out the path of the incoming 360hz signal.  In order to get above 8kHz, we'll have to bypass the analog read function.  It may sound daunting, but it's actually not too bad, just a matter of copying some setup() code that I've written in the next step.

I also want to point out the behavior of the Arduino in response to a signal that rises over 5V and dips under 0V.  In fig 3 you can see how the Arduino clips the incoming signal so that it is always bounded by 0 and 5V.  This causes the tops of the peaks and the bottom of the valleys to get flattened.  In step 8 I'll talk some more about this and how to set up a clipping indicator light to let you know to turn the amplifier down.

Some notes about the 8 bit digital to analog converter (DAC):  I used the command "PORTD = " to send a value between 0 and 255 out of the Arduino and into the DAC where it is converted back into a voltage between 0 and 5V.  The code I used can be found below.  I've written a whole instructable about the 8 bit DAC here.

//Simple Audio In w output to 8 bit DAC
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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 (DAC)
  }
}

void loop(){
  incomingAudio = analogRead(A0);//read voltage at A0
  incomingAudio = (incomingAudio+1)/4 - 1;//scale from 10 bit (0-1023) to 8 bit (0-255)
  if (incomingAudio<0){//deal with negative numbers
    incomingAudio = 0;
  }
  PORTD = incomingAudio;
}

Step 6: Sampling rate of ~40kHz

In the code below I bypassed the function analogRead() in order to increase my sampling rate. The code required to do this is fairly advanced, maybe it can be the subject of another instructable if there's interest (leave a comment if you are interested), but for now it's only important to understand how to use this code in the loop() function, not how I set it up.

Here's simple explanation (all you need to know for now):
Basically in the setup() function I've told the Arduino that I want it to continuously measure pin A0 and forget about the other analog inputs all together.  So while other things are going on in the loop() function, the Arduino is constantly updating a variable called "ADCH" with new values from A0 at a rate of 38.5kHz (that's one sample every 26us, you can see it in fig 2).  When I want to get one of these values I can just set a variable equal to ADCH, or as I wrote in my code:

incomingAudio = ADCH;

I did have to lower the resolution of these analog measurements a little bit to get a higher sampling rate.  In the last step we were using analogRead() to measure the voltage of the signal as a value between 0 and 1023, now these values will always be between 0 and 255.  Also, continuous monitoring of A0 means that the other analog pins are now useless, but if you really need to measure a potentiometer or sensor, check out how you can do it with a digital pin using RCTime  It's possible that the analog pins can still be used as digital I/O pins, but I haven't actually tested this yet, leave a comment if you try it!

The complicated explanation (not necessary, but for those who are interested):
I manually set the Arduino's internal analog to digital converter (ADC) counter to 500kHz and read an 8 bit value from analog input 0 from the ADCH directly (I just read the most significant 8 bits of the 10 bit ADC to save time in the code).  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.  As you can see in fig 2, this gives me one sample every 13/500000 = 26us.  A lot of the ideas here (prescalers and counters) are similar to the setup for Arduino timer interrupts, and you can read more about how that works here.

//Audio out with 38.5kHz sampling rate
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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;//storage for A0 data

void setup(){
  
  //set up continuous sampling of analog pin 0 (you don't need to understand this part, just know how to use it in the loop())
  
  //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
  
  //if you want to add other things to setup(), do it here

}

void loop(){
  incomingAudio = ADCH;//get new value from A0
  //do other stuff here
}

As in the previous step, I sent the values of the variable "incomingAudio" out an 8 bit DAC so that I could visualize the data as it was being stored in the Arduino.  You can see the incoming signal (yellow) and output from the DAC (blue) in the images above.  Notice how much better the Arduino follows the signal compared to the last step.  In fig 2 you can see that the step size is down to 26us (compared to 125us when using analogRead).  Again you can see the effects of clipping at 0V and 5v in fig 3.

The code for sampling rate of 38.5kHz with DAC output is given below.

//Audio out with 38.5kHz sampling rate and DAC output
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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(){

  for (byte i=0;i<8;i++){
    pinMode(i,OUTPUT);
  }
  
  //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
  
  //if you want to add other things to setup(), do it here

}

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

Step 7: Interrupt

In this piece of code, I set up the Arduino to continuously monitor pin A0 at 38.5kHz, but now I've added a piece of code that automatically updates the variable "incomingAudio" each time a new value from A0 has been calculated.  Instead of putting the line:

incomingAudio = ADCH;

in the loop() function of the Arduino sketch, I've put it in a special function called an "interrupt routine."  The interrupt routing looks like this:

ISR(ADC_vect) {
  incomingAudio = ADCH;
}

Think of it as a normal sketch, the Arduino first goes through the setup() function then it starts the loop(), but every 26us (when a new value is ready from A0) the Arduino stops what it is doing in the loop and does whatever is encapsulated in the interrupt routine (in this case just the line "incomingAudio = ADCH;").  Once the interrupt routine has finished, the Arduino picks up again where it was in the loop() for another 26us.  Then the interrupt routine executes again.... this goes on repeating forever.  If you want, you can read more about Arduino interrupts here. 

This interrupt code generally a better way of reading the incoming signal than the way I wrote it in the last step because you are only updating the variable incomingAudio once each time a new value comes in.  Updating the variable multiple times, before the value has even had time to change is redundant.  Also, if you want to record these values you can put the storage code in the interrupt routine so you know that your storage sampling rate is exactly 38.5kHz.

//Audio out with 38.5kHz sampling rate and interrupts
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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(){

  cli();//disable 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

  //if you want to add other things to setup(), do it here

}

ISR(ADC_vect) {//when new ADC value ready
  incomingAudio = ADCH;//update the variable incomingAudio with new value from A0 (between 0 and 255)
}

void loop(){
//do other stuff here
}

Step 8: Clipping Indicator

A clipping indicator LED is useful so that you know if you need to turn the gain down on your amplifier.  If your signal is clipping as it comes into the Arduino, you are losing information about the signal.  Figs 2 and 3 show the incoming signal (yellow) and the data stored in the Arduino (blue) for both 8kHz and 38.5kHz sampling rates.  Notice how the Arduino completely misses the behavior of the peaks and valleys due to clipping.

To set up the clipping counter I created a few new variables.  "clipping" has a state of 1 when the Arduino detects clipping (the incoming signal is measured to be 0 or 5V) and a state of 0 when the Arduino does not detect clipping.  In the code below (for 8kHz sampling rate) I also set up a variable called clippingCounter.  The purpose of this variable is to keep the indicator LED on for a moment after the clipping was detected so that it is visible to the human eye.  In the 38.5kHz code (at the bottom of this step) I used a delay(100) to achieve the same effect.

//Simple Audio In with clipping indicator
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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;
boolean clipping = 0;//zero = not clipping, one = currently clipping
int clippingCounter = 5000;

void setup(){
}

void loop(){
  incomingAudio = analogRead(A0);//read input from A0
  //do stuff with the variable "incomingAudio"
  if (incomingAudio == 0 || incomingAudio == 1023){//if clipping
    digitalWrite(13,HIGH);//set pin 13 high
    clipping = 1;//currently clipping
    clippingCounter = 5000;//reset clippingCounter
  }
  if (clipping){
    if (clippingCounter>0){
      clippingCounter--;//decrement clipping counter
    }
    else{//if clippingCounter has counted all the way down
      clipping = 0;//no longer clipping
      digitalWrite(13,LOW);//turn of clipping indicator
    }
  }
}

and below is the code for 38.5kHz with interrupts:

//Audio in with 38.5kHz sampling rate, interrupts, and clipping indicator
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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.
 *
*/

//variable to store incoming audio sample
byte incomingAudio;

//clipping indicator variables
boolean clipping = 0;

void setup(){
  
  pinMode(13,OUTPUT);//led indicator pin
  
  cli();//disable 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

  //if you want to add other things to setup(), do it here

}

ISR(ADC_vect) {//when new ADC value ready
  incomingAudio = ADCH;//store 8 bit value from analog pin 0
  if (incomingAudio == 0 || incomingAudio == 255){//if clipping
    digitalWrite(13,HIGH);//set pin 13 high
    clipping = 1;//currently clipping
  }
}

void loop(){
  if (clipping){//if currently clipping
    clipping = 0;//
    digitalWrite(13,LOW);//turn off clipping led indicator (pin 13)
  }

  delay(100);
}

Comments

[lbais]

Thank you for your response amanda!

Going to the point, Is it because it takes more than 10 seconds to make the loop of 160000 or 380000 samples. I can see it because I put a led on the 7 pin output

each sample into the interrupt function set the "flag" to 0. Into the main program I've put a while true where I ask continuosly if flag is setting to 0. When flag is 0 and the samples are less than 380000 (i've made this because i'm testing an amount of samples that I can play later) I start to write the SD card with the byte that I get into the interrupt function.

if(flag == 0)
{
flag = 1;
if (samples < 380000)
{

dataFile.write(incomingAudio);
samples ++;
}
else
{
dataFile.close();
digitalWrite(7, LOW);
}

I also deleted the line "dataFile.write(incomingAudio);" to check it and it works in the same way.

Also, when I reproduce the audio file it sounds in fast forward.


---------- I'm working in other kind of interrupt, a timer one but I can't do it work as I want, it has the same kind of issue

//set timer1 interrupt at 1Hz
TCCR0A = 0;// set entire TCCR0A register to 0
TCCR0B = 0;// same for TCCR0B
TCNT0 = 0;//initialize counter value to 0
// set compare match register for 2khz increments
OCR0A = 249;// = (16*10^6) / (10000*64) - 1 (must be <256)
// turn on CTC mode
TCCR0A |= (1 << WGM01);
// Set CS01 and CS00 bits for 64 prescaler
TCCR0B |= (1 << CS01) | (1 << CS00);
// enable timer compare interrupt
TIMSK0 |= (1 << OCIE0A);

sei();//allow interrupts

}//end setup

ISR(TIMER0_COMPA_vect){//timer0 interrupt 10kHz
flag = 0;
incomingAudio = analogRead(0);//update the variable incomingAudio with new value from A0 (between 0 and 255)


}

[amandaghassaei]

can you post your whole sketch, I'm having some trouble following, I suspect the issue is that you are not writing the sample in the 38.5khz interrupt.

[amandaghassaei]

yeah you need to move the line dataFile.write(incomingAudio); into the interrupt to get a sampling rate of 38.5.

[lbais]

Hi, my name is Lucas and i'm one of your followers from Argentina.
I learnt yesterday your instructable about auido + arduino. And I have a few questions that may be you can explain to me.
I have a little project where I have to record a sample of audio in a SD card, I have the Arduino UNO and ethernet SHIELD.

I've made this input audio http://www.atmel.com/Images/doc1456.pdf (page 7) that I put in my A0 analog input.

I've made a audio format research and I've decide to write the bytes in a WAVE format, that is the simpler audio format that I've found.
https://ccrma.stanford.edu/courses/422/projects/WaveFormat/

Following those instructions and yours I could make a sample of audio but it's seems to be issue with the interrupt, like if the interrupt is not working at 38,5khz.

I also saw the interrupt guide that is in linked in your instructable, but I thing that is not clear at all what you are doing there, i can't understand that " ADCSRA " means and why do you put the prescaler to 500khz.

If I make a counting of samples into the main, it takes 27 second to record 380000 samples rate when it should take less than 10 seconds.

I'll send you my pice of code where you can find what I'm doing. (I know that the frecuency I putted in the WAVE header is not 38.5khz but putting 16khz its sounds better).

I hope you can understand what I said, sorry about my english it's pritty bad


//Audio out with 38.5kHz sampling rate and interrupts

#include

struct HEADER
{
byte chunkid[4];
byte chunksize[4];
byte format[4];
byte subchunk1id[4];
byte subchunk1size[4];
byte audioformat[2];
byte numchannels[2];
byte samplerate[4];
byte byterate[4];
byte blockalign[2];
byte bytepersample[2];
byte subchunk2id[4];
byte subchunk2size[4];
};

HEADER headerwave = {0x52, 0x49, 0x46, 0x46, // RIFF
0x00, 0x00, 0x00, 0x00, // 4 + (8 + SubChunk1Size) + (8 + SubChunk2Size) o bien 36 + subchunk2size
0x57, 0x41, 0x56, 0x45, // WAVE
0x66, 0x6d, 0x74, 0x20, // FMT_
0x10, 0x00, 0x00, 0x00, // Chunk size 16 para pcm
0x01, 0x00, // Audio Format PCM
0x01, 0x00, // Cantidad de canales
0x80, 0x3E, 0x00, 0x00, // Frecuencia
0x80, 0x3E, 0x00, 0x00, // SampleRate * NumChannels * BitsPerSample/8
0x01, 0x00, //NumChannels * BitsPerSample/8
0x08, 0x00, // bits por muestra
0x64, 0x61, 0x74, 0x61, // DATA
0x00, 0x00, 0x00, 0x00, // NumSamples * NumChannels * BitsPerSample/8
};

unsigned long int samples = 0;
byte* headerbegin = &headerwave.chunkid[0];
const int chipSelect = 4;
int incomingAudio;
byte flag = 0;
byte iled = 0;
boolean eled = true;


void setup()
{
pinMode(10, OUTPUT);
if (!SD.begin(chipSelect)) {
return;
}

pinMode(7, OUTPUT);

cli();
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;//update the variable incomingAudio with new value from A0 (between 0 and 255)
flag = 0;
/* iled++;
if (iled == 1000)
{
iled = 0;
if (eled)
{
digitalWrite(7, LOW);
eled = false;
}
else
{
digitalWrite(7, HIGH);
eled = true;
}
} */
}


void loop()
{
digitalWrite(7, HIGH);
File dataFile = SD.open("test.wav", FILE_WRITE);
if(dataFile)
{
headerwave.subchunk2size[0] = 0x00;
headerwave.subchunk2size[1] = 0x71;
headerwave.subchunk2size[2] = 0x02;
headerwave.chunksize[0] = 0x24;
headerwave.chunksize[1] = 0x71;
headerwave.chunksize[2] = 0x02;
dataFile.write(headerbegin, 44);

while(true)
{
if(flag == 0)
{
flag = 1;
if (samples < 160000)
{

dataFile.write(incomingAudio);
samples ++;
}
else
{
dataFile.close();
digitalWrite(7, LOW);
}
}
}

}
}

[amandaghassaei]

the analog to digital conversion in the ADC takes 13 clock cycles. 500khz/13 = 38.5khz.
ADCSRA/B and ADMUX are registers that are set at the beginning of a sketch that tell the chip how to behave.
why do you think the interrupt is not working at 38.5kHz?

[Aldaron13]

Hi there. I am new to arduino and was thinking of using this tutorial for a college project. I am just curious on the different applications/uses of this. Would you be able to, say, control something on your computer using sound? Not necessarily voice control but like getting a reaction from (for example) an animation? I am just trying to understand how useful this could be. Any help would be much appreciated!

[amandaghassaei]

I've never tried using this with serial.read(), I'm not sure if the arduino is fast enough to keep up a 39kHz sampling rate and serial.read. if you are not planning on outputting this audio ever as audio, I'd recommend just using analogRead() over and over to monitor the input

[bwaayer]

I'm not all to bothered about losing what's on A0, it's just that I can't remove it :( All I would need is say A1 working. Cheers for the quick reply!

I can't reply to your comment annoyingly, as it won't display the captcha :(

[amandaghassaei]

try this:

//clear ADCSRA and ADCSRB registers
ADCSRA = 0;
ADCSRB = 0;

inputChannel = 1;//A# input pin
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
ADMUX |= inputChannel;

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

//if you want to add other things to setup(), do it here

[bwaayer]

Hi there, how would I go about reading off of say A1?
I already have something hard-wired to pin A0 :(

[amandaghassaei]

this code (running an analog in at this speed) renders all but one of the analog pins useless

[nlarsson2]

If I amplify the signal before feeding it into the circuit, could I feed the audio jack input straight into this part of the circuit in order to make it usable to the arduino?

[amandaghassaei]

Yes, you'll still need the dc offset, but as long as you are amplifying to 2.5v somewhere it should work

[rulasIMT]

Hey Again Amanda, i would like to know if you could give me a hand understanding how the code works, i already have the op amp and sac working, and i would like to mix your tutorial with the sketches found in http://interface.khm.de/index.php/lab/experiments/arduino-realtime-audio-processing/
and also in http://monksoundworks.blogspot.mx
in order to use that effects that i don't understand where the actual effect its done, i mean in which part from sketch, and use them with your input output method
thanks, and hope quick answer still on school project
Regatds Raul

[amandaghassaei]

//Audio in with 38.5kHz sampling rate, interrupts, and clipping indicator
//by Amanda Ghassaei
//http://www.instructables.com/id/Arduino-Audio-Input/
//Sept 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.
*
*/

//variable to store incoming and outgoing audio samples
byte audio;

//clipping indicator variables
boolean clipping = 0;

void setup(){

pinMode(13,OUTPUT);//led indicator pin
DDRD = B11111111;//digital pins 0-7 are all outputs

cli();//disable 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

//if you want to add other things to setup(), do it here

}

ISR(ADC_vect) {//when new ADC value ready
audio = ADCH;//store 8 bit value from analog pin 0, audio input
if (audio == 0 || audio == 255){//if clipping
digitalWrite(13,HIGH);//set pin 13 high
clipping = 1;//currently clipping
}
//do all digital signal processing stuff here to the variable "audio"
PORTD = audio;//send the output to the DAC
}

void loop(){
if (clipping){//if currently clipping
clipping = 0;//
digitalWrite(13,LOW);//turn off clipping led indicator (pin 13)
}

delay(100);
}

[eng mizo]

hay amanda ,, i hope u are well,, thank u very much for your fantastic topic :)

can you help me to do my project of wheelchair controlled voice ??
i need some information about required code
and how i can indicate the words " go , back , right , left , stop" in ardwino code

waiting your answer

thanks alot

[amandaghassaei]

hey, this sounds like a really cool project, unfortunately I don't know a ton about speech recognition and I'm not sure the arduino is powerful enough to handle something like that. definitely write back if you figure it out, sorry I couldn't help more.

[rulasIMT]

im using your r2r ladder tutorial from there to guitar amp, if i run just a sine wave test it works awsome. i had checked with ociloscope, im using 10k and 22k resistors, at input im using 220k pot and 220k resistor, i also noticed that if i change from guitar if the guitar outputs more resistance lets 15k sounds better than my guitar that outputs 9.5 k
regards and thanks

[amandaghassaei]

Did you put a low pass filter on the output? Try increasing the value of the cap

[rulasIMT]

Done amanda, now i eliminate the distortion but i have too much background noise

[amandaghassaei]

how are you outputting the audio?

[rulasIMT]

using ceramic cap code 104

[rulasIMT]

i used your clipping check code, and now its right, but what still giving me headaches its the background noise like a hum

[rulasIMT]

thanks, mm we are talking about the resistor that bridges the 2 pins from op amp right?,also i made the one you pusted identical and i got a real nice distortion that for guitar pedal its gorgeous, but for my project i wanna get rid of it thanks
regards

[amandaghassaei]

the 10k and 100k resistors here:
http://www.instructables.com/id/Arduino-Audio-Input/step3/Non-Inverting-Amplifier/
sounds like you might be clipping, try turning down the amplification

[rulasIMT]

Hey Amanda your projects had been very useful for a school project i working on, i would very glad and pleased if yo can help me with the schemtic of the non-inverting amp, but instead a mic, i would use a guitar
regards and thanks in advance

[amandaghassaei]

the schematic is the same, you may have to mess around with the resistor value a little bit to get it in the right range

[stringstretcher]

Amanda has asked me to post my question here in hopes of finding an answer to my problems.. (at least THIS one!)

I want to log data using an Arduino Uno but am having problems reading my input correctly. The device I want to read is a Radio Shack Sun and Sky Station. It has contacts for DC output, which is in millivolts, never more than 1.5V at max. On my meter it reads a steady voltage, but the Arduino shows a fluctuating reading when using the analog/serial data sketch. I have asked on several of the forums and received varying answers, none of which I can make work. Is the solution an amplifier for the signals? Why does the Arduino give me any reading at all? It seems to vary in an almost sinusoidal wave, but I don't have a scope to see that. Sample and hold? Opamp? Any ideas?

Jim ,
Västerås, Sweden

[amandaghassaei]

have you been reading it with you meter while it is attached to the arduino? sometimes meters aren't fast enough to notice these types of fluctuations, can you tell approx what frequency it is by the readings from the arduino?

[amandaghassaei]

also, do you have the arduino grounded to the Radio Shack thing's ground?

[stringstretcher]

I tried grounding the device's battery to the arduino, with no change. I have not had the Volt/Ohm meter connected while the arduino was reading. I tried adjusting the gain on the device, but the arduino spits out small spikes, or peaks, not a continuous stream, like it should if there were a constant voltage present at the Analog input, which the "should be!"

[amandaghassaei]

have you figured it out? sorry I couldn't help more.

[stringstretcher]

I managed to get a fair signal reading by placing a 3300 uF cap across the output leads. I took the device to my local shop and asked them to look at the signal output on their scope. They determined a sine ripple, and we could rectify it and get a reading with the Arduino.
Thanks for all the help, we all learn here.

[favrin]

Hello amandaghassaei
Great instructable. I followed your unstructions for audio input. I need help to record adc values to sd card. I'm stuck. When i try to write data to sd card i get poor quality audio, with lot of noise and barely audiable. can you help pls?

[amandaghassaei]

can you post your code and schematic?

[GianfrancoPa]

good works!!!

But, if instead a microphone, I wish to use the magnetic head of a magstripe reader??? What I have to change???

Thanks a lot!!!

[amandaghassaei]

yes definitely, I think the setup should be pretty much the same, just replace the two inputs from the mic with the two inputs from the magnetic strip reader.

[bhar92]

Yay! It worked, thanks so much Amanda!
You're awesome!

Bhargav
Bangalore, India

[amandaghassaei]

great! what are you using it for?

[chownRusBase]

This looks great for a project I want to tackle. How much more work is involved to get the sound out via the USB port?

Thanks!