Batería MIDI mínima con impresora 3D

Componentes y suministros

Arduino UNO

LCD estándar Adafruit - 16x2 blanco sobre azul

SparkFun Piezo

Resistencia sensible a la fuerza de Adafruit (FSR)

Resistencia de 10k ohmios

Resistencia 1M ohm

Diodo Zener SparkFun - 5.1V 1W

Interruptor de botón SparkFun de 12 mm

Interruptor deslizante

TRS Socket

Cable USB-A a B

Adaptador de cámara Apple Lightning a USB

Herramientas y máquinas necesarias

Impresora 3D (genérica)

Cortadora láser (genérica)

no es necesario, extra

Soldador (genérico)

cortador de círculos

Aplicaciones y servicios en línea

Arduino IDE

Acerca de este proyecto

Hola.

Este es un kit de batería mínimo con arduino UNO.

En primer lugar, consulte esta página de instrucciones.

https://blog.arduino.cc/2017/01/19/a-3d-printed-e-drum-pad/

Desde que comencé a hacer esto, me cautivaron las baterías electrónicas y piezoeléctricas.

Estaba fascinado por un mecanismo muy simple de batería electrónica y el gran invento llamado MIDI.

En otras palabras, no podría estar satisfecho con solo hacer almohadillas.

Esta batería se divide aproximadamente en dos producciones.

1.Almohadilla hecha con una impresora 3D y papel grueso.

2.Disparador de convertidor midi con arduino UNO.

La señal enviada desde el pad de "1" es procesada por arduino de "2" y convertida en señal MIDI. Y la señal MIDI se transmite desde arduino a iPhone, computadora portátil, etc., y sale el sonido.

No es necesario preparar una fuente de alimentación que no sea un teléfono inteligente o una PC.

Qué necesitará

Herramientas

・ Impresora 3D

・ Cortadora láser (adicional)

・ Llave hexagonal

・ Cuchillo cortador

・ Cortador de círculos

・ Soldador

・ Cortatubos

・ Taladro de destornillador

・ Broca de 9 mm / 10 mm

Material

・ Papel de 1 mm de grosor

・ Filamento PLA

・ Hojas de esponja de espuma de 5 mm / 10 mm

・ MDF de 2,5 mm / 5,5 mm (adicional)

・ M6 - Perno y tuercas de 70 mm

・ M6 - Perno y tuercas de 50 mm

・ M3 - Perno y tuercas de 10 mm

・ M3 - Perno y tuercas de 15 mm

・ M3 - Perno y tuercas de 25 mm

・ Tornillo M2

・ Tubería de acero inoxidable de 13 mm de diámetro

Hardware de batería

・ Cabezal de malla de 10 pulgadas / 8 pulgadas

・ Soporte de caja (todo está bien. Estoy usando YAMAHA SS662.)

・ Soporte para charles (todo está bien. Estoy usando YAMAHA HS650A)

・ Pedal de patada (todo está bien. Estoy usando YAMAHA FP7210A)

・ Baqueta de tambor

Paso 1:Impresión 3D

Todos los datos están en Thingiverse y GitHub.

Utilice la versión 2 para la llanta.

Imprimí piezas con relleno al 20%. El grosor de la capa es de 0,3 mm.

Además, puede utilizar un cortador láser para hacer almohadillas.

https://github.com/RyoKosaka/drums/tree/master/vector

Paso 2:Montaje

Utilice pernos y tuercas de M3-10 mm para conectar las piezas.

Utilice los pernos M3-15 mm o M3-25 mm para la parte central para fijar la parte inferior entre sí.

Paso 3:hacer Shell

Primero, la altura del caparazón es de 55 mm.

Haga tres bandas con un ancho de 55 mm.

La longitud es un poco más larga que la longitud que cubre la almohadilla.

Dado que hay un espacio en la parte inferior, intente insertar una banda en ese espacio.

Corta la banda para que tenga la longitud perfecta del círculo.

Repita esto 3 veces y superponga con adhesivo.

Cuando la cáscara se seque, con la cabeza de la malla fijada, haga un agujero de 9 mm de diámetro para el encaje.

Puedes usar tuercas de mariposa, pero también hice teclas de afinación que se pueden apretar incluso con tuercas comunes, así que úsalas por todos los medios.

Para fijar la cabeza de la malla, utilice pernos M6-70 mm.

Una vez que hayas hecho un agujero, vuelve a quitar el cabezal de malla para poner un piezo

