KY-037 Capteur sonore

// Déclaration et initialisation des broches d'entrées
int Analog_Eingang = A0; // Entrée analogique
int Digital_Eingang = 3; // Entrée digitale
  
void setup ()
{
  pinMode (Analog_Eingang, INPUT);
  pinMode (Digital_Eingang, INPUT);
       
  Serial.begin (9600); // Sortie série à 9600 bauds
}
  
// Le programme lit les valeurs des broches d'entrée et les envoie à la sortie série
void loop ()
{
  float Analog;
  int Digital;
    
  //Les valeurs sont lues, sont converties en tension...
  Analog = analogRead (Analog_Eingang) * (5.0 / 1023.0); 
  Digital = digitalRead (Digital_Eingang);
    
  //... et envoyées à la sortie série.
  Serial.print ("Tension analogique:"); Serial.print (Analog, 4);  Serial.print ("V, ");
  Serial.print ("Limite:");
  
  if(Digital==1)
  {
      Serial.println (" atteinte");
  }
  else
  {
      Serial.println (" pas encore atteinte");
  }
  Serial.println ("----------------------------------------------------------------");
  delay (200);
}

Ce capteur émet un signal si le microphone frontal du capteur détecte un bruit. La sensibilité du capteur peut être réglée à l'aide d'un potentiomètre.

Note sur l'utilisation

Ce capteur est parfaitement adapté à la mesure de seuils. Cela signifie que le capteur émet un signal numérique élevé dès qu'une valeur seuil définie par l'utilisateur est dépassée. Cependant, cela signifie également que les valeurs mesurées analogiques ne sont pas adaptées aux conversions, car le signal analogique est également influencé par le potentiomètre rotatif.

Sortie numérique: Le potentiomètre permet de régler une valeur seuil du son reçu à laquelle la sortie numérique doit basculer.

Sortie analogique: signal direct du microphone sous forme de niveau de tension.

LED1: Indique que le capteur est alimenté en tension.

LED2: Indique qu'un son a été détecté

Fonctionnalité du capteur

Ce capteur possède trois composants fonctionnels sur sa carte de circuit imprimé. La première est l'unité de détection située à l'avant du module, qui mesure physiquement l'environnement actuel et le transmet sous forme de signal analogique à la deuxième unité, l'amplificateur. Celui-ci amplifie le signal en fonction de la résistance réglée sur le potentiomètre rotatif et l'envoie à la sortie analogique du module.

**Le signal est inversé ; si une valeur élevée est mesurée, cela se traduit par une valeur de tension plus faible à la sortie analogique.

La troisième unité est un comparateur, qui commute la sortie numérique et la LED lorsque le signal tombe en dessous d'une certaine valeur. Au moyen du potentiomètre rotatif, la sensibilité peut être réglée comme indiqué sur la figure suivante :

