Zumbador de programa para Juegos Multijugador

Lo que necesitamos

Diagrama de circuito

Primero, conectamos todos los componentes como se puede observar en el siguiente diagrama de circuito:

Como pulsadores puede elegir cualquier componente para establecer un puente entre GND y la entrada digital correspondiente.

Utilizaremos las resistencias internas de pull-up, por lo que esto es posible. Sólo tenemos que asegurarnos después de que las entradas son active low.

Utilicé un módulo de zumbido pasivo. La diferencia con el zumbador activo es que no es necesario generar una señal de onda cuadrada. Bernd Albrecht se extendió sobre el uso de estos módulos en la entrada de su blog "Le enseñamos los tonos de la flauta". 

Exposición

Mi objetivo es poder pulsar cuatro botones diferentes y que cada uno de ellos muestre un color diferente en el anillo LED. También me gustaría que el módulo del zumbador emita el tono correspondiente. Primero, conecté el anillo de LEDs e instalé la librería adecuada llamada "Adafruit Neopixel". Trae el sketch de ejemplo "buttoncycler", que podemos utilizar bien como base. En lugar del anillo RGB también se pueden utilizar cuatro Módulo de Sensor RGB LED SMD. Después, la librería se omite, pero los pines RGB se deben conectar individualmente. Esto significa que son necesarios 4 x 3 pines. Cada uno de los botones están conectados a uno de los cuatro pines digitales y a GND. Con esto se tendría el hardware completo.

Para el timbre podemos instalar la librería "Tone". Esto hace que sea muy fácil obtener tonos del módulo. Aquí podemos utilizar el sketch de ejemplo "ToneTest".

El código fuente

A partir de los sketchs de ejemplo, escribí un programa que consulta los cuatro botones uno tras otro. Si se presiona uno de ellos, el LED correspondiente se ilumina durante 5 segundos y se escucha brevemente un tono.

