MEMS Microphone Hookup Guide

Contributors: jenfoxbot
Favorited Favorite 2


The SparkFun MEMS microphone breakout board is a simple and easy-to-use microphone for a variety of sound-sensing projects. The on-board mic is an ADMP401, which is a low-power, omnidirectional microphone with an analog output. It works for both near and long-range uses and is particularly good for portable applications due to its low power consumption. Possible applications include: smartphones, digital video cameras, and keeping an "ear" on your pets while you're away.

SparkFun MEMS Microphone Breakout - INMP401 (ADMP401)

SparkFun MEMS Microphone Breakout - INMP401 (ADMP401)


Read this hook-up guide to get an overview of the breakout board and how to use it, including its technical specifications, how to hook it up to a microcontroller, and an example code to get started!

Questions? Feedback? Want to share an awesome project you built using this sensor? Write a comment at the end of this tutorial!

Suggested Reading

To successfully use the SparkFun MEMS microphone breakout board, you'll need to be familiar with Arduino microcontrollers, analog (aka ADC) input, and sound waves. For folks new to these topics, check out the following resources to get a feel for the concepts and verbiage used throughout this tutorial.

MEMS Mic Breakout Board Overview

The SparkFun MEMS Microphone breakout board uses the ADMP401 microphone for sound detection. There are three ports for this board: Vcc, the power input (~ 3.3V), GND, or ground, and AUD, the audio signal output. The AUD output is an analog signal. To power this lil' mic, use a DC voltage between **1.5 and 3.3V **with a supply current of about 250 μA.

backside view

For technically-minded folks, here are some of the features of the ADMP401:

  1. High Signal-to-Noise Ratio ("SNR") of 62 dBA
  2. Sensitivity of about -42 dBV
  3. Flat frequency response from 100 Hz to 15 kHz
  4. Low current consumption of <250 μA
  5. Maximum acoustic input of 120 dB

Check out the ADMP401 datasheet for a complete overview of the board.

The SparkFun breakout board includes an amplifier with a gain of 67, which is more than sufficient for the ADMP401 mic. The amplifier's AUD output will float at one-half Vcc when there is no sound. When held at arms length and talked into, the amplifier will produce a peak-to-peak output of about 200 mV.

Quick Start

If all of this is super familiar, here's all you need to get started:

  1. Solder wires (or headers) to the three MEMS mic breakout board ports.

  2. Connect the Vcc port to 3.3V (or anything between 1.5 and 3.3V) and the GND port to ground.

  3. Connect the AUD port to an analog (ADC) input on a microcontroller.

  4. Read in the ADMP401 analog signal and measure/record all the sounds! (Also remember it's a sound signal, so you'll likely want to use the amplitude of the sound wave rather than the raw voltage output.)

wire hookup

Hardware Hookup

For a more in-depth example, follow along with the following steps:

  1. Solder three wires (or header pins) to the breakout board ports. Recommended to use red for Vcc, black for GND, and yellow (or some other color) for AUD to easily distinguish the board ports.

  2. Connect the Vcc port to the 3.3 V output of a microcontroller (or any power supply between 1.5 and 3.3 V).

  3. Connect the GND port to GND on the microcontroller.

  4. Connect the AUD port to an analog, or ADC, input on the microcontroller.

alt text

The next section will cover how to read the Audio signal from the Mic to a microcontroller.

Arduino Software Example

The ADMP401 signal output is a varying voltage. When all is quiet (shhhh), the AUD output will float at one-half the power supply voltage. For example, with a 3.3 V power supply, the AUD output will be about 1.65 V. In the photo below, the yellow marker on the left side of the oscilloscope screen marks the zero axis for the voltage (aka V = 0). The pulse is the AUD output of a finger snap close to the mic.


Converting ADC to Voltage

The microcontroller analog (ADC) input converts our audio signal into an integer. The range of possible ADC values depends on which microcontroller you are using. For an Arduino microcontroller, this range is between 0 and 1023, so the resolution of our ADC measurement is 1024. To convert our analog measurement into a voltage, we use the following equation:


In our case, the ADC Resolution is 1024, and the System Voltage 3.3 V. We'll need to add this equation in our code to convert our ADC Reading into a voltage.

But Wait, What Are We Actually Measuring??

For many applications that deal with sound (which is a wave), we're mostly interested in the amplitude of the signal. In general, and for the sake of simplicity, a larger amplitude means a louder sound, and a smaller amplitude means a quieter sound (and the sound wave frequency roughly corresponds to pitch). Knowing the amplitude of our audio signal allows us to build a sound visualizer, a volume unit ("VU") meter, set a volume threshold trigger, and other cool and useful projects!