Paso 4:Adjuntar Piezo

SNARE

En el caso de una trampa, use dos piezo como se muestra en la imagen.

Conecte el cable rojo del piezoeléctrico a cada punta y anillo.

Ambos cables negros se conectan a la manga.

No olvide pasar los cables a través de los orificios de la placa del sensor al soldar.

El piezo para la cabeza (piezo conectado a la punta) debe emparejarse con una esponja de espuma de 10 mm de espesor como se muestra en la imagen.

Uno abajo, tres arriba. Y haz que los 3 conos superiores sean como en la imagen.

Luego colóquelo en la placa del sensor.

PATADA

Dado que el pad de bombo usa solo un piezo, solo se puede usar la punta.

No se requiere placa de sensor. Dos esponjas de espuma debajo del piezo

Coloque el sensor desplazado desde el centro.

Es porque arduino no puede juzgar la fuerza del golpe si el batidor golpea el sensor directamente.

HI-HAT

El circuito es el mismo que el del pad de bombo.

Coloque un trozo de esponja de espuma de 10 mm de espesor debajo del piezo.

Piezo es delicado. Tenga cuidado de no doblarse ni lastimarse.

Paso 6:Kick PAD de 8 pulgadas

Primero, corte un tubo de acero inoxidable de 13 mm de diámetro.

Haga dos de 200 mm y dos de 365 mm.

Dado que la longitud se puede ajustar, incluso si hay algún error en la longitud, está bien.

Móntelos con referencia a imágenes.

Para fijar la tubería, está diseñada para que la tuerca M3 se pueda cargar dentro de la pieza.

Fije la tubería de forma segura. Utilice pernos y tuercas de M3-15 mm.

Paso 7:charles de 12 pulgadas

Después de producir la cáscara con papel grueso, pensé que si usabas papel grueso podría hacer platillos.

Primero. Corta papel grueso en un círculo con un diámetro de 300 mm. Haz tres de esto.

A continuación, haga una muesca desde el centro.

Finalmente, se hace una segunda muesca desde el punto a 10 mm de distancia paralela a la primera muesca.

De esta forma se hacen tres pac-mans con una pequeña boca abierta.

Luego, cierra la boca del Pac Man con cuidado con cinta adhesiva para darle forma de platillo.

Aplique adhesivo y superponga estos. No olvide extender el adhesivo de forma limpia y fina

Sujételo firmemente con las manos, luego coloque el peso alrededor y séquelo.

Para silenciar, poner una esponja de 5 mm de grosor y perforar un agujero. No puede abrir el agujero de forma ordenada, pero puede ocultar el agujero para que esté bien.

Complete colocando el soporte del sensor y la guía del cable con cinta adhesiva de doble cara. Podría ser más fácil si usa una pistola de pegamento.

Paso 8:controlador de charles

Hi-Hat Controller envía la apertura y cierre del charles a arduino.

El circuito es muy simple.

Está hecho combinando tres partes.

Coloque el FSR en la parte inferior y fije el casquillo. FSR se puede utilizar incluso si se abre un agujero.

Adjunte una esponja de 10 mm al FSR como si fuera una foto.

Fije la tapa con tornillos M3 - 10 mm.

Aunque solo es ALTO y BAJO, es posible que se pregunte por qué usé FSR.

Utilizo FSR para que se corresponda con módulos de sonido como Roland y Yamaha.

Y en la fuente de sonido exclusiva para batería como EZ DRUMMER 2, hay varias etapas en el grado de apertura del charles.

Si es FSR, es posible responder simplemente modificando el código. Sin embargo, no lo he probado.

Paso 9:USB - MIDI

¿Qué podemos hacer en este paso?

Con solo el cable USB, puede enviar señal midi desde arduino.

En otras palabras, haga que arduino sea reconocido por iPhone, etc. como un dispositivo midi sin ningún hardware adicional.

En primer lugar, consulte esta página.

http://morecatlab.akiba.coocan.jp/lab/index.php/aruino/midi-firmware-for-arduino-uno-moco/

https://github.com/kuwatay/mocolufa

Si conecta el arduino UNO normal directamente al iPhone, obtendrá un mensaje de error como "Arduino UNO no es compatible".

Entonces, debe reescribir el chip USB (ATmega16U2) utilizado en arduino UNO.

https://www.arduino.cc/en/Hacking/DFUProgramming8U2