Para probar la función de los componentes, justo al comienzo del programa, he agregado una animación de inicio, que enciende los LEDs de los colores del reproductor y hace sonar el zumbador.

 / * MultiplayergameshowBuzz 
  * Para cuatro jugadores con colores y toenen.
  * Para Az-Delivery.de
  *  
  * Función:
  * Los jugadores pueden activar un botón
  * El color del jugador se ilumina y suena zumbido.
  *  
  * Hardware utilizado:
  * - ATMEGA328P Microcontroller
  * - Módulo de zumbador pasivo
  * - Anillo de neopíxel con 12 LED RGB
  * - Botón 4
  *  
  * Bibliotecas utilizadas:
  * - adafruit_neaopixel.h
  * - tone.h
  *  
  * Fuente de muestra de Adafruit_Nopixel.H: CycleCler
  *  
  *************************************************** 
  * @Filename: buttoncycler.ino
  * @Brief: Neopixel Demo
  * @Author: Adafruit
  *
  * Copyright (C) Adafruit
  ****************************************************
  *
  * PINOUT:
  *  
  * Anillo Neopixel | Microcontrolador
  *  ------------------------------------
  * Vcc | 5v o 3.3v
  * GND | Gnd
  * En | D2
  *         
  *         
  * Fuente de muestra del tono.h: prueba de tono
  *************************************************** 
  * @FileName: SoundTest.ino
  * @Brief: Demo de tonos
  * @Author: 
  *
  * https://code.google.com/archive/p/rogue-code/wikis/tonelibrarydocumentation.wiki
  ***************************************************
  *
  * PINOUT:
  *  
  * Módulo de zumbador activo | Mikrocontroller
  *  ------------------------------------------------
  * GND | Gnd
  * En | D2
  *
  *
  */
 ​
 #include 
 #include 
 #define pixel_pin 2// Pin digital IO conectado a los neopíxeles.
 #define buzzer_pin 3
 #define pixel_count 12// Número de neopíxeles
 #define max_buttons 4
 ​
 /***************************
  * Neopíxel
  */
 // Declarar nuestro objeto de tira de Neopixel:
 Adafruit_neopixel banda(Pixel_Count, Pixel_pin, Neo_grb + Neo_khz800);
 // argumento 1 = Número de píxeles en la tira de Neopixel
 // argumento 2 = Número de PIN arduino (la mayoría son válidos)
 // argumento 3 = banderas tipo pixel, agregue juntos según sea necesario:
 // neo_khz800 800 kHz brocas de bits (la mayoría de los productos Neopixel w / WS2812 LEDs)
 // neo_khz400 400 kHz (clásico 'v1' (no v2) flora píxeles, controladores WS2811)
 // los píxeles neo_grb están cableados para GRB BITSTREAM (la mayoría de los productos Neopixel)
 // Los píxeles neo_rgb están cableados para RGB Bitstream (V1 Flora Pixels, no V2)
 // neo_rgbw píxeles están cableados para RGBW Bitstream (Neopixel RGBW Products)
 En t Led_number[Max_buttons] = {7, 10, 1, 4};                  // neopixel-nummer der spieler
 uint32_t color[Max_buttons] = { banda.Color(255, 0, 0),       // spielerfarben
                                 banda.Color(0, 255, 0),
                                 banda.Color(0, 0, 255),
                                 banda.Color(255, 0, 255)};
 /***************************
  * Botones
  */
 En t Button_Pin[Max_buttons] = {4, 5, 6, 7};                   // Botón Pin Nummern
 booleano antiguo[Max_buttons] = {ELEVADO, ELEVADO, ELEVADO, ELEVADO};     
 booleano estancamiento[Max_buttons] = {ELEVADO, ELEVADO, ELEVADO, ELEVADO};
 En t recuento de botón = 0;
 ​
 /***************************
  * Tonos
  */
 En t notas[] = { NOTA_C3,
                 NOTA_C4,
                 NOTA_D4,
                 NOTA_E4,
                 NOTA_F4};
 Tono zumbador;
 ​
 vacío configuración() {
   mono(Button_Pin[0], Input_pullup);
   mono(Button_Pin[1], Input_pullup);
   mono(Button_Pin[2], Input_pullup);
   mono(Button_Pin[3], Input_pullup);
   zumbador.empezar(Buzzer_pin);
   banda.empezar(); 
   banda.show();
   startanimation();
 }
 ​
 vacío círculo() {
   estancamiento[recuento de botón] = lectura digital(Button_Pin[recuento de botón]);
   
   Si((estancamiento[recuento de botón] == BAJO) && (antiguo[recuento de botón] == ELEVADO)) {
     // Retardo corto para rebotar el botón.
     demora(20);
     // Compruebe si el botón sigue siendo bajo después de rebotar.
     estancamiento[recuento de botón] = lectura digital(Button_Pin[recuento de botón]);
     Si(estancamiento[recuento de botón] == BAJO) {      // Sí, todavía bajo
       banda.setpixelcolor(Led_number[recuento de botón], color[recuento de botón]);
       banda.show();
       zumbador.tocar(notas[0], 500);
       demora(5000);
       banda.setpixelcolor(Led_number[recuento de botón], banda.Color(  0,   0,   0));
       banda.show();
     }
   }
   // Establezca el estado del botón de la última lea al estado anterior.
   antiguo[recuento de botón] = estancamiento[recuento de botón];
   recuento de botón++;
   Si (recuento de botón > Max_buttons-1) {
     recuento de botón = 0;
   }
 }
 ​
 vacío startanimation() {
   En t I = 0;
   En t concurso de colores = 0;
   En t tiempo de retardo = 35;
 ​
   // FARBKREISE MIT SPIELERFARBEN
   tiempo (concurso de colores < Max_buttons) {
     zumbador.tocar(notas[concurso de colores+1], 200); 
     por (I = 0; I < Pixel_Count; I++) {
       banda.setpixelcolor(I, color[concurso de colores]);
       banda.show();
       demora(tiempo de retardo);
     }
     concurso de colores++;
   }
   
   concurso de colores = 0;
 ​
   // alle pixel aus
   por (I = 0; I < Pixel_Count; I++) {
     banda.setpixelcolor(I, banda.Color(  0,   0,   0));
     banda.show();
     demora(tiempo de retardo);
   }
 ​
   // spieler-pixel
   por (I = 0; I < Max_buttons; I++) {
     banda.setpixelcolor(Led_number[I], color[I]);
     banda.show();
     zumbador.tocar(notas[I+1], 200);
     demora(500);
   }
 ​
   demora(1000);
   
   por (I = 0; I < Pixel_Count; I++) {
     banda.setpixelcolor(I, banda.Color(  0,   0,   0));
     banda.show();
   }
 }