To find the audio signal amplitude, take a bunch of measurements in a small time frame (e.g. 50 ms, the lowest frequency a human can hear). Find the minimum and maximum readings in this time frame and subtract the two to get the peak-to-peak amplitude. We can leave it at that, or divide the peak-to-peak amplitude by a factor of two to get the wave amplitude. We can use the ADC integer value, or convert this into voltage as described above.


Sample Code

Below is a simple example sketch to get you started with the MEMS microphone breakout board. You can find the code in the GitHub repo as well. The code, written for an Arduino microcontroller, includes a conversion equation from the ADC Reading to voltage, a function to find the audio signal peak-to-peak amplitude, and a simple VU Meter that outputs to the Arduino Serial Monitor.

Be sure to read the comments in the code to understand how it works and to adapt it to fit your needs.

 * Example Sketch for the SparkFun MEMS Microphone Breakout Board
 * Written by jenfoxbot <>
 * Code is open-source, beer/coffee-ware license.

// Connect the MEMS AUD output to the Arduino A0 pin
int mic = A0;

// Variables to find the peak-to-peak amplitude of AUD output
const int sampleTime = 50; 
int micOut;

//previous VU value
int preValue = 0; 

void setup() {

void loop() {
   int micOutput = findPTPAmp();

// Find the Peak-to-Peak Amplitude Function
int findPTPAmp(){
// Time variables to find the peak-to-peak amplitude
   unsigned long startTime= millis();  // Start of sample window
   unsigned int PTPAmp = 0; 

// Signal variables to find the peak-to-peak amplitude
   unsigned int maxAmp = 0;
   unsigned int minAmp = 1023;

// Find the max and min of the mic output within the 50 ms timeframe
   while(millis() - startTime < sampleTime) 
      micOut = analogRead(mic);
      if( micOut < 1023) //prevent erroneous readings
        if (micOut > maxAmp)
          maxAmp = micOut; //save only the max reading
        else if (micOut < minAmp)
          minAmp = micOut; //save only the min reading

  PTPAmp = maxAmp - minAmp; // (max amp) - (min amp) = peak-to-peak amplitude
  double micOut_Volts = (PTPAmp * 3.3) / 1024; // Convert ADC into voltage

  //Uncomment this line for help debugging (be sure to also comment out the VUMeter function)

  //Return the PTP amplitude to use in the soundLevel function. 
  // You can also return the micOut_Volts if you prefer to use the voltage level.
  return PTPAmp;   

// Volume Unit Meter function: map the PTP amplitude to a volume unit between 0 and 10.
int VUMeter(int micAmp){

  // Map the mic peak-to-peak amplitude to a volume unit between 0 and 10.
   // Amplitude is used instead of voltage to give a larger (and more accurate) range for the map function.
   // This is just one way to do this -- test out different approaches!
  int fill = map(micAmp, 23, 750, 0, 10); 

  // Only print the volume unit value if it changes from previous value
  while(fill != preValue)
    preValue = fill;

Resources and Going Further

If you run into trouble getting, or understanding, an audio signal output from the MEMS mic breakout board, try using a multimeter and/or an oscilloscope to measure the voltage output of the signal in quiet and loud settings. If you're still stuck, leave a comment, and we'll help you troubleshoot.

After you've read in the MEMS microphone and have a good handle on the signal output, you're ready to start using it for practical microphone applications! Here are a few ideas to get you started:

  1. Build a music visualizer! Here's a sample sketch for the music visualizer shown in the SparkFun Simple Sketches example.
  2. Record sounds and play them back! You'll also need a speaker, an amplifier transistor, and some pushbuttons (and some code.. here's an open-source mbed example).
  3. Make a sound-reactive EL Wire costume and replace the Sound Detector with the MEMS Microphone!
  4. Check out these other audio related tutorials below.

MiniGen Hookup Guide

Using the MiniGen, SparkFun's Arduino Pro Mini signal generator shield

Experiment Guide for RedBot with Shadow Chassis

This Experiment Guide offers nine experiments to get you started with the SparkFun RedBot. This guide is designed for those who are familiar with our SparkFun Inventor's Kit and want to take their robotics knowledge to the next level.

Build a Qwiic Jukebox that is Toddler Approved!

Follow this tutorial to build your own custom jukebox. Note, this is designed simple and tough for use primarily with toddlers. It's also a great introduction to SparkFun's Qwiic products!

MicroMod Artemis Processor Board Hookup Guide

Get started with the Artemis MicroMod Processor Board in this tutorial!

Happy building!