Módulo KY 038 - tectijuana/sistemasprogramables-kamikaze GitHub Wiki

El sensor KY-038 tiene como característica que es altamente sensible, por lo que su sensor de micrófono de condensador electret (EC) permite detectar un mínimo ruido producido en el ambiente, cuenta con un LED indicador de suministro de energía y por el otro extremo cuenta con otro que indica la salida. También permite obtener dos salidas, una análoga, que lleva toda la información que está detectando el micrófono y una digital que es una salida de encendido o apagado que se activa cuando el sonido supera un cierto volumen establecido por el potenciómetro.

Este Sensor puede detectar sonido, consiste en el funcionamiento de un detector de ondas sonoras, dichas ondas son recibidas en forma de energía y son enviadas mediante señales eléctricas hacia un aparato receptor/codificador.

Este sensor la señal que nos entrega es digital y analógica, lo cual nos permite decidir cuál utilizar según nuestras necesidades. Si necesitamos saber el valor del sensor, podremos utilizar directamente la salida analógica para conseguir los datos. Sino, podemos utilizar la salida digital, la cual se activa o se desactiva según si el sensor llega a medir la intensidad del sonido que le configuremos, mediante la definición de la sensibilidad del sensor.

• Modelo: KY-038
• Voltaje de Funcionamiento: 4 a 6 V DC
• Distancia Máxima de Inducción: 0.5 metros.
• Chip Principal: LM393
• Micrófono: Electret
• Gama de Frecuencias: 100 – 10.000 Hz.
• Sensibilidad: – 46 ± 2,0, (0dB = 1V / Pa) a 1K Hz.
• La Sensibilidad Mínima a Ruido: 58 dB
• Dimensiones: 36 x 15 x 15 mm
• Peso: 4 gr

El esquema eléctrico es sencillo. Alimentamos el módulo conectando GND y 5V a los pines correspondientes de Arduino.

Ahora si queremos usar la lectura digital, conectamos la salida DO a una de las entradas digitales de Arduino.

Deberemos calibrar el umbral de disparo de la salida digital con el potenciómetro instalado en el módulo para el nivel de sonido deseado.

Mientras que la conexión vista desde Arduino quedaría así:

Si quisiéramos emplear el valor analógico, simplemente conectaríamos la salida AO del sensor a una entrada analógica de Arduino. Aunque, como hemos dicho, en este caso sería mejor optar por un modelo amplificado.

En el primer ejemplo de código, empleamos la señal digital del sensor para encender el LED integrado en Arduino si se detecta sonido, y apagarlo en caso contrario.

const int pinLED = 13;
const int pinMicrophone = 9;
 
void setup ()
{
  pinMode (pinLED, OUTPUT);
  pinMode (pinMicrophone, INPUT);
}
 
void loop ()
{
  bool soundDetected = digitalRead(pinMicrophone);
  if (soundDetected)
  {
    digitalWrite (pinLED, HIGH);
    delay(1000);
  }
  else
  {
    digitalWrite (pinLED, LOW);
    delay(10);
  }
}

En el siguiente ejemplo almacenamos un estado (ON/OFF) y hacemos que varíe cada vez que se detecte un sonido. En el ejemplo empleamos el estado para encender o apagar el LED integrado, pero en un caso real realizaríamos las acciones oportunas como activar un relé.

const int pinLED = 13; 
const int pinMicrophone = 9;
bool state;
 
void setup()
{
  pinMode(pinLED, OUTPUT);
  pinMode(pinMicrophone, INPUT_PULLUP);
}
 
void loop()
{
  bool soundDetected = digitalRead(pinMicrophone); 
  if (soundDetected == true)
  {
    state = ! state;    
    digitalWrite(pinLED , state);
    delay (1000);
  }
  delay(10);
}

Este último ejemplo lee el valor de voltaje actual que se medirá en el pin de salida y lo muestra a través de la interfaz en serie.

Además de eso, el estado del pin digital se mostrará en el terminal, indicándonos si se superó o no el valor extremo.

// Declaration and initialization of the input pin
int Analog_Eingang = A0; // X-axis-signal
int Digital_Eingang = 3; // Button
  
void setup ()
{
  pinMode (Analog_Eingang, INPUT);
  pinMode (Digital_Eingang, INPUT);
       
  Serial.begin (9600); // Serial output with 9600 bps
}
  
// The program reads the current value of the input pins
// and outputs it via serial out
void loop ()
{
  float Analog;
  int Digital;
    
  // Current value will be read and converted to voltage 
  Analog = analogRead (Analog_Eingang) * (5.0 / 1023.0); 
  Digital = digitalRead (Digital_Eingang);
    
  //... and outputted here
  Serial.print ("Analog voltage value:"); Serial.print (Analog, 4);  Serial.print ("V, ");
  Serial.print ("Extreme value:");
  
  if(Digital==1)
  {
      Serial.println (" reached");
  }
  else
  {
      Serial.println (" not reached yet");
  }
  Serial.println ("----------------------------------------------------------------");
  delay (200);
}