Esta instrucción es cómo reescribir el archivo hexadecimal.

Continúe de acuerdo con este sitio hasta la descripción a continuación.

sudo dfu-programmer atmega16u2 flash Arduino-usbserial-uno.hex

Simplemente reemplace "Arduino-usbserial-uno.hex" por "dualMoco.hex".

Por lo tanto,

sudo dfu-programmer atmega16u2 flash dualMoco.hex

Después de reescribir, su Arduino será reconocido como un dispositivo MIDI.

Si cortocircuita el pin como se muestra en la imagen, será reconocido como Arduino normal.

De lo contrario (cuando no esté en cortocircuito), arduino UNO será reconocido como un dispositivo MIDI.

En otras palabras, al escribir código usando el IDE de arduino, debe cortocircuitar los pines como se muestra en la imagen.

Paso 10:Disparador a convertidor MIDI

Hay arduino UNO y shield en la caja.

Consulte la imagen de fritzing para ver el circuito del escudo.

Los diodos son para protección, pero vi la información de que arduino UNO tiene circuito de protección, los diodos pueden no ser necesarios. ¿Alguien sabe sobre esto?

Después de imprimir primero el modelo de la carcasa y la cubierta, es bueno hacer el escudo de acuerdo con ella.

También hay un modelo 3D de la portada, pero hice una portada con un cortador láser. Elija el que desee.

Paso 11:Juega con GarageBand

Simplemente inicie Garageband y conéctese. No existe un entorno particularmente difícil.

Hay una serie de DAW para PC que se pueden utilizar en esta batería, incluido GarageBand.

Entre ellos, Hydrogen es gratuito y puedes agregar sonido.

Paso 12:Configuración

Al hacer el código, era problemático reescribir el código cada vez que cambiaba el valor, así que quería poder cambiar el valor solo con arduino.

En otras palabras, esto está hecho para depurar código, por lo que hay elementos que no necesitan cambiarse.

Sin embargo, el ajuste es necesario según el tamaño del piezo, el tamaño de la almohadilla, la dureza de la esponja.

Seleccione un instrumento con el botón INC / DEC y seleccione el elemento de ajuste con el botón NEXT / BACK. Cuando se presiona el botón EDIT mientras se muestran los instrumentos y elementos que desea configurar, puede cambiar el valor con el botón INC / DEC. Luego, presionar el botón EDITAR nuevamente confirma el cambio.

Si ve la última parte del video, comprenderá cómo funciona.

UMBRAL

El valor más bajo al que sale el sonido

SENSIBILIDAD

Sensibilidad del sensor. Si lo bajas, ganarás alta velocidad incluso si golpeas suavemente.

NOTA

Número de la nota. Al cambiar, puede cambiar de instrumento. Consulte la imagen.

BANDERA

Un valor para juzgar que la paliza ha terminado. No tienes que cambiarlo demasiado. Sería bueno establecer el valor de 1 a 10. Si aumenta demasiado el valor, obtendrá un sonido dos veces con un solo golpe. Si lo baja demasiado, puede perder el sonido cuando golpea repetidamente.

TIEMPO DE ESCANEO

Al buscar picos, los valores se toman consecutivamente durante varios milisegundos después de superar el umbral. El valor más alto entre ellos alcanzará su punto máximo. Estos varios milisegundos son SCANTIME. No es necesario cambiarlo.

CABEZA / RIM

Establece la facilidad de la llanta. Levantarlo dificulta el sonido. Si lo baja con demasiada fuerza, el aro sonará cuando golpee la cabeza. En cuanto al juicio de la cabeza y el aro, puede ser necesario mejorar el código

PEDAL VELO

A diferencia de otros pads, la velocidad del pedal es constante. El valor inicial es 100. Cambie a su valor favorito.

TIEMPO DE MÁSCARA

Este es un valor relacionado con FLAG. No es necesario cambiarlo. Si lo levanta, es posible que no escuche un sonido cuando golpea continuamente.

Paso 13:Fusion 360

Es posible que algunas piezas no se puedan utilizar a menos que se modifiquen sus dimensiones. Es difícil editar datos STL. Así que cargué datos de Fusion 360. Sin embargo, dado que estoy editando datos a modo de prueba y error, es mejor no depender demasiado de la función de historial.

https://github.com/RyoKosaka/drums/tree/master/Fusion360

EXTRA

Los pasos adicionales están en los instructivos.

