ACTIVITE ARDUINO : Détecteur de bruit autonome avec Arduino Nano 33 IoT

Objectif

Réaliser un détecteur de bruit autonome permettant de signaler qu’un niveau sonore trop important est maintenu pendant une certaine durée, en utilisant une carte Arduino Nano 33 IoT alimentée par une batterie.

Le dispositif est destiné notamment à une utilisation en salle de classe (demande d’un professeur de CPE pour des séances de Travaux Dirigés en petits groupes). L’objectif n’est pas de mesurer précisément un niveau sonore en décibels, mais de disposer d’un indicateur simple permettant de signaler un niveau sonore dépassant un seuil réglable.

Le fonctionnement retenu est le suivant :

• lorsque le niveau sonore dépasse le seuil réglé sur le capteur, une première alerte est donnée par une LED rouge clignotante ;
• si cette situation se maintient pendant environ 2 secondes, un buzzer est déclenché pendant 1 seconde ;
• après le signal sonore, le système reste silencieux pendant 5 secondes ;
• si le niveau sonore reste trop important, un nouveau signal sonore est déclenché ;
• lorsque le niveau sonore redevient normal, le système revient à son état initial.

Le seuil de déclenchement est réglable directement à l’aide du potentiomètre présent sur le module GT1146.

Matériel nécessaire

1. Une carte Arduino Nano 33 IoT

2. Un capteur de son GT1146

3. Une LED rouge

4. Un buzzer

5. Une batterie LiPo

6. Un interrupteur

Schéma du montage

Le montage utilise les connexions suivantes :

Téléversement du code Arduino sur la carte Nano 33 IoT

1. Installation de la carte Arduino Nano 33

2. Code Arduino

Le programme téléversé dans l’Arduino est le suivant :

// ============================================================
// Arduino Nano 33 IoT + GT1146
//
// GT1146 D0 -> D4
// LED rouge -> D2 + résistance
// Buzzer -> D3
//
// PRINCIPE
// ------------------------------------------------------------
// D0 HIGH permanent       -> détection
// D0 HIGH/LOW alterné     -> détection
// D0 LOW permanent        -> calme
//
// FONCTIONNEMENT
// ------------------------------------------------------------
// 1. Détection pendant 2 s
// 2. LED rouge clignote pendant cette période
// 3. Puis buzzer pendant 1 s
// 4. Silence pendant 5 s
// 5. Nouveau bip si la détection continue
// 6. Retour au calme -> remise à zéro
// ============================================================


// ------------------------------------------------------------
// BROCHES
// ------------------------------------------------------------

const int GT1146= 4;
const int LED    = 2;
const int BUZZER = 3;


// ------------------------------------------------------------
// REGLAGES
// ------------------------------------------------------------

const unsigned long TEMPS_AVANT_BIP = 2000;  // 2 secondes
const unsigned long DUREE_BIP       = 1000;  // 1 seconde
const unsigned long TEMPS_SILENCE   = 5000;  // 5 secondes

const unsigned long PERIODE_LED     = 500;  // clignotement


// ------------------------------------------------------------
// VARIABLES
// ------------------------------------------------------------

bool detection = false;
bool buzzerEnCours = false;

unsigned long debutDetection = 0;
unsigned long debutBuzzer = 0;
unsigned long prochainBip = 0;

unsigned long dernierChangement = 0;

bool etatLED = false;
unsigned long dernierClignotement = 0;


// ============================================================
// SETUP
// ============================================================

void setup() {

  pinMode(GT1146, INPUT);
  pinMode(LED, OUTPUT);
  pinMode(BUZZER, OUTPUT);

  digitalWrite(LED, LOW);
  digitalWrite(BUZZER, LOW);

  Serial.begin(9600);

  delay(500);

  Serial.println();
  Serial.println("==============================");
  Serial.println(" DETECTEUR DE BRUIT - V8");
  Serial.println("==============================");
}


// ============================================================
// LOOP
// ============================================================

