Published March 25, 2026 © GPL3+

Making an accurate handheld dB meter

A small handheld and very accurate sound meter to measure SNR or noise ambiance, the DB meter.

BeginnerFull instructions provided1 hour346

Story

Because I am a sound lover, and in recent times I have done a lot of research on audio-related products. But I am always curious to measure the sound performance in terms of dB(A). In that way, when the amplifier is in steady state, I can measure the total output noise due to the surroundings. Because decibels are a logarithmic scale, it usually starts from a very light value, and it can also measure very high values. I have many options, as someone on the internet says, there are phone apps that claim to measure sound levels, but let's be honest, a phone microphone is designed for voice calls, not calibrated acoustic measurement.

So if you want to measure actual sound output, there are professional sound level meters, but they start at a couple of hundred dollars. But I wanted something in between a handheld dB meter that's actually accurate and battery-friendly. When I was searching the web, I came across the DFRobot Gravity Analog Sound Level Meter (SEN0232). This little board has a professional-grade MEMS microphone with proper signal conditioning. It has an A-weighting filter and a beautifully simple analog output. The voltage coming out is linearly proportional to decibels. So, no complex DSP, no FFT, just read an analog pin and multiply. I paired it with my own designed Arduino from JLCPCB and a 0.96" OLED display, and that’s how I got myself a proper handheld dB meter.

What is a Sound Level Meter?

Before jumping into the process of building the meter first let’s what actually is dBA and dB. Human ears can hear sounds between 1kHz and 5kHz, and are less sensitive to the other ranges. A-weighting is a frequency response curve that adjusts the measurement to match human perception. Here is the representation over frequency you can see the plots:

When you see dBA, that's a decibel reading with A-weighting applied. This is important because the SEN0232 uses A-weighting, which means the readings represent how loud something sounds to you, not just the raw acoustic energy. That's exactly what you want for a practical sound level meter. Here is the dBA reference scale:

DFRobot Gravity Analog Sound Level Meter:

The SEN0232 is not just a microphone breakout board, but it's a complete sound level measurement module with an onboard signal conditioning circuit.

Key Specifications:

Measurement Range: 30 dBA to 130 dBA
Measurement Error: ±1.5 dB
Frequency Weighting: A-Weighted
Frequency Response: 31.5 Hz to 8.5 kHz
Time Characteristic: 125 ms (Fast mode)
Input Voltage: 3.3V to 5.0V
Input Current: 22 mA @ 3.3V / 14 mA @ 5.0V
Output Voltage: 0.6V to 2.6V (Analog)

The board comes with a sensitivity MEMS microphone for capturing sound pressure waves, then followed by an A-Weighting Filter that shapes the frequency response to match human hearing. Some signal conditioning and rectification circuitry that converts the AC audio signal into a stable DC voltage. And finally, the output voltage has a direct linear relationship to the decibel value.

Components Required:

DFRobot SEN0232 Sound Level Meter
Arduino Nano
Adafruit SSD1306 0.96" OLED Display
Breadboard
Jumper Wires
USB Cable

Circuit Connections:

The wiring is dead simple; that's the beauty of the Gravity interface of this sensor. Just power the sensor with a 5V supply from the Arduino and plug the output wire into the A0 pin of the Arduino. For the OLED connection:

VCC - 5V
GND - GND
SDA - A4
SCL - A5

I am using the board that I have designed on my own; you can see all the details from here. It is an Arduino-compatible board with the same specs, but with some hardware modifications. I got mine from JLCPCB. You can explore and try making one yourself; files attached.

Arduino Code:

Here's the complete Arduino sketch that reads the sound level and displays it on the OLED with a visual bar graph.

Install these from the Arduino Library Manager:

1. Adafruit SSD1306 - For the OLED display
2. Adafruit GFX Library - Graphics primitives (installed automatically with SSD1306)
Go to Sketch > Include Library > Manage Libraries, search for Adafruit SSD1306, and install it. The GFX library will be installed as a dependency.

Download the main code from this link.

Upload this first and open the Serial Monitor at 115200 baud. You should see readings between 30 and 130 dBA, depending on your environment. A quiet room should read around 35-45 dBA.

How the Code Works:

Because the sensitivity and conversions are based on ADC and they work on a reference. If that reference voltage is stable the readings are accurate. Arduino's 5V rail can vary from 4.6V to 5.2V depending on the host. And when running on battery, over the time as the battery discharges there will be variations. To eliminate this issue, we used the `readVcc() function which takes the reference from the internal 1.1V bandgap of Arduino. This gives us the true supply voltage in millivolts, which we use in the dB calculation.