Ce capteur ne donne pas de valeurs absolues (par exemple, la température exactement mesurée en °C ou l'intensité du champ magnétique en mT), mais il s'agit d'une mesure relative : une valeur limite est définie par rapport à la situation environnementale normale donnée et un signal est donné qui peut être traité ultérieurement si cette valeur limite est dépassée ou si une autre condition que le cas normal s'est produite.

Ce comportement est idéal pour la surveillance de la température (KY-028), les capteurs de proximité (KY-024, KY-025, KY-036), des moniteurs d'alarme (KY-037, KY-038) ou des codeurs (KY-026).

Affectation des broches

Exemple de code Raspberry Pi

Affectation des broches Raspberry Pi

Raspberry Pi	Capteur
GPIO 24 [Pin 18]	Signal numérique
3,3 V [Pin 1]	+V
GND [Pin 6]	GND
-	Signal analogique

Capteur	KY-053
Signal analogique	A0
Signal numérique	-
+V	-
GND	-

Raspberry Pi	KY-053
GPIO 3 [Pin 5]	SCL
GPIO 2 [Pin 3]	SDA
3,3 V [Pin 1]	VDD
GND [Pin 6]	GND

Capteur analogique, il faut donc respecter les points suivants.

Contrairement à l'Arduino, le Raspberry Pi n'a pas d'entrées analogiques ou il n'y a pas d'ADC (convertisseur analogique numérique) intégré dans la puce du Raspberry Pi. Cela limite le Raspberry Pi, si vous voulez utiliser des capteurs, où les valeurs de sortie ne sont pas numériques [valeur de tension dépassée -> valeur numérique ON | valeur de tension sous-cotée -> valeur numérique OFF | exemple : bouton enfoncé [ON] bouton relâché [OFF]], mais il doit s'agir d'une valeur variable continue (exemple : potentiomètre -> autre position = autre valeur de tension).

Pour éviter ce problème, notre kit de capteur X40 a le KY-053, un module avec ADC précis de 16 bits, que vous pouvez utiliser sur le Raspberry pour l'étendre avec 4 entrées analogiques. Il est connecté au Raspberry Pi via I2C, prend en charge la mesure analogique et transmet la valeur numérique au Raspberry Pi.

Ainsi, nous recommandons de connecter le module KY-053 avec ledit ADC entre les capteurs analogiques de cet ensemble. Pour plus d'informations, veuillez consulter la page d'information sur le convertisseur analogique-numérique KY-053.

Le programme utilise les bibliothèques Python ADS1x15 et I2C correspondantes d'Adafruit pour piloter l'ADC ADS1115. Ceux-ci ont été publiés au lien suivant https://github.com/adafruit/Adafruit_CircuitPython_ADS1x15 sous la licence MIT. Les bibliothèques requises ne sont pas incluses dans le paquet de téléchargement ci-dessous.

Le programme lit les valeurs actuelles des broches d'entrée et les affiche dans la console sous forme de valeur en [mV].

Veuillez noter que vous devez activer I2C sur votre Raspberry Pi avant d'utiliser cet exemple.

#!/usr/bin/python
# coding=utf-8
# Ce code utilise les librairies Python ADS1115 et I2C pour la Raspberry Pi
# Ces librairies sont publiées sous licence BSD sur le lien ci-dessous
# [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code]
from Adafruit_ADS1x15 import ADS1x15
from time import sleep
 
# Les modules nécessaires sont importés et mis en place
import time, signal, sys, os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
 
# Les variables utilisées sont initialisées
delayTime = 0.2
 
# attribution d'adresse ADS1x15 ADC
 
ADS1015 = 0x00  # 12-bit ADC
ADS1115 = 0x01  # 16-bit
 
# Choix du gain
gain = 4096  # +/- 4.096V
# gain = 2048  # +/- 2.048V
# gain = 1024  # +/- 1.024V
# gain = 512   # +/- 0.512V
# gain = 256   # +/- 0.256V
 
# Choix de la fréquence d'échantillonnage ADC (SampleRate)
# sps = 8    # 8 échantillons par seconde
# sps = 16   # 16 échantillons par seconde
# sps = 32   # 32 échantillons par seconde
sps = 64   # 64 échantillons par seconde
# sps = 128  # 128 échantillons par seconde
# sps = 250  # 250 échantillons par seconde
# sps = 475  # 475 échantillons par seconde
# sps = 860  # 860 échantillons par seconde
 
# choix du canal ADC (1-4)
adc_channel = 0    # Channel 0
# adc_channel = 1    # Channel 1
# adc_channel = 2    # Channel 2
# adc_channel = 3    # Channel 3
 
# initialisation du convertisseur
adc = ADS1x15(ic=ADS1115)
 
# Sélection de la broche d'entrée du signal numérique
Digital_PIN = 24
GPIO.setup(Digital_PIN, GPIO.IN, pull_up_down = GPIO.PUD_OFF)
 
#############################################################################################################
 
# ########
# boucle de programme principale
# ########
# Le programme lit les tensions en entrées et les transmet à la console.
 
try:
    while True:
        #Les valeurs de tension sont enregistrées
        analog = adc.readADCSingleEnded(adc_channel, gain, sps)
 
        # Envoi vers la console
        if GPIO.input(Digital_PIN) == False:
            print "Tension analogique:", analog,"mV, ","Limite: pas encore atteinte"
        else:
            print "Tension analogique:", analog, "mV, ", "Limite: atteinte"
        print "---------------------------------------"
 
        # Reset + Delay
        button_pressed = False
        time.sleep(delayTime)
 
 
 
except KeyboardInterrupt:
    GPIO.cleanup()

Exemple de téléchargement de programme

KY037-RPi.zip

Pour commencer avec la commande :

sudo python3 KY037-RPi.py

# Chargement des bibliothèques
from machine import Pin
from time import sleep
import ADS1115

# Initialisation de GPIO26 comme entrée ADC
ADS1115.init(0x48, 1, 4, False)
# Initialisation de GPIO18 comme entrée
digital = Pin(18,Pin.IN, Pin.PULL_UP)

# Boucle sans fin pour la lecture de l'ADC.
while True:
    Analog = ADS1115.read(0)
    # Conversion de la valeur analogique en tension
    Volt = ADS1115.raw_to_v(ADS1115.read(0))
    Dig = digital.value()

    # Sortie série de la valeur analogique et de la tension calculée
    print("Valeur analogique: " + str(Analog))
    print("Valeur de la tension analogique: " + str(Volt) + " V")

    # Demande si la valeur analogique a changé avec la sortie série.
    if Dig == 1:
        print("Valeur limite : atteinte.")
        print("----------------------------------------")
    else:
        print("Valeur limite : non atteinte.")
        print("----------------------------------------")
    sleep(2)