void loop() {

  unsigned long maintenant = millis();

  int etat = digitalRead(GT1146);


  // ==========================================================
  // 1. AFFICHAGE DU SIGNAL
  // ==========================================================

  Serial.println(etat == HIGH ? "D0 = HIGH" : "D0 = LOW");


  // ==========================================================
  // 2. DETECTION
  // ==========================================================

  // HIGH = signal de détection
  //
  // Peu importe que HIGH soit permanent ou qu'il alterne
  // avec LOW : dès qu'on observe HIGH, on considère qu'il
  // y a une activité sonore.

  if (etat == HIGH) {

    dernierChangement = maintenant;

    // Première détection
    if (!detection) {

      detection = true;
      debutDetection = maintenant;

      Serial.println(">>> DEBUT DETECTION");
    }
  }


  // ==========================================================
  // 3. RETOUR AU CALME
  // ==========================================================

  // Si D0 reste LOW pendant 1 seconde,
  // on considère que le bruit est terminé.

  if (detection &&
      etat == LOW &&
      maintenant - dernierChangement >= 1000) {

    detection = false;

    buzzerEnCours = false;

    debutDetection = 0;
    prochainBip = 0;

    digitalWrite(BUZZER, LOW);

    etatLED = false;
    digitalWrite(LED, LOW);

    Serial.println(">>> RETOUR AU CALME");
  }


  // ==========================================================
  // 4. PREMIERE ALERTE : LED
  // ==========================================================

  if (detection) {

    // La LED clignote immédiatement dès la détection

    if (maintenant - dernierClignotement >= PERIODE_LED) {

      dernierClignotement = maintenant;

      etatLED = !etatLED;

      digitalWrite(LED, etatLED);
    }
  }


  // ==========================================================
  // 5. DECLENCHEMENT DU BUZZER
  // ==========================================================

  // Le buzzer n'arrive qu'après 2 secondes de détection.

  if (detection &&
      !buzzerEnCours &&
      maintenant - debutDetection >= TEMPS_AVANT_BIP &&
      maintenant >= prochainBip) {

    buzzerEnCours = true;

    debutBuzzer = maintenant;

    digitalWrite(BUZZER, HIGH);

    Serial.println(">>> BIP !");
  }


  // ==========================================================
  // 6. FIN DU BIP
  // ==========================================================

  if (buzzerEnCours &&
      maintenant - debutBuzzer >= DUREE_BIP) {

    digitalWrite(BUZZER, LOW);

    buzzerEnCours = false;

    prochainBip = maintenant + TEMPS_SILENCE;

    Serial.println(">>> FIN BIP - silence 5 s");
  }


  delay(50);
}

3. Téléversement du programme

Une fois le code copié dans l’IDE Arduino :

1. Brancher la carte Arduino Nano 33 IoT à l’ordinateur avec un câble USB.
2. Dans Outils → Type de carte, vérifier que Arduino Nano 33 IoT est sélectionnée.
3. Dans Outils → Port, sélectionner le port correspondant à la carte.
4. Cliquer sur le bouton Téléverser.

Le programme est alors compilé puis envoyé dans la mémoire de l’Arduino.

Une fois le téléversement terminé, la carte peut fonctionner de manière autonome.

Remarque : le câble USB peut être conservé pour effectuer les essais et observer le fonctionnement du programme. Pour une utilisation autonome, il peut ensuite être retiré et l’Arduino alimenté par la batterie.

Réglage du seuil de détection

Le seuil de déclenchement est réglé directement avec le petit potentiomètre présent sur le module GT1146.

Le réglage doit être effectué progressivement à l’aide d’un petit tournevis.

Lorsque le niveau sonore atteint le seuil, la petite LED du module GT1146 s’allume et la sortie D0 commence à changer d’état.

Le moniteur série de l’IDE Arduino permet également d’observer le signal reçu par la carte :

D0 = HIGH
D0 = HIGH
D0 = LOW
D0 = LOW
D0 = HIGH
D0 = HIGH
D0 = LOW
...

Lorsque le niveau sonore est inférieur au seuil, D0 reste généralement dans un état stable.

Le programme utilise cette information pour déterminer qu’un niveau sonore important est présent.

Fonctionnement du dispositif

Le fonctionnement peut être résumé par la chronologie suivante :

Niveau sonore normal
        │
        ▼
   aucune alerte
        │
        │ niveau sonore trop important
        ▼
  LED rouge clignote
        │
        │ pendant 2 secondes
        ▼
    BUZZER 1 seconde
        │
        ▼
   silence 5 secondes
        │
        ├── bruit toujours présent ──► nouveau bip
        │
        └── retour au calme ─────────► remise à zéro

L’intérêt de cette temporisation est d’éviter qu’un bruit ponctuel déclenche immédiatement une alerte sonore. Le système est ainsi davantage adapté à la surveillance du niveau sonore ambiant d’une salle qu’à la détection d’un bruit bref.

Boîtier imprimé en 3D

L’ensemble des composants peut être intégré dans un boîtier imprimé en 3D.

Le boîtier devra notamment prévoir :

• une ouverture pour le capteur GT1146 afin que celui-ci puisse recevoir correctement les sons ;
• une ouverture ou une grille devant le buzzer (Attention : le buzzer ne doit pas être « coincé » dans l’ouverture car cela l’empêcherait de vibrer correctement);
• une fenêtre permettant de voir la LED d’alerte ;
• un accès au potentiomètre du GT1146 pour permettre le réglage du seuil ;
• un emplacement pour la batterie ;
• un interrupteur général permettant de mettre facilement le dispositif sous tension.

Le boîtier peut être réalisé avec une imprimante 3D et adapté aux dimensions des différents composants utilisés.

Bilan

Ce montage permet de réaliser avec un matériel relativement simple un détecteur de bruit autonome et réglable, pouvant être utilisé notamment dans le cadre d’expérimentations ou de projets pédagogiques.

Le dispositif ne constitue pas un sonomètre : il ne fournit pas une mesure en décibels. Il fonctionne comme un détecteur de dépassement d’un seuil sonore, le seuil étant réglé directement sur le capteur.

Cette approche présente l’avantage d’être simple à mettre en œuvre et particulièrement adaptée à une utilisation où l’on cherche davantage à signaler un niveau sonore excessif qu’à effectuer une mesure acoustique précise.