Raw sensor readings can be noisy. The code uses a circular buffer of 10 samples to compute a running average. This smooths out spikes while still responding quickly to changes (10 samples x 125ms = 1.25 seconds of averaging). This is the widely used noise cancellation technique used in ADCs.

Here is how the ADC conversion is done:

A perfectly linear 0.6V-to-2.6V range mapping to 30-130 dBA. No lookup tables, no polynomial curve fitting, no complex calibration. Just multiply by 50. That's it. 0.6V = 30 dBA, 2.6V = 130 dBA.

dbValue = (analogRead(A0) / 1024.0) * Vref * 50.0;
Sensitivity = 100 dB / 2.0V = 50 dB/V

Testing and Working:

I have tested the output in different scenarios, and it is working perfectly. Best to pair it directly with the Arduino with a soldering connection; a loose one may give you noise. The readings were stable and consistent. The running average smooths out transient spikes nicely, and the OLED display updates smoothly without flickering.

Testing with Songs:

Testing during conversation:

Conclusion:

With this standalone handheld unit, we can now make instant readings, which means just power on and read, no booting or launching software. An OLED display gives you a clear, real-time reading. Now, at least I have added one more measurement unit in my lab. I can assure you that this is the one if you are looking for a low-cost but accurate dBA measurement unit. There are a lot of other applications where this board can be used. I will come with some other applications in the future. Until then, the comment section is free for you.

dBA oled code

/*
 * Ultra-Stable Handheld dBA Meter
 * DFRobot SEN0232 + Arduino + SSD1306 OLED
 *
 * Features:
 * - Real-time dBA reading with large font
 * - Visual bar graph
 * - Min/Max tracking with reset
 * - Running average for ultra-stable readings
 * - Dynamic Vcc compensation (battery safe)
 * - Sound level descriptor
 *
 * Wiring:
 *   SEN0232 A (Green)  -> A0
 *   SEN0232 + (Red)    -> 5V
 *   SEN0232 - (Black)  -> GND
 *   OLED SDA           -> A4
 *   OLED SCL           -> A5
 *   OLED VCC           -> 5V
 *   OLED GND           -> GND
 *
 * Author: Sagar Saini
 * License: MIT
 */

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// ---- Display Configuration ----
#define SCREEN_WIDTH   128
#define SCREEN_HEIGHT  64
#define OLED_RESET     -1
#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// ---- Sensor Configuration ----
#define SENSOR_PIN A0
#define SENSITIVITY 50.0   // dBA per Volt (sensor characteristic)

// ---- Averaging Configuration ----
#define NUM_SAMPLES    10   // Circular buffer size
#define SAMPLE_DELAY   125  // ms (matches sensor's 125ms response time)

// ---- Variables ----
float samples[NUM_SAMPLES];
int sampleIndex = 0;
bool bufferFull = false;
float minDb = 999.0;
float maxDb = 0.0;
unsigned long lastSampleTime = 0;

// =============================================
// Accurate Vcc Reading (essential for battery)
// Reads internal 1.1V bandgap against AVcc
// Returns actual Vcc in millivolts
// =============================================
long readVcc() {
  #if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
    ADMUX = _BV(REFS0) | _BV(MUX4) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #elif defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
    ADMUX = _BV(MUX5) | _BV(MUX0);
  #elif defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
    ADMUX = _BV(MUX3) | _BV(MUX2);
  #else
    // ATmega328P (Arduino Uno/Nano)
    ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  #endif

  delay(2);
  ADCSRA |= _BV(ADSC);
  while (bit_is_set(ADCSRA, ADSC));

  uint8_t low  = ADCL;
  uint8_t high = ADCH;
  long result = (high << 8) | low;

  // 1.1V * 1023 * 1000 = 1125300
  result = 1125300L / result;
  return result;  // Vcc in millivolts
}

// =============================================
// Read Sound Level with Averaging
// =============================================
float readSoundLevel() {
  float refVolt = float(readVcc()) / 1000.0;
  float voltage = (analogRead(SENSOR_PIN) / 1024.0) * refVolt;
  float db = voltage * SENSITIVITY;

  // Clamp to sensor's valid range
  db = constrain(db, 30.0, 130.0);

  // Store in circular buffer
  samples[sampleIndex] = db;
  sampleIndex = (sampleIndex + 1) % NUM_SAMPLES;
  if (sampleIndex == 0) bufferFull = true;

  // Compute running average
  float sum = 0;
  int count = bufferFull ? NUM_SAMPLES : sampleIndex;
  for (int i = 0; i < count; i++) {
    sum += samples[i];
  }
  return sum / (float)count;
}