Para recorrer los botones y LEDs del programa más rápidamente y con menos código fuente, he utilizado matrices. La siguiente línea contiene el número de LED en el anillo de LEDs RGB: 

 En t Led_number[Max_buttons] = {7, 10, 1, 4};

El LED con el número 0 está a las 5 horas, es decir, en la parte inferior derecha. Esto se debe a que soldé una tira de pines, con la que pude conectar el anillo en la placa de conexión.

Los colores de los jugadores se definen con la siguiente línea:

 uint32_t color[Max_buttons] = { banda.Color(255, 0, 0),       // Colores del jugador
                                 banda.Color(0, 255, 0),
                                 banda.Color(0, 0, 255),
                                 banda.Color(255, 0, 255)};

La función Color () de la librería Neopixel crea un valor de 32 bits. Aquí he agrupado cuatro valores.

Los pines de los botones y sus estados, se escriben en las matrices de la siguiente manera:

 En t Button_Pin[Max_buttons] = {4, 5, 6, 7};                   // Números de pin del botón
 booleano Antiguo[Max_buttons] = {ELEVADO, ELEVADO, ELEVADO, ELEVADO};     
 booleano Estancamiento[Max_buttons] = {ELEVADO, ELEVADO, ELEVADO, ELEVADO};

Con la matriz ahora es posible consultar los cuatro pines uno tras otro con digitalRead() con el empleo de un bucle. Las matrices oldState [] y newState [] son necesarias para comprobar si un botón se presionó y también si se soltó nuevamente. De lo contrario, mantendríamos pulsado el botón y, por lo tanto, haríamos sonar el timbre varias veces. En teoría, no necesitaríamos hacer esto, ya que incluido una pausa cuando se presiona un botón.

Los tonos del zumbador también se pueden escribir en una matriz. He configurado el C3 como el tono que suena cuando se pulsa un botón. Los otros tonos son sólo para la animación de inicio.

 vacío configurar() {
   mono(Button_Pin[0], Input_pullup);
   mono(Button_Pin[1], Input_pullup);
   mono(Button_Pin[2], Input_pullup);
   mono(Button_Pin[3], Input_pullup);
   zumbador.Empezar(Buzzer_pin);
   banda.Empezar(); 
   banda.show();
   animación inicial();
 }

Para esto se inicializan con INPUT_PULLUP. El zumbador necesita la función begin(), al igual que el anillo de LEDs RGB. La función show() apaga los LEDs aquí. Siempre es necesario para mostrar el color establecido en el LED deseado. Los valores se cargan primero en la memoria y luego se muestran en los LEDs.

Aquí comienzo la animación de inicio después de la inicialización. Con dos bucles, los píxeles se recorren y se muestran con los colores previamente establecidos. Después se apagan y los LEDs de los reproductores se vuelven a encender uno a uno. A continuación, suena el timbre.

Aquí ya vemos la ventaja de las matrices. Con los bucles puede iterar fácilmente.

La función loop () también se ha vuelto relativamente corta como resultado. Dado que el microcontrolador se ejecuta en un bucle sin fin de todos modos, no necesitamos crear un bucle adicional. Consultamos los pines de los botones y contamos el índice de la matriz con cada pasada. Cuando se presiona uno de los botones, la consulta condicional se pone en marcha y el LED correspondiente se ilumina. Los pines de los botones, los números de los LEDs y los colores de los jugadores utilizan el mismo índice en sus matrices. Esto permite acceder a los valores de todas las matrices con un contador. Esto acorta enormemente el código fuente.

Conclusión