Señal Digital = Pin 3
+V = Pin 5V
GND = Pin GND
Señal Análoga = Pin 0

ARD_Analog-Sensor

!! Atención !! Sensor Análogo !! Atención !!

A diferencia de Arduino, el Raspberry Pi no proporciona un ADC (Convertidor Digital Analógico) en su chip. Esto limita al Raspbery Pi si desea utilizar un sensor no digital.

Para evadir esto, es importante utilizar el Sensorkit x40 con el módulo KY-053, que proporciona un ADC de 16 bits que se puede usar con el Raspberry Pi para actualizarlo con 4 pines de entrada analógica adicionales. Este módulo está conectado a través de I2C al Raspberry Pi. Mide los datos analógicos y los convierte en una señal digital adecuada para Raspberry Pi.

Por lo tanto, recomendamos utilizar el ADC KY-053 si desea utilizar sensores analógicos junto con Raspberry Pi. Para obtener más información, consulte el infosite: Convertidor Digital Analógico KY-053

!! Atención !! Sensor Análogo !! Atención !!

El programa utiliza las bibliotecas de python ADS1x15 e I2C específicas de la empresa Adafruit para controlar el ADS1115 ADC. Puede encontrarlos aquí: Adafruit-Raspberry-Pi-Python-Code publicado bajo BSD License. Puede encontrar las bibliotecas necesarias en el paquete de descarga inferior.

El programa lee los valores actuales de los pines de entrada y los emite en el terminal en [mV].

Además de eso, el estado del pin digital se mostrará en la terminal para mostrar si se superó o no el valor extremo.

#############################################################################################################
### Copyright by Joy-IT
### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
### Commercial use only after permission is requested and granted
###
### KY-053 Analog Digital Converter - Raspberry Pi Python Code Example
###
#############################################################################################################
 
 
# This code is using the ADS1115 and the I2C Python Library for Raspberry Pi
# This was published on the following link under the BSD license
# [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code]
from Adafruit_ADS1x15 import ADS1x15
from time import sleep
 
# import needed modules
import math, signal, sys, os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
 
# initialise variables
delayTime = 0.5 # in Sekunden
 
# assigning the ADS1x15 ADC
 
ADS1015 = 0x00  # 12-bit ADC
ADS1115 = 0x01  # 16-bit
 
# choosing the amplifing gain
gain = 4096  # +/- 4.096V
# gain = 2048  # +/- 2.048V
# gain = 1024  # +/- 1.024V
# gain = 512   # +/- 0.512V
# gain = 256   # +/- 0.256V
 
# choosing the sampling rate
# sps = 8    # 8 Samples per second
# sps = 16   # 16 Samples per second
# sps = 32   # 32 Samples per second
sps = 64   # 64 Samples per second
# sps = 128  # 128 Samples per second
# sps = 250  # 250 Samples per second
# sps = 475  # 475 Samples per second
# sps = 860  # 860 Samples per second
 
# assigning the ADC-Channel (1-4)
adc_channel_0 = 0    # Channel 0
adc_channel_1 = 1    # Channel 1
adc_channel_2 = 2    # Channel 2
adc_channel_3 = 3    # Channel 3
 
# initialise ADC (ADS1115)
adc = ADS1x15(ic=ADS1115)
 
# Input pin for the digital signal will be picked here
Digital_PIN = 24
GPIO.setup(Digital_PIN, GPIO.IN, pull_up_down = GPIO.PUD_OFF)
  
#############################################################################################################
  
# ########
# main program loop
# ########
# The program reads the current value of the input pin
# and shows it at the terminal
  
try:
        while True:
                #Current values will be recorded
                analog = adc.readADCSingleEnded(adc_channel_0, gain, sps)
  
                # Output at the terminal
                if GPIO.input(Digital_PIN) == False:
                        print "Analog voltage value:", analog,"mV, ","extreme value: not reached"
                else:
                        print "Analog voltage value:", analog, "mV, ", "extreme value: reached"
                print "---------------------------------------"
  
                sleep(delayTime)
  
  
  
except KeyboardInterrupt:
        GPIO.cleanup()

Sensor:

• Señal Digital = GPIO 24 [Pin 18 (RPi)]
  
• + V = 3,3V [Pin 1 (RPi)]
  
• GND = GND [Pin 06 (RPi)]
  
• Señal Análoga = 0 Análogo [Pin A0 (ADS1115 - KY-053)]
  

ADS1115 - KY-053:

• VDD = 3,3V [Pin 01]
  
• GND = GND [Pin 09]
  
• SCL = GPIO03 / SCL [Pin 05]
  
• SDA = GPIO02 / SDA [Pin 03]
  
• A0 = Mira Arriba [Sensor: Señal Analógica]

KY-038_Microphone_sensor_module_RPi

Para comenzar, ingrese el comando: sudo python KY-038_Microphone_sensor_module_RPir.py