// =============================================
// Sound Level Descriptor
// =============================================
const char* getLevelDescription(float db) {
  if (db < 40)  return "Quiet";
  if (db < 55)  return "Moderate";
  if (db < 70)  return "Loud";
  if (db < 85)  return "Very Loud";
  if (db < 100) return "Dangerous";
  return "EXTREME!";
}

// =============================================
// Draw Visual Bar Graph
// =============================================
void drawBarGraph(float db) {
  int barWidth = map(constrain((int)db, 30, 130), 30, 130, 0, 120);

  // Outline
  display.drawRect(3, 42, 122, 10, SSD1306_WHITE);

  // Filled portion
  if (barWidth > 0) {
    display.fillRect(4, 43, barWidth, 8, SSD1306_WHITE);
  }

  // Scale labels
  display.setTextSize(1);
  display.setCursor(0, 54);
  display.print(F("30"));
  display.setCursor(55, 54);
  display.print(F("80"));
  display.setCursor(108, 54);
  display.print(F("130"));
}

// =============================================
// Update OLED Display
// =============================================
void updateDisplay(float db) {
  display.clearDisplay();

  // ---- Header Row ----
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(10, 3);
  display.print(F("dBA METER"));

  // Level descriptor (right-aligned)
  const char* desc = getLevelDescription(db);
  int descWidth = strlen(desc) * 6;
 // display.setCursor(SCREEN_WIDTH - descWidth, 0);
 // display.print(desc);

  // Separator
  display.drawLine(0, 10, 127, 10, SSD1306_WHITE);

  // ---- Main Reading (Large) ----
  display.setTextSize(2);
  display.setCursor(40, 23);
  if (db < 100.0) {
    display.print(db, 1);
  } else {
    display.print(db, 0);
  }

  // Unit
  display.setTextSize(1);

  // Min/Max (small, below main reading)
  display.setCursor(100, 23);
  display.print(F("H:"));
  display.print((int)maxDb);
  display.setCursor(100, 32);
  display.print(F("L:"));
  display.print((int)minDb);

  // ---- Bar Graph ----
  drawBarGraph(db);

  display.display();
}

// =============================================
// Setup
// =============================================
void setup() {
  Serial.begin(115200);

  // Initialize OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 OLED not found!"));
    for (;;);
  }

  // Splash screen
  display.clearDisplay();
  display.setTextSize(2);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(45, 3);
  display.println(F("dBA"));
  display.setCursor(35, 25);
  display.println(F("METER"));
  display.setTextSize(1);
  display.setCursor(20, 50);
  display.print(F("SEN0232 + SSD1306"));
  display.display();
  delay(2000);

  // Initialize buffer
  for (int i = 0; i < NUM_SAMPLES; i++) {
    samples[i] = 0;
  }

  // Serial header
  Serial.println(F("========================="));
  Serial.println(F(" Handheld dBA Meter"));
  Serial.println(F(" SEN0232 + SSD1306 OLED"));
  Serial.println(F("========================="));
  Serial.println();
  Serial.println(F("dBA\tMin\tMax\tVcc(mV)\tLevel"));
  Serial.println(F("---\t---\t---\t-------\t-----"));
}

// =============================================
// Main Loop
// =============================================
void loop() {
  unsigned long now = millis();

  if (now - lastSampleTime >= SAMPLE_DELAY) {
    lastSampleTime = now;

    float db = readSoundLevel();

    // Track min/max (ignore startup readings)
    if (bufferFull || sampleIndex > 3) {
      if (db > maxDb) maxDb = db;
      if (db < minDb) minDb = db;
    }

    // Update OLED
    updateDisplay(db);

    // Serial output
    Serial.print(db, 1);
    Serial.print(F("\t"));
    Serial.print(minDb, 1);
    Serial.print(F("\t"));
    Serial.print(maxDb, 1);
    Serial.print(F("\t"));
    Serial.print(readVcc());
    Serial.print(F("\t"));
    Serial.println(getLevelDescription(db));
  }
}

Credits

Electro BOY

58 projects • 68 followers

Electronics is my passion. I am not professional, Always learning something new. I am good at soldering, designing pcb, Arduino programing.

Embed the widget on your own site

Making an accurate handheld dB meter

Making an accurate handheld dB meter

Story

What is a Sound Level Meter?

DFRobot Gravity Analog Sound Level Meter:

Components Required:

Circuit Connections:

Arduino Code:

How the Code Works:

Testing and Working:

Conclusion:

Code

dBA oled code

Credits

Electro BOY

Comments

Related channels and tags