https://www.instructables.com/id/Arduino-Minimal-Drum-Kit/

Y, el proceso de producción detallado se publica en este blog.

Compruébalo si estás interesado.

No dude en preguntar cualquier cosa.

¡Diviértete!

Código

Hello Drum v2

Hola Drum v2 Arduino

Modificado:05/12/2019 por George Brotherston

 / * Drum MIDI Controller Creado:28/06/2017 por Ryo Kosaka como "HELLO DRUM" Ver.1.0 Modificado:05/12/2019 por George Brotherston * /// La biblioteca incluye // #include  // Biblioteca Arduino (incluida automáticamente) // LOW (línea 41) // HIGH (línea 40) // INPUT_PULLUP (línea 47) // digitalRead () (línea 177) / / analogRead () (Línea 178) #include  // Biblioteca MIDI - Versión:4.3.1 // incluye  // clase MIDI (Línea 30) // método de clase 'begin' (Línea 55) #include  // LiquidCrystal - Versión:1.0.7 // Objeto lcd instanciado (en la sección Variables a continuación) de la clase LiquidCrystal (Línea 45) // Variables - Declarar e inicializar // Variables - Programa booleano bSnareFlag =falso; booleano bHihatFlag =falso; booleano bKickFlag =falso; booleano bPedalFlag =falso; booleano bButtonState =true; booleano bButtonState_set =true; int iUPDOWN =0; int iNEXTBACK =0; // Arrays - Programa // InstrumentSensor [6] ={umbral, sensibilidad, nota, bandera, velocidad, iPeakValue} // 'iPeakValue' y 'velocidad' deben ser cero para todas las matrices InstrumentSensor // Todos los 'aHIHAT []' y Los elementos de la matriz 'aHIHAT_CLOSE []' deben tener el mismo valor, excepto el elemento 'nota'. int aSNARE [6] ={150, 950, 38, 3, 0, 0}; int aSNARE_RIM [6] ={5, 500, 37, 3, 0, 0}; int aHIHAT [6] ={100, 800, 46, 1, 0, 0}; int aHIHAT_CLOSE [6] ={100, 800, 42, 1, 0, 0}; int aKICK [6] ={200, 700, 36, 1, 0, 0}; // Instrument_ContinuousController [4] ={scantime, snare / rim, pedalVelocity, masktime} int aHIHAT_PEDAL [4] ={600, 0, 44, 0}; // InstrumentSensor_ParameterValue [4] ={umbral, sensibilidad, nota, bandera} int aSETTING [4] ={4, 500, 100, 1}; // Bibliotecas // LiquidCrystal.h // Constantes (ya definidas en la Biblioteca, ¿todavía están en el alcance? Si no, defina a continuación) // const int rs =12, en =11, d4 =5, d5 =4, d6 =3 , d7 =2; // objeto lcd instanciado de la clase LiquidCrystal (LiquidCrystal.h Línea 45) LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Asociar los pines de la interfaz LCD al número de pin de Arduino asociado // MIDI.h // Inicializar la biblioteca MIDI_CREATE_DEFAULT_INSTANCE (); // Código de programa // Ejecución del programa - Inicial (configuración del programa) void setup () {MIDI.begin (10); // comenzar (MIDI.h Línea 55) lcd.begin (16, 2); // begin (LiquidCrystal.h Line 62) lcd.print ("INICIALIZANDO ..."); // imprimir (LiquidCrystal.h Línea 45) lcd.setCursor (0, 1); // setCursor (LiquidCrystal.h Line 82) lcd.print ("CONTROLADOR MIDI DE BATERÍA"); pinMode (6, INPUT_PULLUP); // pinMode (Arduino.h Línea 175); INPUT_PULLUP (Arduino.h Línea 47) pinMode (7, INPUT_PULLUP); pinMode (8, INPUT_PULLUP); pinMode (9, INPUT_PULLUP); pinMode (10, INPUT_PULLUP); } // Ejecución del programa - Steadystate (bucle continuo hasta que se pierde la energía) void loop () {// Circuito controlador MIDI de batería // Declarar e inicializar variables int iButton_set =digitalRead (6); // Botón Establecer // digitalRead () (Arduino.h Línea 177) int iButton_up =digitalRead (7); // Botón Arriba int iButton_down =digitalRead (8); // Botón Abajo int iButton_next =digitalRead (9); // Botón Siguiente int iButton_back =digitalRead (10); // Botón de retroceso int iPiezoValue_A0 =analogRead (A0); // Piezo - Snare Head // analogRead () (Arduino.h Line 178) int iPiezoValue_A1 =analogRead (A1); // Piezo - Aro de caja int iPiezoValue_A2 =analogRead (A2); // Hi-hat int iPiezoValue_A3 =analogRead (A3); // Bombo int iFSRValue_A4 =analogRead (A4); // Pedal de charles // Modo de edición int aUP [4] ={5, 50, 1,1}; // {umbral, sensibilidad, nota, bandera} int aUP_ADVANCE [4] ={1, 50, 1,1}; // {scantime, rim / head, pedal velocity, masktime} // Nota:una matriz INSTRUMENT [] no fue declarada en 'Arrays' arriba de char * aINSTRUMENT [] ={"SNARE HEAD", "SNARE RIM", "HIHAT OPEN "," HIHAT CLOSE "," HIHAT PEDAL "," KICK "," AVANCED SETTING "}; // Nota:aSETTING [] array FUE declarado en 'Arrays' encima de char * aSETTING [] ={"UMBRAL", "SENSIBILIDAD", "NOTA", "BANDERA"}; // Nota:aSETTING_ADVANCE [] no se declaró en 'Arrays' por encima de char * aSETTING_ADVANCE [] ={"TIEMPO DE ESCANEO", "CABEZA / RIM", "PEDAL VELO", "TIEMPO DE MÁSCARA"}; si (iUPDOWN <0) {iUPDOWN =6; } si (iUPDOWN> 6) {iUPDOWN =0; } si (iNEXTBACK <0) {iNEXTBACK =3; } si (iNEXTBACK> 3) {iNEXTBACK =0; } // Pulsador EDITAR // BAJO (Arduino.h Línea 41) if (iButton_set ==LOW &&bButtonState ==true &&bButtonState_set ==true) {lcd.clear (); lcd.print ("EDITAR"); bButtonState =falso; bButtonState_set =falso; retraso (500); } if (iButton_set ==LOW &&bButtonState ==true &&bButtonState_set ==false) {lcd.clear (); lcd.print ("EDITAR HECHO"); bButtonState =falso; bButtonState_set =true; retraso (500); } if (iButton_up ==LOW &&bButtonState ==true &&bButtonState_set ==false) {switch (iUPDOWN) {caso 0:aSNARE [iNEXTBACK] =aSNARE [iNEXTBACK] + aUP [iNEXTBACK]; descanso; caso 1:aSNARE_RIM [iNEXTBACK] =aSNARE_RIM [iNEXTBACK] + aUP [iNEXTBACK]; descanso; caso 2:cambiar (iNEXTBACK) {caso 2:aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] + aUP [iNEXTBACK]; descanso; predeterminado:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] + aUP [iNEXTBACK]; aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] + aUP [iNEXTBACK]; } descanso; caso 3:cambiar (iNEXTBACK) {caso 2:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] + aUP [iNEXTBACK]; descanso; predeterminado:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] + aUP [iNEXTBACK]; aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] + aUP [iNEXTBACK]; } descanso; caso 4:cambiar (iNEXTBACK) {caso 0:aHIHAT_PEDAL [iNEXTBACK] =aHIHAT_PEDAL [iNEXTBACK] + aUP [iNEXTBACK]; descanso; caso 2:aHIHAT_PEDAL [iNEXTBACK] =aHIHAT_PEDAL [iNEXTBACK] + aUP [iNEXTBACK]; descanso; } descanso; caso 5:aKICK [iNEXTBACK] =aKICK [iNEXTBACK] + aUP [iNEXTBACK]; descanso; caso 6:aSETTING [iNEXTBACK] =aSETTING [iNEXTBACK] + aUP_ADVANCE [iNEXTBACK]; descanso; } bButtonState =falso; retraso (30); } if (iButton_down ==LOW &&bButtonState ==true &&bButtonState_set ==false) {cambiar (iUPDOWN) {caso 0:aSNARE [iNEXTBACK] =aSNARE [iNEXTBACK] - aUP [iNEXTBACK]; descanso; case 1:aSNARE_RIM[iNEXTBACK] =aSNARE_RIM[iNEXTBACK] - aUP[iNEXTBACK]; descanso; case 2:switch (iNEXTBACK) { case 2:aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] - aUP[iNEXTBACK]; descanso; default:aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK]; aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] - aUP[iNEXTBACK]; } descanso; case 3:switch (iNEXTBACK) { case 2:aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK]; descanso; default:aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK]; aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] - aUP[iNEXTBACK]; } descanso; case 4:switch (iNEXTBACK) { case 0:aHIHAT_PEDAL[iNEXTBACK] =aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK]; descanso; case 2:aHIHAT_PEDAL[iNEXTBACK] =aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK]; descanso; } descanso; case 5:aKICK[iNEXTBACK] =aKICK[iNEXTBACK] - aUP[iNEXTBACK]; descanso; case 6:aSETTING[iNEXTBACK] =aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK]; descanso; } bButtonState =false; delay(30); } // Pushbuttons UP; DOWN; NEXT; BACK if (iButton_up ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iUPDOWN =++iUPDOWN; bButtonState =false; delay(30); } if (iButton_down ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iUPDOWN =--iUPDOWN; bButtonState =false; delay(30); } if (iButton_next ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iNEXTBACK =++iNEXTBACK; bButtonState =false; delay(30); } if (iButton_back ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iNEXTBACK =--iNEXTBACK; bButtonState =false; delay(30); } if (bButtonState ==false &&iButton_up ==HIGH &&iButton_down ==HIGH &&iButton_next ==HIGH &&iButton_back ==HIGH &&iButton_set ==HIGH) { // HIGH is defined in Arduino.h Line 40 switch (iUPDOWN) { case 0:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aSNARE[iNEXTBACK]); descanso; case 1:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aSNARE_RIM[iNEXTBACK]); descanso; case 2:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT[iNEXTBACK]); descanso; case 3:lcd.clear();lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT_CLOSE[iNEXTBACK]); descanso; case 4:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT_PEDAL[iNEXTBACK]); descanso; case 5:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aKICK[iNEXTBACK]); descanso; case 6:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING_ADVANCE[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aSETTING[iNEXTBACK]); descanso; } bButtonState =true; } // Instrument Sensors // Snare Drum if (iPiezoValue_A0> aSNARE[0] &&bSnareFlag ==false) { for (int i =0; i  aSNARE[4]) { aSNARE[4] =iPeak_A0; } if (iPeak_A1> aSNARE_RIM[4]) { aSNARE_RIM[4] =iPeak_A1; } } aSNARE[5] =aSNARE[4]; aSNARE_RIM[5] =aSNARE_RIM[4]; aSNARE[4] =map(aSNARE[4], aSNARE[0], aSNARE[1], 0, 127); aSNARE_RIM[4] =map(aSNARE_RIM[4], aSNARE_RIM[0], aSNARE_RIM[1], 0, 127); aSNARE[4] =(aSNARE[4] * aSNARE[4]) / 127; // Curve setting //aSNARE_RIM[4] =(aSNARE_RIM[4] * aSNARE_RIM[4]) / 127; if (aSNARE[4] <=1) { aSNARE[4] =1; } if (aSNARE[4]> 127) { aSNARE[4] =127; } if (aSNARE_RIM[4] <=0) { aSNARE_RIM[4] =0; } if (aSNARE_RIM[4]> 127) { aSNARE_RIM[4] =127; } if (aSNARE_RIM[5]> aSETTING[1]) { MIDI.sendNoteOn(aSNARE_RIM[2], aSNARE_RIM[4], 1); //(note, velocity, channel) MIDI.sendNoteOn(aSNARE_RIM[2], 0, 1); lcd.clear(); lcd.print("SNARE RIM"); lcd.setCursor(0, 1); lcd.print(aSNARE_RIM[4]); bSnareFlag =true; } //else if (aSNARE[5]> aSNARE_RIM[5]) else { MIDI.sendNoteOn(aSNARE[2], aSNARE[4], 1); //(note, velocity, channel) MIDI.sendNoteOn(aSNARE[2], 0, 1); lcd.clear(); lcd.print("SNARE HEAD"); lcd.setCursor(0, 1); lcd.print(aSNARE[4]); //lcd.setCursor(10, 1); //lcd.print(aSNARE_RIM[5]); bSnareFlag =true; } } // Hi-Hat Cymbal if (iPiezoValue_A2> aHIHAT[0] &&bHihatFlag ==false) { for (int i =0; i  aHIHAT[4]) { aHIHAT[4] =iPeak_A2; } } aHIHAT[5] =aHIHAT[4]; aHIHAT[4] =map(aHIHAT[4], aHIHAT[0], aHIHAT[1], 0, 127); aHIHAT[4] =(aHIHAT[4] * aHIHAT[4]) / 127; if (aHIHAT[4] <=1) { aHIHAT[4] =1; } if (aHIHAT[4]> 127) { aHIHAT[4] =127; } if (iPiezoValue_A0 =aHIHAT_PEDAL[0]) { MIDI.sendNoteOn(aHIHAT_CLOSE[2], aHIHAT[4], 1); MIDI.sendNoteOn(aHIHAT_CLOSE[2], 0, 1); lcd.clear(); lcd.print("HIHAT CLOSE"); lcd.setCursor(0, 1); lcd.print(aHIHAT[4]); bHihatFlag =true; } } // Hi-hat Pedal if (iPiezoValue_A0> aHIHAT_PEDAL[0] &&bPedalFlag ==false) { MIDI.sendNoteOn(aHIHAT_PEDAL[2], aSETTING[2], 1); // (note, velocity, channel) MIDI.sendNoteOn(aHIHAT_PEDAL[2], 0, 1); lcd.clear(); lcd.print("HIHAT PEDAL"); lcd.setCursor(0, 1); lcd.print(aSETTING[2]); bPedalFlag =true; } // Kick Drum if (iPiezoValue_A3> aKICK[0] &&bKickFlag ==false) { for (int i =0; i  aKICK[4]) { aKICK[4] =iPeak_A3; } } aKICK[5] =aKICK[4]; aKICK[4] =map(aKICK[4], aKICK[0], aKICK[1], 0, 127); aKICK[4] =(aKICK[4] * aKICK[4]) / 127; if (aKICK[4] <=1) { aKICK[4] =1; } if (aKICK[4]> 127) { aKICK[4] =127; } MIDI.sendNoteOn(aKICK[2], aKICK[4], 1); MIDI.sendNoteOn(aKICK[2], 0, 1); lcd.clear(); lcd.print("KICK"); lcd.setCursor(0, 1); lcd.print(aKICK[4]); bKickFlag =true; }// --- BEGIN 'Code in Progress' --- //// --- I could be wrong, but this is what it appears to be --- and out of curiousity what is purpose of this sequence? -- // // I=(A0); // Previous Code // -- DOES iSensorValue_A0 need to be declared as an integer? How does this relate to iPiezoValue_A0? -- // if (iSensorValue_A0 <(aSNARE[5] * (0.01 * aSNARE[3]))) { bSnareFlag =false; } if (iPiezoValue_A0 <=aHIHAT_PEDAL[0] &&iPiezoValue_A2 <(aHIHAT[5] * (0.01 * aHIHAT[3])) &&bHihatFlag ==true) { delay(aSETTING[3]); // iSensorValue_A1 is reading analogRead(A2), but this is aHIHAT_PEDAL (which is analogRead(A2) int iSensorValue_A1 =analogRead(A2); if (iSensorValue_A1 <(aHIHAT[5] * (0.01 * aHIHAT[3]))) { bHihatFlag =false; } } if (iPiezoValue_A0>=aHIHAT_PEDAL[0] &&iPiezoValue_A2 <(aHIHAT[5] *(0.01 * aHIHAT[3])) &&bHihatFlag ==true) { delay(aSETTING[3]); int iSensorValue_A2 =analogRead(A2); if (iSensorValue_A2 <(aHIHAT[5] * (0.01 * aHIHAT[3]))) { bHihatFlag =false; } } if (iPiezoValue_A3 <(aKICK[5] * (0.01 * aKICK[3])) &&bKickFlag ==true) { delay(aSETTING[3]); // -- Should declared iSensorValue_A3 be iPiezoValue_A3? iSensorValue_A3 is declared but not used anywhere?? int iSensorValue_A3 =analogRead(A3); if (iPiezoValue_A3 <(aKICK[5] * (0.01 * aKICK[3]))) { bKickFlag =false; } } if (iPiezoValue_A0 <=aHIHAT_PEDAL[0] &&bPedalFlag ==true) { bPedalFlag =false; }// --- END 'Code in Progress' --- // }

Hello Drum

Esquemas

circuit_nZotR7rJMM.fzz

Registrador de datos de globos meteorológicos con tecnología Arduino Cómo leer la temperatura y la humedad en Blynk con DHT11

Proceso de manufactura

Impresión 3d

Sistema de control de automatización

Tecnología Industrial