Kit de bateria MIDI mínimo com impressora 3D

Componentes e suprimentos

Arduino UNO

Adafruit LCD padrão - 16x2 branco em azul

SparkFun Piezo

Adafruit Force Sensitive Resistor (FSR)

Resistor 10k ohm

Resistor 1M ohm

SparkFun Zener Diode - 5.1V 1W

SparkFun Botão de pressão 12 mm

Slide Switch

Soquete TRS

Cabo USB-A para B

Adaptador Apple Lightning para câmera USB

Ferramentas e máquinas necessárias

Impressora 3D (genérica)

Cortador a laser (genérico)

não necessário, extra

Ferro de soldar (genérico)

cortador de círculo

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Oi.

Este é um kit de bateria mínimo usando o arduino UNO.

Em primeiro lugar, verifique esta página de instruções.

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

Desde que comecei a fazer isso, fui cativado por piezo e bateria eletrônica.

Fiquei fascinado por um mecanismo muito simples de bateria eletrônica e pela grande invenção chamada MIDI.

Em outras palavras, eu não poderia me contentar apenas em fazer absorventes.

Este kit de bateria é dividido em duas produções.

1.Pad feito com impressora 3d e papel grosso.

2.Trigger conversor de midi com arduino UNO.

O sinal enviado do pad de "1" é processado pelo arduino de "2" e convertido em sinal MIDI. E o sinal MIDI é transmitido do Arduino para o iPhone, laptop, etc, e o som é emitido.

Você não precisa preparar uma fonte de alimentação diferente de um smartphone ou PC.

O que você precisa

Ferramentas

·impressora 3d

・ Cortador a laser (extra)

・ Chave hexagonal

・ Faca de corte

・ Cortador de círculo

·Ferro de solda

・ Cortador de Tubos

・ Furadeira

・ Broca 9mm / 10mm

Material

・ Papel de 1 mm de espessura

・ Filamento PLA

・ Folhas de espuma esponjosa 5mm / 10mm

・ MDF 2,5 mm / 5,5 mm (Extra)

・ M6 - parafuso e porcas de 70 mm

・ M6 - parafuso e porcas de 50 mm

・ M3 - parafuso e porcas de 10 mm

・ M3 - parafuso e porcas de 15 mm

・ M3 - parafuso e porcas de 25 mm

・ Parafuso M2

・ Tubo de aço inoxidável de 13 mm de diâmetro

Hardware de bateria

・ Cabeça de malha de 10 polegadas / 8 polegadas

・ Suporte de caixa (tudo está OK. Estou usando YAMAHA SS662.)

・ Suporte de chimbal (tudo está OK. Estou usando YAMAHA HS650A)

・ Pedal de chute (tudo está OK. Estou usando YAMAHA FP7210A)

·Baqueta

Etapa 1:impressão 3D

Todos os dados estão no Thingiverse e no GitHub.

Use a Ver.2 para o aro.

Imprimi peças com preenchimento a 20%. A espessura da camada é de 0,3 mm.

Além disso, você pode usar o cortador a laser para fazer bloco.

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

Etapa 2:montagem

Use parafusos e porcas M3-10 mm para conectar as peças.

Use os parafusos M3-15 mm ou M3-25 mm para a parte central para fixar a parte inferior entre si.

Etapa 3:Fazendo Shell

Em primeiro lugar, a altura da concha é de 55 mm.

Faça três bandas com largura de 55 mm.

O comprimento é ligeiramente maior do que o comprimento que cobre a almofada.

Como há uma lacuna na parte inferior, tente inserir uma faixa nessa lacuna.

Corte a faixa de modo que tenha um comprimento de círculo perfeito.

Repita 3 vezes e cubra com adesivo.

Quando a casca secar, com a cabeça de malha fixada, faça um orifício de 9 mm de diâmetro para o alvéolo.

Você pode usar porcas borboleta, mas eu também fiz chaves de afinação que podem ser apertadas mesmo com porcas comuns, então, por favor, use-as de todas as maneiras.

Para fixar a cabeça de malha, use parafusos M6-70 mm.

Depois de fazer um furo, remova a cabeça de malha novamente para colocar um piezo

Etapa 4:anexando o piezo

SNARE

No caso de uma caixa, use dois piezoelétricos conforme mostrado na imagem.

Conecte o cabo vermelho do piezo a cada ponta e anel.

Ambos os cabos pretos se conectam à manga.

Não se esqueça de passar os cabos pelos orifícios da placa do sensor ao soldar.

O piezo para a cabeça (piezo conectado à ponta) precisa ser imprensado com uma esponja de espuma de 10 mm de espessura, conforme mostrado na imagem.

Um abaixo, três no topo. E faça os 3 cones principais como a imagem.

Em seguida, coloque-o na placa do sensor.

KICK

Uma vez que o bloco de chute usa apenas um piezo, apenas a ponta pode ser usada.

Nenhuma placa de sensor é necessária. Duas espumas de esponja sob o piezo

Coloque o sensor deslocado do centro.

É porque o Arduino não pode julgar a força do golpe se o batedor atingir o sensor diretamente.

HI-HAT

O circuito é igual ao pad de bumbo.

Coloque um pedaço de esponja de 10 mm de espessura sob o piezo.

Piezo é delicado. Tenha cuidado para não dobrar ou se machucar.

Etapa 5:almofada de caixa de 10 polegadas

Primeiro, conecte o sensor ao aro.

Fixe a placa do sensor. Corrija-o com firmeza. Faça a extremidade do cone visível 2-3 mm quando visto de lado.

Obviamente, o mesmo procedimento também é usado ao usar um bloco de 20 polegadas como uma caixa.

Etapa 6:Kick PAD de 8 polegadas

Primeiro, corte um tubo de aço inoxidável de 13 mm de diâmetro.

Faça dois 200 mm e dois 365 mm.

Uma vez que o comprimento pode ser ajustado, mesmo se houver algum erro no comprimento, está tudo bem.

Monte-os com referência às imagens.

Para a fixação do tubo, ele é projetado de forma que a porca M3 possa ser carregada no interior da peça.

Fixe o tubo com segurança. Use parafusos e porcas M3-15 mm.

Etapa 7:chimbal de 12 polegadas

Depois de fazer a concha com papel grosso, pensei que se usar papel grosso posso fazer pratos.

Primeiro. Corte o papel grosso em um círculo com um diâmetro de 300 mm. Faça três deste.

Em seguida, faça um entalhe no centro.

Finalmente, um segundo entalhe é feito a partir do ponto separado 10 mm paralelo ao primeiro entalhe.

Desta forma, são feitos três pac-man com uma boquinha aberta.

Em seguida, feche a boca do Pac Man cuidadosamente com fita adesiva para torná-la um prato.

Aplique o adesivo e cubra-os. Não se esqueça de estender o adesivo de maneira limpa e fina

Segure firmemente com as mãos, coloque o peso ao redor e seque.

Para silenciar, coloque uma esponja de 5 mm de espessura e faça um furo. Você não pode abrir o buraco perfeitamente, mas pode esconder o buraco para que esteja tudo bem.

Conclua anexando a montagem do sensor e a guia do cabo com fita dupla-face. Pode ser mais fácil se você usar uma pistola de cola.

Etapa 8:controlador de chimbal

O controlador do chimbal envia a abertura e o fechamento do chimbal para o arduino.

O circuito é muito simples.

É feito pela combinação de três partes.

Fixe o FSR na parte inferior e fixe o soquete. FSR pode ser usado mesmo se um orifício for aberto.

Anexe uma esponja de 10 mm ao FSR como uma foto.

Fixe a tampa com parafusos M3 - 10 mm.

Mesmo que seja apenas ALTO e BAIXO, você pode se perguntar por que usei FSR.

Eu uso FSR para corresponder a módulos de som como Roland e Yamaha.

E na fonte sonora exclusiva para bateria como EZ DRUMMER 2, existem vários estágios no grau de abertura do chimbal.

Se for FSR, pode ser possível responder apenas modificando o código. No entanto, ainda não tentei.

Etapa 9:USB - MIDI

O que podemos fazer nesta etapa?

Com o cabo USB sozinho, você pode enviar sinal midi do Arduino.

Em outras palavras, faça com que o arduino seja reconhecido pelo iPhone etc. como um dispositivo midi sem nenhum hardware adicional.

Em primeiro lugar, verifique esta página.

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

https://github.com/kuwatay/mocolufa

Se você conectar o arduino UNO normal diretamente ao iPhone, receberá uma mensagem de erro como "Arduino UNO não é compatível".

Então, você tem que reescrever o chip USB (ATmega16U2) usado no arduino UNO.

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

Esta instrução mostra como reescrever o arquivo hexadecimal.

Proceda de acordo com este site até a descrição abaixo.

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

Basta substituir "Arduino-usbserial-uno.hex" por "dualMoco.hex".

Portanto,

sudo dfu-programmer atmega16u2 flash dualMoco.hex

Após a reescrita, seu Arduino será reconhecido como um dispositivo MIDI.

Se você curto-circuitar o pino conforme mostrado na imagem, ele será reconhecido como Arduino normal.

Do contrário (quando não estiver em curto-circuito), o arduino UNO será reconhecido como um dispositivo MIDI.

Em outras palavras, ao escrever o código usando o IDE arduino, você deve curto-circuitar os pinos conforme mostrado na imagem.

Etapa 10:acionar o conversor de MIDI

Há arduino UNO e escudo na caixa.

Consulte a imagem de fritagem para o circuito da blindagem.

Diodos são para proteção, mas vi a informação de que o arduino UNO tem circuito de proteção, diodos podem não ser necessários. Alguém sabe sobre isso?

Depois de imprimir primeiro o modelo da caixa e a capa, é bom fazer a blindagem de acordo com ela.

Também existe um modelo 3D da capa, mas fiz uma capa com um cortador a laser. Escolha o que você quiser.

Etapa 11:brincar com o GarageBand

Basta iniciar o garageband e conectar. Não existe um cenário particularmente difícil.

Existem vários DAWs para PCs que podem ser usados neste conjunto de bateria, incluindo o GarageBand.

Entre eles, o hidrogênio é gratuito e você pode adicionar som.

Etapa 12:Configuração

Ao fazer o código, era difícil reescrever o código cada vez que o valor mudava, então eu queria poder mudar o valor apenas com o arduino.

Em outras palavras, isso é feito para código de depuração, portanto, há itens que não precisam ser alterados.

No entanto, a configuração é necessária dependendo do tamanho do piezo, do tamanho da almofada, da dureza da espuma esponjosa.

Selecione um instrumento com o botão INC / DEC e selecione o item de configuração com o botão NEXT / BACK. Quando o botão EDIT é pressionado enquanto os instrumentos e itens que você deseja configurar são exibidos, você pode alterar o valor com o botão INC / DEC. Em seguida, pressionar o botão EDIT novamente confirma a alteração.

Se você assistir à última parte do vídeo, entenderá como operar.

LIMIAR

O menor valor em que o som é emitido

SENSIBILIDADE

Sensibilidade do sensor. Se você abaixá-lo, você ganhará alta velocidade, mesmo se bater suavemente.

NOTA

Número da nota. Ao mudar, você pode mudar os instrumentos. Por favor, consulte a imagem.

BANDEIRA

Um valor para julgar que a surra acabou. Você não precisa mudar muito. Seria bom definir o valor de 1 a 10. Se você aumentar muito o valor, obterá um som duas vezes com um único toque. Se você baixá-lo muito, poderá perder o som ao bater repetidamente.

TEMPO DE VARREDURA

Na busca por picos, os valores são tomados consecutivamente por vários milissegundos após exceder o limite. O valor mais alto entre eles atingirá o pico. Vários milissegundos são SCANTIME. Não há necessidade de alterá-lo.

HEAD / RIM

Defina a facilidade do aro. Aumentar torna difícil o som. Se você abaixá-lo com muita força, o aro soará quando você bater na cabeça. Em relação ao julgamento da cabeça e do aro, pode ser necessário melhorar o código

PEDAL VELO

Ao contrário de outros pads, a velocidade do pedal é constante. O valor inicial é 100. Mude para o seu valor favorito.

TEMPO DE MÁSCARA

Este é um valor relacionado ao FLAG. Não há necessidade de alterá-lo. Se você aumentá-lo, poderá não ouvir um som ao bater continuamente.

Etapa 13:Fusion 360

Algumas peças podem não ser utilizáveis, a menos que suas dimensões sejam alteradas. É difícil editar dados STL. Então eu carreguei os dados do Fusion 360. No entanto, como estou editando dados durante a tentativa e erro, é melhor não depender muito da função de histórico.

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

EXTRA

Etapas extras estão em instructables.

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

E o processo de produção detalhado está publicado neste blog.

Verifique se você está interessado.

Sinta-se à vontade para perguntar qualquer coisa.

Divirta-se!

Código

Hello Drum v2

Hello Drum v2 Arduino

Modificado:12/05/2019 por George Brotherston

 / * Drum MIDI Controller Criado:28/06/2017 por Ryo Kosaka como "HELLO DRUM" Ver.1.0 Modificado:12/05/2019 por George Brotherston * /// Biblioteca Inclui // #include  // Biblioteca Arduino (incluída automaticamente) // LOW (Linha 41) // HIGH (Linha 40) // INPUT_PULLUP (Linha 47) // digitalRead () (Linha 177) / / analogRead () (Linha 178) #include  // Biblioteca MIDI - Versão:4.3.1 // inclui  // classe MIDI (Linha 30) // método de classe 'begin' (Line 55) #include  // LiquidCrystal - Versão:1.0.7 // objeto lcd instanciado (na seção Variáveis abaixo) da classe LiquidCrystal (Linha 45) // Variáveis - Declarar e inicializar // Variáveis - Programa booleano bSnareFlag =falso; booleano bHihatFlag =false; booleano bKickFlag =false; boolean bPedalFlag =false; boolean bButtonState =true; boolean bButtonState_set =true; int iUPDOWN =0; int iNEXTBACK =0; // Matrizes - Programa // InstrumentSensor [6] ={limiar, sensibilidade, nota, sinalização, velocidade, iPeakValue} // 'iPeakValue' e 'velocidade' devem ser zero para todas as matrizes InstrumentSensor // Todos 'aHIHAT []' e Os elementos da matriz 'aHIHAT_CLOSE []' devem ter o mesmo valor, exceto para o 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] ={limite, sensibilidade, nota, sinalizador} int aSETTING [4] ={4, 500, 100, 1}; // Bibliotecas // LiquidCrystal.h // Constantes (já definidas na Biblioteca, ainda no escopo? Se não, defina abaixo) // const int rs =12, en =11, d4 =5, d5 =4, d6 =3 , d7 =2; // objeto lcd instanciado da classe LiquidCrystal (LiquidCrystal.h Linha 45) LiquidCrystal lcd (rs, en, d4, d5, d6, d7); // Associar os pinos da interface LCD ao número do pino Arduino associado // MIDI.h // Inicializar a biblioteca MIDI_CREATE_DEFAULT_INSTANCE (); // Código do Programa // Execução do Programa - Inicial (configuração do programa) void setup () {MIDI.begin (10); // begin (MIDI.h Line 55) lcd.begin (16, 2); // begin (LiquidCrystal.h Line 62) lcd.print ("INITIALIZING ..."); // imprimir (LiquidCrystal.h Linha 45) lcd.setCursor (0, 1); // setCursor (LiquidCrystal.h Line 82) lcd.print ("DRUM MIDI CONTROLLER"); pinMode (6, INPUT_PULLUP); // pinMode (Arduino.h Line 175); INPUT_PULLUP (Arduino.h Linha 47) pinMode (7, INPUT_PULLUP); pinMode (8, INPUT_PULLUP); pinMode (9, INPUT_PULLUP); pinMode (10, INPUT_PULLUP); } // Execução do programa - Steadystate (loop contínuo até que a energia seja perdida) void loop () {// Circuito controlador MIDI de bateria // Declara e inicializa variáveis int iButton_set =digitalRead (6); // Botão Set // digitalRead () (Arduino.h Linha 177) int iButton_up =digitalRead (7); // Botão para cima int iButton_down =digitalRead (8); // Botão para baixo int iButton_next =digitalRead (9); // Botão Próximo int iButton_back =digitalRead (10); // Botão Voltar int iPiezoValue_A0 =analogRead (A0); // Piezo - Snare Head // analogRead () (Arduino.h Linha 178) int iPiezoValue_A1 =analogRead (A1); // Piezo - Snare Rim int iPiezoValue_A2 =analogRead (A2); // Chimbal int iPiezoValue_A3 =analogRead (A3); // Kick Drum int iFSRValue_A4 =analogRead (A4); // Pedal de chimbal // Modo de edição int aUP [4] ={5, 50, 1,1}; // {limite, sensibilidade, nota, sinalizador} int aUP_ADVANCE [4] ={1, 50, 1,1}; // {scantime, rim / head, pedal velocity, masktime} // Observação:a matriz aINSTRUMENT [] não foi declarada em 'Arrays' acima de char * aINSTRUMENT [] ={"SNARE HEAD", "SNARE RIM", "HIHAT OPEN "," HIHAT CLOSE "," HIHAT PEDAL "," KICK "," ADVANCED SETTING "}; // Nota:o array aSETTING [] foi declarado em 'Arrays' acima char * aSETTING [] ={"THRESHOLD", "SENSITIVITY", "NOTE", "FLAG"}; // Nota:aSETTING_ADVANCE [] não foi declarado em 'Arrays' acima char * aSETTING_ADVANCE [] ={"SCAN TIME", "HEAD / RIM", "PEDAL VELO", "MASK TIME"}; se (iUPDOWN <0) {iUPDOWN =6; } se (iUPDOWN> 6) {iUPDOWN =0; } if (iNEXTBACK <0) {iNEXTBACK =3; } if (iNEXTBACK> 3) {iNEXTBACK =0; } // Botão EDITAR // LOW (Arduino.h Linha 41) if (iButton_set ==LOW &&bButtonState ==true &&bButtonState_set ==true) {lcd.clear (); lcd.print ("EDITAR"); bButtonState =false; bButtonState_set =false; atraso (500); } if (iButton_set ==LOW &&bButtonState ==true &&bButtonState_set ==false) {lcd.clear (); lcd.print ("EDITAR FEITO"); bButtonState =false; bButtonState_set =true; atraso (500); } if (iButton_up ==LOW &&bButtonState ==true &&bButtonState_set ==false) {switch (iUPDOWN) {case 0:aSNARE [iNEXTBACK] =aSNARE [iNEXTBACK] + aUP [iNEXTBACK]; pausa; caso 1:aSNARE_RIM [iNEXTBACK] =aSNARE_RIM [iNEXTBACK] + aUP [iNEXTBACK]; pausa; caso 2:switch (iNEXTBACK) {case 2:aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] + aUP [iNEXTBACK]; pausa; padrão:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] + aUP [iNEXTBACK]; aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] + aUP [iNEXTBACK]; } pausa; caso 3:switch (iNEXTBACK) {case 2:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] + aUP [iNEXTBACK]; pausa; padrão:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] + aUP [iNEXTBACK]; aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] + aUP [iNEXTBACK]; } pausa; caso 4:switch (iNEXTBACK) {case 0:aHIHAT_PEDAL [iNEXTBACK] =aHIHAT_PEDAL [iNEXTBACK] + aUP [iNEXTBACK]; pausa; caso 2:aHIHAT_PEDAL [iNEXTBACK] =aHIHAT_PEDAL [iNEXTBACK] + aUP [iNEXTBACK]; pausa; } pausa; caso 5:aKICK [iNEXTBACK] =aKICK [iNEXTBACK] + aUP [iNEXTBACK]; pausa; caso 6:aSETTING [iNEXTBACK] =aSETTING [iNEXTBACK] + aUP_ADVANCE [iNEXTBACK]; pausa; } bButtonState =false; atraso (30); } if (iButton_down ==LOW &&bButtonState ==true &&bButtonState_set ==false) {switch (iUPDOWN) {case 0:aSNARE [iNEXTBACK] =aSNARE [iNEXTBACK] - aUP [iNEXTBACK]; pausa; caso 1:aSNARE_RIM [iNEXTBACK] =aSNARE_RIM [iNEXTBACK] - aUP [iNEXTBACK]; pausa; caso 2:switch (iNEXTBACK) {case 2:aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] - aUP [iNEXTBACK]; pausa; padrão:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] - aUP [iNEXTBACK]; aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] - aUP [iNEXTBACK]; } pausa; caso 3:switch (iNEXTBACK) {case 2:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] - aUP [iNEXTBACK]; pausa; padrão:aHIHAT_CLOSE [iNEXTBACK] =aHIHAT_CLOSE [iNEXTBACK] - aUP [iNEXTBACK]; aHIHAT [iNEXTBACK] =aHIHAT [iNEXTBACK] - aUP [iNEXTBACK]; } pausa; caso 4:switch (iNEXTBACK) {case 0:aHIHAT_PEDAL [iNEXTBACK] =aHIHAT_PEDAL [iNEXTBACK] - aUP [iNEXTBACK]; pausa; caso 2:aHIHAT_PEDAL [iNEXTBACK] =aHIHAT_PEDAL [iNEXTBACK] - aUP [iNEXTBACK]; pausa; } pausa; case 5:aKICK[iNEXTBACK] =aKICK[iNEXTBACK] - aUP[iNEXTBACK]; pausa; case 6:aSETTING[iNEXTBACK] =aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK]; pausa; } 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]); pausa; 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]); pausa; case 2:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor (0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT[iNEXTBACK]); pausa; 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]); pausa; 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]); pausa; case 5:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor (0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aKICK[iNEXTBACK]); pausa; 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]); pausa; } 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 dados do balão meteorológico Arduino Como ler a temperatura e umidade em Blynk com DHT11

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial