Para Arduino

¿Qué es un módulo KY-006?

Se trata de un módulo que integra un buzzer o zumbador pasivo y tiene una estructura que simplifica su uso, lo que hace que sea muy sencillo utilizarlo con Arduino.

El zumbador pasivo emite un sonido cuando se aplica una señal sinusoidal o cuadrada. Dependiendo de la frecuencia de la señal el sonido variará.

Este módulo forma parte del kit de 37 sensores compatible con Arduino.

¿Para qué sirve el módulo KY-006?

Los zumbadores pasivos tienen una variedad de aplicaciones en diferentes campos debido a su capacidad para generar sonidos o tonos específicos cuando se les aplica una señal eléctrica adecuada.

Algunos de los usos más comunes de los zumbadores pasivos incluyen:

• Electrodomésticos: Se utilizan para emitir señales sonoras en dispositivos como microondas, hornos, lavadoras, y refrigeradores. Estos sonidos pueden indicar el fin de un ciclo de trabajo, una puerta abierta, o algún otro estado importante.
• Alarmas y sistemas de seguridad: Los zumbadores pasivos son componentes clave en sistemas de alarma para casas, coches, y dispositivos de seguridad personal. Pueden emitir tonos fuertes para alertar sobre una intrusión, un incendio, o cualquier otra emergencia.
• Equipos médicos: En dispositivos médicos, los zumbadores pasivos pueden alertar al personal médico sobre condiciones específicas de los pacientes, como cambios en los signos vitales o la finalización de ciclos de dosificación en equipos de infusión.
• Juguetes electrónicos: Se utilizan en juguetes para producir efectos sonoros, mejorando la experiencia de juego al proporcionar retroalimentación auditiva que puede ser activada por acciones específicas del usuario.
• Instrumentos musicales electrónicos: En algunos casos, los zumbadores pasivos se utilizan en instrumentos musicales electrónicos para crear sonidos o notas específicas, especialmente en dispositivos educativos o de juguete.
• Relojes y cronómetros: Los zumbadores pasivos pueden emitir señales audibles para indicar alarmas, fin de tiempos de cuenta regresiva, o cambios en la configuración.
• Computadoras y periféricos: Son usados para emitir señales de error o de confirmación, como el pitido durante el arranque que indica que el sistema ha pasado las pruebas de autodiagnóstico.
• Controladores industriales y sistemas de automatización: En entornos industriales, los zumbadores pasivos pueden alertar sobre el estado de las máquinas, cambios en los procesos de producción, o necesidades de mantenimiento.
• Dispositivos de comunicación: En algunos dispositivos de comunicación, como estaciones base para teléfonos inalámbricos o sistemas de intercomunicación, los zumbadores pasivos pueden indicar llamadas entrantes o mensajes.

La flexibilidad y simplicidad de los zumbadores pasivos los hacen ideales para cualquier aplicación que requiera una forma económica y eficiente de proporcionar retroalimentación o alertas sonoras.

Especificaciones del módulo KY-006

Estructura física

El módulo tiene conectado un buzzer piezoeléctrico pasivo:

Dispone de 3 pines. Dos de ellos conectados al buzzer y un tercero que no está conectado a nada, por lo que no se utiliza.

• GND: Tiene un signo menos (-) y es el que tenemos que conectar con la tierra de nuestro Arduino.
• IN: Tiene una S. Es el que conectaremos a un pin PWM de nuestro Arduino para enviar la señal con la frecuencia deseada para hacer sonar el buzzer.
• Pin central: No se usa.

Especificaciones técnicas

A continuación puedes ver las especificaciones técnicas del módulo KY-006:

¿Cómo funciona el zumbador pasivo?

El zumbador pasivo del módulo KY-006 convierte las señales eléctricas en sonido mediante el uso de un material piezoeléctrico.

En el interior de estos componentes se encuentra un disco hecho de material piezoeléctrico, como el titanato de circonio y plomo (PZT). Este material tiene la propiedad de cambiar de forma o vibrar cuando se le aplica un voltaje eléctrico, y viceversa, puede generar un voltaje cuando se deforma.

Cuando se aplica una señal eléctrica alternante (AC) a través del material piezoeléctrico, este empieza a vibrar debido a los cambios rápidos de polaridad en la señal eléctrica.

Las vibraciones del disco piezoeléctrico crean ondas de presión en el aire, las cuales percibimos como sonido. La frecuencia de la señal eléctrica aplicada determina la frecuencia de las vibraciones y, por tanto, el tono del sonido producido.

¿Cómo conectar el módulo KY-006 con Arduino?

Materiales

Estos son los materiales necesarios para conectar un módulo KY-006 con Arduino:

	Una placa Arduino (Yo usaré Arduino UNO)
	Un módulo KY-006
	Cables
	Una protoboard
	Un ordenador con el IDE de Arduino instalado

Conexiones

Las conexiones son las que aparecen en la siguiente imagen:

Como puedes ver, las conexiones son muy sencillas.

El pin etiquetado con un signo negativo (-) va conectado a tierra. Utilizaremos la linea negativa de la protoboard para hacer esta conexión. El pin GND de Arduino va conectado a esta linea y el pin negativo del módulo también.

El pin etiquetado con S lo tenemos que conectar a un pin digital. Yo lo he conectado al pin 4, pero puedes usar otro si lo prefieres.

Dicho esto, vamos a hacer el sketch.

¿Cómo programar el módulo KY-006 con Arduino?

Hay dos formas de modificar la frecuencia de la señal que vamos a enviar al buzzer. Una es utilizando la función tone() y la otra es utilizando digitalWrite() con delay(). Vamos a ver un ejemplo de cada una.

Con tone()

Este es el sketch completo para utilizar el módulo KY-006 con tone():

//DECLARACIONES
#define DO  131
#define RE  147
#define MI  165
#define FA  175
#define SOL  196
#define LA  220
#define SI  247

const int KY006 = 4;

const int MELODIA[] = {
  DO, RE, MI, FA, SOL, LA, SI
};

const int TIEMPO = 500;

//CONFIGURACIÓN
void setup() {

}

//FUNCIÓN LOOP
void loop(){
  for (int i = 0; i < 7; i++) {
    tone(KY006, MELODIA[i]);
    delay(TIEMPO);
    noTone(KY006);
    delay(TIEMPO * 0.3);
  }
}

Declaraciones

Tenemos que declarar 7 constantes con las frecuencias de las notas en Hz. Las he llamado igual que las notas (DO, RE, MI, FA, SOL, LA y SI) para que no haya confusión.

#define DO  131
#define RE  147
#define MI  165
#define FA  175
#define SOL  196
#define LA  220
#define SI  247

También vamos a declarar una constate para el pin digital en el que hemos conectado el módulo. En mi caso el pin 4:

const int KY006 = 4;

Lo siguiente que necesitamos es la melodía que vamos a generar. Para eso nos ayudaremos de un array:

const int MELODIA[] = {
  DO, RE, MI, FA, SOL, LA, SI
};

He escogido la escala musical porque me parecía más sencillo de entender. En un futuro artículo ya te explicaré como hacer una canción a partir de una partitura.

Fíjate que los elementos que componen el array MELODIA son las constantes con las frecuencias de cada nota que habíamos declarado antes. Las debemos colocar en el orden en el que sonarán.

Configuración

En este caso no será necesario realizar ninguna configuración, por lo que dejaremos la función setup() vacía.

void setup() {

}

Función loop

Y dentro de la función loop() generamos la secuencia de tonos:

void loop(){
  for (int i = 0; i < 7; i++) {
    tone(KY006, MELODIA[i]);
    delay(TIEMPO);
    noTone(KY006);
    delay(TIEMPO * 0.3);
  }
}

Con el bucle for recorremos el array MELODIA. Fíjate que empieza en 0 (int i=0) y termina en 6 (i<7). Esos valores se corresponden con las posiciones que ocupan las notas dentro del array.

Dentro del bucle for llamamos a la función tone() pasándole el pin digital en el que está conectado el módulo KY-006 y la frecuencia en Hz que tendrá el tono:

tone(KY006, MELODIA[i]);

Las frecuencias que soporta la función tone() van desde los 31Hz hasta los 65535Hz. Aunque nosotros ahora solo usaremos las 7 frecuencias que hemos definido para la escala musical.

Como puedes ver, el pin lo indicamos utilizando la constante KY006 y la frecuencia la sacamos del array MELODIA con ayuda del indice del bucle (MELODIA[i]) que representa la posición del array a la que queremos acceder.

La siguiente instrucción es un delay con el tiempo que durará el tono en milisegundos:

delay(TIEMPO);

Recuerda que la constante TIEMPO, que declaramos anteriormente, tiene valor 500, por lo que se generará un retraso de medio segundo antes de que se ejecute la siguiente instrucción. Si prefieres que tenga otra duración, simplemente cambia el valor de la constante.

La siguiente instrucción es la llamada a noTone():

noTone(KY006);

La función noTone() detiene el tono del pin que se le indica como parámetro, en este caso el pin 4, que es el valor de la constante KY006 y es donde hemos conectado el módulo.

Como noTone() se ejecuta justo después de la instrucción delay de 500ms, el tono no se detendrá hasta que transcurra ese tiempo. Por tanto el tono sonará durante medio segundo.

Y hemos llegado a la última instrucción dentro del bucle for. Se trata de otro delay:

delay(TIEMPO * 0.3);

En este caso el tiempo del retraso será el 30% del tiempo total del tono. Por eso multiplicamos TIEMPO * 0.3. Como el tono ya se detuvo por la llamada a la función noTone(), este delay será un tiempo en el que no sonará nada. Como está justo al final de la instrucción for, lo que conseguimos es que haya un pequeño silencio entre nota y nota, puesto que se ejecutará justo antes de que el for itere y pase a la siguiente posición del array.

Cuando el array complete sus 7 iteraciones habrán sonado las 7 notas de la escala. En este punto la función loop comenzará de nuevo, por lo que volverá a sonar la escala desde el principio. Y se repetirá mientras el Arduino reciba alimentación.

Versión simplificada de la función loop

La función tone() tiene una variación que permite pasar, además del pin y la frecuencia, el tiempo que dura el tono. Usando esta versión de la función podemos simplificar la función loop() de la siguiente forma:

void loop() {
  for (int i = 0; i < 7; i++) {
    tone(KY006, melodia[i], TIEMPO);
    delay(TIEMPO * 1.3);
  }
}

Como puedes comprobar, el tercer parámetro que le pasamos a tone() es la constante TIEMPO que antes utilizamos con delay().

tone(KY006, melodia[i], TIEMPO);

De esta forma le estamos indicando que el tono que enviamos debe durar 500ms. Una vez transcurrido ese tiempo se detendrá sin necesidad de llamar a noTone().

Hay que tener en cuenta una cosa. Ese tiempo que pasamos a tone() solo le indica la duración del tono, pero no impide que la siguiente instrucción del sketch se ejecute antes de que se complete el tiempo. Por tanto, el sketch continuará su ejecución normal aunque el tono esté sonando.

Para impedir que el sketch continúe antes de que se complete el tono usamos un delay():

delay(TIEMPO * 1.3);

Al pasarle el tiempo multiplicado por 1.3 le estamos indicando que debe esperar los 500ms que dura el tono y un 30% más de ese tiempo en el que no se emitirá ningún tono.

De esta forma conseguimos lo mismo que teníamos en el versión inicial, pero con menos código.

Con digitalWrite() y delay()

Vamos ahora a ver el otro caso utilizando digitalWrite() y delay():

//DECLARACIONES
const int KY006 = 4;

//CONFIGURACIÓN
void setup() {
  pinMode(KY006, OUTPUT);
}

//FUNCIÓN LOOP
void loop() {
  for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 100; j++) {
      digitalWrite(KY006, HIGH);
      delay(i);
      digitalWrite(KY006, LOW);
      delay(i);
    }
    delay(50);
  }
}

Declaraciones

Primero vamos a declarar una constante para el pin digital en el que hemos conectado el módulo KY-006:

const int KY006 = 4;

En mi caso es el pin 4, si has usado otro diferente cambia este valor.

Configuración

Dentro de la función setup() tenemos que configurar el pin KY006 como salida, puesto que enviaremos pulsos altos y bajos para generar los tonos en el buzzer:

void setup() {
  pinMode(KY006, OUTPUT);
}

Función loop

En la función loop() generaremos los tonos.

Fíjate que hay 2 bucles for anidados:

for (int i = 1; i < 11; i++) {
    for (int j = 0; j < 100; j++) {
      ...
    }
    ...
}

El for externo, el que tiene como índice la variable i, genera 10 iteraciones. Este bucle es el que controla los tonos. Por cada iteración de este bucle se generará un tono.

El for interno, el de la j, es el responsable de generar un tono. Como puedes ver realiza 100 repeticiones. Por cada iteración generaremos un pulso alto y un pulso bajo. Cuando se completen las 100 iteraciones se habrán producido 100 pulsos altos y 100 bajos intercalados. De esta forma obtendremos una señal cuadrada.

Las instrucciones del interior del bucle interno son las responsables de hacer estos pulsos que hemos comentados antes, es decir, un pulso alto (HIGH) y uno bajo (LOW):

digitalWrite(KY006, HIGH);
delay(i);
digitalWrite(KY006, LOW);
delay(i);

Te preguntarás, ¿Cómo va a hacer esto que suenen los tonos diferentes? La clave está en los delay que hay después de cada digitalWrite(). El tiempo que se ejecutará el delay lo determina la variable i del bucle externo y dependiendo de este valor la frecuencia de la señal cuadrada variará.

Es decir, cuando i tenga valor 1 el delay será de 1 ms, por tanto la señal generada será así:

En la siguiente iteración i tendrá valor 2, por lo que la señal será esta otra:

Y así sucesivamente con los 10 valores que irá tomando la variable i.

El periodo de la señal cambia, por lo que la frecuencia también lo hace, lo que se traducirá en diferentes sonidos del buzzer.

Ya solo falta un último detalle, el delay que hay justo al final del for externo:

for (int i = 1; i < 11; i++) {
    for (int j = 0; j < 100; j++) {
      ...
    }
    delay(50);
}

Este delay de 50 ms será el encargado de hacer una pequeña pausa entre tono y tono. Puedes poner otra duración si lo prefieres. Durante este tiempo el módulo KY-006 no generará ningún sonido.

Bueno, pues ya tenemos los dos sketch. Carga primero uno en tu Arduino y pruébalo y después haz lo mismo con el otro para comprobar que te ha salido bien.

¡Suscríbete a la newsletter y no te pierdas nada!

Te avisaré cuando publique nuevo contenido en paraarduino.com y en mi canal de YouTube (@ParaArduino).