Proyectos con Arduino.

Blog de proyectos de Arduino de alumnos de la URJC

Monitor de Ruido para Aulas

por · 05/05/2026

Presentación del proyecto

Grupo: SEyTR_Mo Grupo 02.

Autores:

  • Enrique Padilla
  • Alexis Maestro
  • Sergio Muñoz
  • Alejandro Hernandez

1. Introducción y motivación

En muchas aulas donde se imparten clases de cualquier tipo, el ruido ambiental puede dificultar la concentración de los estudiantes. Cuando el nivel de ruido es elevado durante periodos prolongados, puede provocar fatiga auditiva o pérdida de atención, haciendo más complicado seguir o impartir la clase de forma adecuada. Por ello, hemos optado por desarrollar un proyecto en Arduino que nos permita monitorizar y controlar este problema.

La idea consiste en colocar un sensor de sonido en el aula, conectarlo a un microcontrolador y representar el nivel de ruido mediante luces de colores. Cuando el ambiente es tranquilo, se ilumina un LED verde, en niveles moderados se enciende un LED amarillo y ante ruido elevado se activa un LED rojo junto con un zumbador. Además, una pantalla LCD muestra en tiempo real un valor relativo del nivel de ruido, y esta información también puede enviarse por Bluetooth a un teléfono móvil para su visualización.

2. Materiales y componentes

Este proyecto esta construido mediante los siguientes componentes:

ComponenteFunción
Microcontrolador Arduino Uno/NanoProcesa las señales del sensor, controla los LEDs y la pantalla LCD y envía datos por Bluetooth
Sensor de sonido KY‑037/KY‑038Convierte las ondas de presión en señales eléctricas analógicas y digitales
Pantalla LCD 16×2 con módulo I2CMuestra el nivel de ruido en dB y mensajes de estado
Tres LEDs (verde, amarillo y rojo) + resistencias de 220 ΩIndican visualmente el estado del ruido (silencio, normal, alto)
Potenciómetro de 10 kΩAjusta el contraste de la LCD cuando se usa en modo paralelo
Zumbador pasivoEmite un pitido cuando el nivel de ruido es muy alto
Módulo Bluetooth HC‑05Envía los datos de dB a una aplicación móvil
Cables, protoboard y fuente de alimentaciónPermiten interconectar y alimentar los componentes

El coste total ha sido alrededor de los 45,84 €.

3. Diseño del circuito y simulación

Antes de construir la versión física, diseñamos el circuito en Tinkercad para comprobar la asignación de pines y el comportamiento del programa.

(La simulación de Tinkercad esta bastante limitada debido a que no permite emular dispositivos Bluetooth y para el ruido hemos tenido que usar un potenciómetro).

  • Estado «Todo en orden»
  • Estado «Aviso moderado»
  • Estado «¡ Alerta Roja !»

Según el nivel de ruido detectado, el sistema indicará un estado distinto (Verde, Amarillo o Rojo), representando niveles de ruido bajo, moderado o alto.

4. Funcionamiento del sistema

El sensor de sonido utiliza un micrófono electret, un amplificador y un comparador LM393 para convertir las ondas sonoras en señales eléctricas. En nuestro caso se trabaja con la salida analógica del sensor, conectada al pin A2 del Arduino, para obtener una medida relativa del nivel de ruido. Nuestro algoritmo realiza los siguientes pasos:

  1. Lectura del sensor: Se realizan 250 lecturas rápidas del sensor y se guardan el valor mínimo y máximo obtenidos. A partir de ellos se calcula la amplitud pico a pico mediante la diferencia máximo – mínimo, que sirve como medida relativa de la intensidad del sonido.
  2. Filtrado de la señal: Para evitar cambios bruscos o lecturas puntuales erróneas, el sistema guarda las últimas 5 mediciones en un historial y calcula una media móvil. Esta media permite estabilizar la lectura antes de decidir el estado del sistema.
  3. Evaluación por umbrales: Se establecen distintos umbrales para detectar ruido moderado o alto. El sistema combina dos criterios: el valor actual del sensor, para detectar picos rápidos, y la media móvil, para detectar ruido continuado. Según estos valores, el sistema puede estar en tres estados: verde, amarillo o rojo.
  4. Visualización en la LCD: La pantalla muestra en la primera línea el nivel relativo de ruido calculado y en la segunda línea el estado actual del sistema: “TODO EN ORDEN”, “AVISO MODERADO” o “!ALERTA ROJA!”.
  5. Alarma sonora: Cuando el sistema entra en estado amarillo o rojo, se activa un zumbador con distinta frecuencia. En estado amarillo se emite un aviso moderado y en estado rojo se emite una alerta más intensa. Además, se controla la duración del pitido para evitar que el propio buzzer afecte a la medición del sensor.
  6. Envío de datos por Bluetooth: Mediante el módulo HC-05, configurado a 9600 baudios, el sistema envía periódicamente al móvil el ruido máximo detectado, el estado actual (VERDE, AMARILLO o ROJO) y el modo de funcionamiento (AUTO o MANUAL).
  7. Modo manual: Desde la aplicación Bluetooth se pueden enviar comandos para forzar un estado concreto: V para verde, A para amarillo, R para rojo y M para volver al modo automático.

5. Desarrollo del código y calibración

El software está dividido en varias funciones auxiliares, además de las funciones principales setup() y loop(). En setup() se configuran los pines de salida, se inicializa la comunicación serie, el módulo Bluetooth HC-05 y la pantalla LCD I2C. La función loop() se ejecuta continuamente y se encarga de leer los comandos Bluetooth, gestionar el buzzer, medir el ruido del sensor, calcular una media móvil, actualizar la LCD, controlar los LEDs y enviar los datos al móvil. A continuación se muestra el código de la versión física del sistema, basado en lectura de amplitud pico a pico y detección por umbrales:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <SoftwareSerial.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);
SoftwareSerial bluetooth(4, 7);

const int pinBuzzer = 6;
const int pinVerde = 8;
const int pinAmarillo = 9;
const int pinRojo = 10;
const int pinSensor = A2;

const int UMBRAL_AMARILLO = 13;
const int UMBRAL_ROJO = 50;
const int UMBRAL_PICO_AMARILLO = 13;
const int UMBRAL_PICO_ROJO = 50;

int  estadoActual = 0;
bool modoManual = false;

int historial[5] = {0, 0, 0, 0, 0};
int indice = 0;

unsigned long ultimoEnvio = 0;
unsigned long ultimoEstadoRojo = 0;
int ruidoMaxEnvio = 0;
const int INTERVALO_ENVIO = 200;
const int DURACION_ROJO = 1000;

int estadoBuzzer = 0;
unsigned long inicioBuzzer = 0;
unsigned long finBuzzer = 0;
const int DURACION_PITIDO_AMARILLO = 2000;
const int DURACION_PITIDO_ROJO = 3000;
const int BLOQUEO_SENSOR = 500;

int leerSensor() {
  int minimo = 1023;
  int maximo = 0;
  for (int i = 0; i < 250; i++) {
    int lectura = analogRead(pinSensor);
    if (lectura > maximo) maximo = lectura;
    if (lectura < minimo) minimo = lectura;
    delayMicroseconds(300);
  }
  return maximo - minimo;
}

void apagarLeds() {
  digitalWrite(pinVerde,    LOW);
  digitalWrite(pinAmarillo, LOW);
  digitalWrite(pinRojo,     LOW);
}

void leerBluetooth() {
  while (bluetooth.available()) {
    char comando = bluetooth.read();

    if (comando == '\n' || comando == '\r' || comando == ' ') continue;

    if (comando == 'V' || comando == 'v') {
      modoManual = true; estadoActual = 0;
      bluetooth.println(">> Modo manual: VERDE");
    } else if (comando == 'A' || comando == 'a') {
      modoManual = true; estadoActual = 1;
      bluetooth.println(">> Modo manual: AMARILLO");
    } else if (comando == 'R' || comando == 'r') {
      modoManual = true; estadoActual = 2;
      bluetooth.println(">> Modo manual: ROJO");
    } else if (comando == 'M' || comando == 'm') {
      modoManual = false; estadoActual = 0;
      bluetooth.println(">> Modo automatico activado");
    }
  }
}

void gestionarBuzzer() {
  unsigned long ahora = millis();
  if (estadoBuzzer == 1) {
    int duracion = (estadoActual == 2) ? DURACION_PITIDO_ROJO : DURACION_PITIDO_AMARILLO;
    if (ahora - inicioBuzzer > duracion) {
      noTone(pinBuzzer);
      finBuzzer    = ahora;
      estadoBuzzer = 2;
    }
  } else if (estadoBuzzer == 2) {
    if (ahora - finBuzzer > BLOQUEO_SENSOR) {
      estadoBuzzer = 0;
    }
  }
}

void activarBuzzer(int frecuencia) {
  if (estadoBuzzer == 0) {
    tone(pinBuzzer, frecuencia);
    inicioBuzzer = millis();
    estadoBuzzer = 1;
  }
}

void setup() {
  pinMode(pinVerde, OUTPUT);
  pinMode(pinAmarillo, OUTPUT);
  pinMode(pinRojo, OUTPUT);
  pinMode(pinBuzzer, OUTPUT);

  Serial.begin(9600);
  bluetooth.begin(9600);

  Wire.begin();
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.print("SISTEMA ESTABLE");
  delay(1000);
}

void loop() {
  leerBluetooth();
  gestionarBuzzer();

  int ruido = (estadoBuzzer == 2) ? 0 : leerSensor();

  historial[indice] = ruido;
  indice = (indice + 1) % 5;
  int media = 0;
  for (int i = 0; i < 5; i++) media += historial[i];
  media = media / 5;

  Serial.print("Sensor: ");
  Serial.print(ruido);
  Serial.print(" | Media: ");
  Serial.println(media);

  if (!modoManual) {
    bool picoRojo = ruido > UMBRAL_PICO_ROJO;
    bool picoAmarillo = ruido > UMBRAL_PICO_AMARILLO;
    bool mediaRoja = media > UMBRAL_ROJO;
    bool mediaAmarilla = media > UMBRAL_AMARILLO;

    if (mediaRoja || picoRojo) {
      estadoActual     = 2;
      ultimoEstadoRojo = millis();

    } else if ((mediaAmarilla || picoAmarillo) && estadoActual != 2) {
      estadoActual = 1;

    } else if (media < 10) {
      if (estadoActual == 2 && millis() - ultimoEstadoRojo > DURACION_ROJO) {
        estadoActual = 0;
      } else if (estadoActual != 2) {
        estadoActual = 0;
      }
    }
  }

  if (ruido > ruidoMaxEnvio) ruidoMaxEnvio = ruido;
  if (millis() - ultimoEnvio > INTERVALO_ENVIO) {
    ultimoEnvio = millis();
    String modo   = modoManual ? "MANUAL" : "AUTO";
    String estado = estadoActual == 0 ? "VERDE" : estadoActual == 1 ? "AMARILLO" : "ROJO";
    bluetooth.print("Ruido: ");
    bluetooth.print(ruidoMaxEnvio);
    bluetooth.print(" | ");
    bluetooth.print(estado);
    bluetooth.print(" | ");
    bluetooth.println(modo);
    ruidoMaxEnvio = 0;
  }

  lcd.setCursor(0, 0);
  lcd.print(" Nivel:");
  lcd.print(media);
  lcd.print("   ");

  apagarLeds();

  if (estadoActual == 2) {
    digitalWrite(pinRojo, HIGH);
    lcd.setCursor(0, 1);
    lcd.print("!ALERTA ROJA!  ");
    activarBuzzer(2000);

  } else if (estadoActual == 1) {
    digitalWrite(pinAmarillo, HIGH);
    lcd.setCursor(0, 1);
    lcd.print("AVISO MODERADO ");
    activarBuzzer(500);

  } else {
    digitalWrite(pinVerde, HIGH);
    noTone(pinBuzzer);
    estadoBuzzer = 0;
    lcd.setCursor(0, 1);
    lcd.print("TODO EN ORDEN ");
  }

  delay(20);
}

6. Problemas encontrados y soluciones

El problema: un sensor poco sensible

El principal inconveniente del sensor es que incorpora un micrófono de pequeño tamaño, lo que limita bastante su capacidad para recoger sonido a distancia. Esto provocaba que:

  • Las mediciones fueran prácticamente constantes
  • No hubiera cambios significativos entre silencio y ruido moderado
  • El sistema no reaccionara correctamente ante situaciones reales del aula

La solución: un cono acústico

Para solucionar este problema decidimos no complicar el sistema a nivel electrónico y optamos por una solución mucho más sencilla pero efectiva: añadir un cono acústico al sensor.

Este cono actúa como un concentrador de ondas sonoras, funcionando de forma similar a un embudo. Su objetivo es recoger el sonido del entorno y dirigirlo directamente hacia el micrófono del sensor.

7. Resultados y pruebas

Tras montar el circuito y calibrar el sensor, probamos el sistema en entornos reales. En condiciones de ambiente tranquilo, el LED verde permanecía encendido y la LCD mostraba valores bajos. Durante conversaciones normales, el sistema pasaba a estado amarillo y los valores aumentaban de forma progresiva. Ante ruidos intensos, como un aplauso, se activaba el estado rojo y el zumbador emitía una señal acústica. Estos resultados confirman que el monitor permite percibir de manera inmediata el nivel de ruido de forma relativa y adaptada al entorno.

Además estos niveles leídos también son enviados a la aplicación de móvil Serial Bluetooth Terminal mediante el módulo de Bluetooth incorporado.

8. Conclusión

Gracias a este proyecto hemos podido comprobar que con componentes relativamente baratos y conocimientos básicos de electrónica y programación se pueden crean proyectos y dispositivos muy completos y funcionales, en este caso para la concentración en aulas, además al usarse Arduino se puede conectar de forma sencilla a otros dispositivos e incluso aplicaciones mediante protocolos como Bluetooth o Wifi (Aunque este proyecto no contempla la posibilidad de Hardware para la conectividad mediante Wifi).

En una revisión futura es posible sustituir el sensor por un modulo con amplificador de bajo ruido que tenga una mejor sensibilidad como un MAX4466 o un MAX9814, además se podría cambiar el módulo de Arduino y Bluetooth por un ESP32 que permitiría tener Wifi integrado e incluso mandar datos a través de internet, incluso programar una aplicación móvil mas especifica. En un punto mas estético, se podría usar una impresora 3D para realizar un carcasa mas profesional.

Vídeo: PULSA AQUI

También te podría gustar...

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *