Piano portátil de toque capacitivo
Componentes e suprimentos
 |
| × | 1 | |||
| × | 1 | ||||
| × | 1 | ||||
 |
| × | 1 | |||
| × | 1 | ||||
 |
| × | 1 |
Sobre este projeto
Neste projeto, explico como construir um piano de toque capacitivo portátil com
- um Arduino,
- um Touch Shield capacitivo para Arduino usando o MPR121,
- uma campainha piezoelétrica,
- fita de folha de cobre com adesivo condutor (cortado na forma de teclas de piano),
todos colocados em um gabinete de acrílico transparente (ProtoStax para Arduino) com as teclas de toque capacitivas presas em sua superfície superior. Isso o torna um pequeno piano agradável que você pode tocar, tocar e codificar novas melodias!
Para o sensor de toque capacitivo, eu uso 12 x Capacitive Touch Shield para Arduino da Adafruit usando o MPR121, junto com a biblioteca Adafruit_MPR121 que torna mais fácil detectar e responder a toques em até 12 superfícies condutoras diferentes.
Espere um minuto! Existem 12 semitons em uma oitava - dó, dó #, ré, ré #, mi, mi #, fá, sol, sol #, lá, lá #, b! Perfeito! Bem, teria sido ótimo se o MPR121 suportasse 13 entradas - teria nos permitido ir de C para C da oitava superior, mas ainda há muitas músicas disponíveis! (e também ofereço sugestões abaixo sobre como você pode levar este projeto adiante, expandindo a faixa de oitavas)
Além disso, você também pode programar em suas próprias sequências de toque ("Chaves Secretas" ou combinações de teclas) para tocar quaisquer melodias aleatórias que podem incluir quantas oitavas você quiser (limitado apenas pela capacidade de seu ouvido para ouvir as notas, ou seu piezo / alto-falante para reproduzi-lo!).
Para a saída, uso a biblioteca de tons do Arduino para reproduzir o som por meio de uma campainha Piezo. Você também pode usar um alto-falante - lembre-se de usar um resistor com ele para restringir a corrente àquela que pode ser fornecida pelo pino do Arduino!
Para as teclas do piano, uso fita de folha de cobre com adesivo condutor. É importante obtê-lo com adesivo condutor, pois você vai colar a fita no fio que está conectado à blindagem.
Por último, vem o gabinete. Alguns de vocês devem estar cientes de que criei um novo sistema de gabinete empilhável e modular chamado ProtoStax. Foi uma coceira pessoal que tive que coçar - eu queria um gabinete que suportasse diferentes estágios de prototipagem, oferecendo proteção e acesso aberto no início, com a capacidade de adicionar paredes laterais e o topo depois, mas também com a capacidade de empilhar unidades múltiplas, lado a lado ou uma em cima da outra, com a capacidade de se expandir com as necessidades de prototipagem e adição de outras placas e componentes.
Neste exemplo, eu uso ProtoStax para Arduino, um gabinete de acrílico transparente para o Arduino - ele se encaixa tanto na pegada Uno / Leonardo quanto na pegada Mega / Due maior - que também é empilhável e modular e tem espaço confortável para os dois Escudos (com algumas pequenas modificações, que irei delinear). É claro e robusto e também possui pés de borracha para elevá-lo um pouco e proteger a superfície da mesa. A superfície superior da caixa também atua como o teclado do seu piano de toque - é aqui que você vai colar sua fita de folha de cobre condutora! No final, você terá um belo piano de toque que pode facilmente carregar e exibir e tocar junto! 😊
Ok, vamos começar, vamos? 😊
Etapa 1 - Monte o Arduino na placa de base do gabinete
Vamos primeiro montar o Arduino (Uno em nosso exemplo) na placa de base do gabinete. Isso oferece proteção ao mesmo tempo em que oferece acesso aberto total a ele para configurar e configurar o Arduino e brincar com ele. Quando você estiver pronto para fechá-lo, é fácil adicionar as paredes laterais e a placa superior e prender tudo com parafusos.
Monte o Arduino na placa de base e adicione pés e outro hardware para preparar o gabinete em Configuração da plataforma . Veja as etapas abaixo na apresentação de slides - a legenda de cada imagem é numerada e fornece uma explicação adicional para cada etapa.
Aqui estão todas as etapas como um GIF animado:
Etapa 2 - Prepare o escudo MPR121 para o Arduino
Cortei no comprimento 12 pedaços de fio trançado 22 AWG. Em seguida, os soldei no escudo MPR121. O Escudo Adafruit tem dois orifícios grandes para cada uma das 12 entradas para agarrar com pinças de crocodilo. Entre esses dois orifícios está um regular menor que acomodará um fio 22 AWG.
O escudo MPR121 também expõe todos os pinos por meio de orifícios próximos aos cabeçalhos. Também soldei em um Piezo Buzzer PS1240, com uma perna inserida no pino 12 e a outra no GND.
Tive a certeza de descascar a outra extremidade (livre) de cada um dos fios. Usei um padrão de repetição de 6 cores diferentes para as 12 entradas, para codificá-las por cores, para que a ordem pudesse ser mantida mais tarde na montagem.
Etapa 3 - Prepare o gabinete
Em seguida, precisamos preparar o gabinete. Começamos inserindo a blindagem no Arduino montado na placa base. Em seguida, inserimos os elementos de reforço superiores e as paredes laterais nas ranhuras da parede.
Peguei a parte superior padrão do gabinete ProtoStax para Arduino e adicionei 12 orifícios para inserir os fios das entradas de blindagem. Usei um cortador a laser para cortar os orifícios correspondentes ao modelo de tecla de piano, mas você pode usar uma furadeira com a mesma facilidade (apenas certifique-se de usar um pouco de fita adesiva na placa de acrílico antes de perfurar). Um pequeno orifício de 1/8 "deve ser suficiente.
Em seguida, insiro cuidadosamente os fios da blindagem nos orifícios da placa superior - certifique-se de inserir o fio do orifício 0 até o orifício mais à esquerda e insiro progressivamente os fios numerados (eles são numerados na blindagem) nos orifícios da esquerda para a direita. Em seguida, adiciono os espaçadores superiores abaixo da placa superior e aparafuso a parte superior do parafuso para completar o gabinete.
Em seguida, empurro os fios até que apenas as partes metálicas fiquem para fora.
Em seguida, recortei pedaços de um rolo de folha de cobre com adesivo condutor no formato das teclas de piano do modelo (veja o modelo abaixo). Em seguida, descasco cuidadosamente a folha de cobre e colo-as em suas respectivas posições na placa superior do gabinete, certificando-me de que a fita de cobre cole sobre o fio correspondente que sai do orifício.
Aqui está o modelo para as teclas do piano e os orifícios. Você deve conseguir imprimir em papel Carta 8,5 x 11 e ter o tamanho correto (avise-me se estiver tendo problemas!)
No final, fica assim:(eu poderia ter feito um trabalho melhor com a fita de folha de cobre, mas esta foi a primeira vez que a usei, então espero que eu melhore no manuseio no futuro! 😊)
Etapa 4 - Código de demonstração
Primeiro, você precisará instalar a biblioteca Adafruit_MPR121. Depois disso, você pode compilar e fazer upload do esboço de exemplo, que transforma sua criação em um piano de toque, e inclui combinações de teclas secretas para tocar alguns jingles.
- Pressione C E G B para tocar "Twinkle Twinkle Little Stars"
- Pressione C D E F G para tocar em escala para cima e para baixo
- Pressione C D A B para tocar "Oh Susanna!"
- Pressione C # A # B para tocar "Frere Jacques / Brother John"
Também tornei mais fácil para você transcrever sua (s) própria (s) música (ões) de sua escolha a partir da partitura de sua música.
Se você estiver interessado em ler mais sobre o código (e eu sei que você está!), Continue lendo!
Vamos examinar rapidamente as partes principais do código. Você pode consultar rapidamente o código de demonstração aqui - https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo/blob/master/ProtoStax_CapacitiveTouch_Piano_Demo.ino
O código pode ser dividido em 3 partes:
- Obtendo dados de toque do MPR121 usando a biblioteca Adafruit_MRP121.
- Decidir o que fazer com os dados de toque - ou seja, tocar o tom correspondente como um piano ou detectar multi-toques e, em seguida, tocar o jingle secreto, ambos usando a biblioteca de tons integrada.
- Programação de melodias, incluindo como adicionar suas próprias melodias
Aqui está uma rápida olhada na parte do toque capacitivo do código. Como normalmente é o caso, você declara um objeto da classe Adafruit_MPR121. Em setup (), você chama o método begin () para inicializá-lo e pode obter os pads tocados atualmente em loop () usando o método cap.touched (). Simples!
Adafruit_MPR121 cap =Adafruit_MPR121 (); void setup () {... // O endereço padrão é 0x5A, se vinculado a 3,3 V é 0x5B // Se vinculado a SDA é 0x5C e se SCL, então 0x5D se ( ! cap.begin (0x5A)) {Serial.println ("MPR121 não encontrado, verificar a fiação?"); enquanto (1); } ...} void loop () {// Obter os pads tocados atualmente currtouched =cap.touched ();} Com os dados de toque, você pode responder a um toque reproduzindo o tom correspondente e parando o tom quando o botão não está sendo pressionado:
// se * foi * tocado e * não foi * tocado antes, toque o tom correspondente! if ((currtouched &_BV (i)) &&! (lasttouched &_BV (i))) {// Serial.print ("currtouched ="); Serial.print (currtouched); Serial.print ("lasttouched ="); Serial.print (tocado pela última vez); Serial.print (""); Serial.print (i); Serial.println ("tocado"); tom (TONE_PIN, escala [i]); } // se * foi * tocado e agora * não é *, e adicionalmente, nenhum botão está sendo pressionado, então pare o tom // Isso permite transições suaves entre as notas conforme você desliza o dedo sobre as teclas // Isso também permite para a sustentação de uma determinada nota, tocando em qualquer tecla e mantendo-a pressionada - você pode pressionar outra tecla e ele a tocará, mas não para de tocá-la // até que você solte a primeira tecla - mais ou menos como o sustentar o pedal do piano! if (! (currtouched &_BV (i)) &&(lasttouched &_BV (i)) &&! currtouched) {// if (! (currtouched &_BV (i)) &&(lasttouched &_BV (i))) {/ / Serial.print ("currtouched ="); Serial.print (currtouched); Serial.print ("lasttouched ="); Serial.print (tocado pela última vez); Serial.print (""); Serial.print (i); Serial.println ("lançado"); noTone (TONE_PIN); }
Lidamos com vários toques de teclas especiais tocando a melodia correspondente:
// Toque músicas se nossa combinação 'secreta' de teclas for pressionada! if (currtouched ==2193) {// C E G B playTune (melody, MELODY_LENGTH (melody), 2); // Toca Twinkle Twinkle Little Star} else if (currtouched ==181) {// C D E F G playTune (melody2, MELODY_LENGTH (melody2), 48); // Toca o slide de escala para cima e para baixo} else if (currtouched ==2565) {// C D A B playTune (melody3, MELODY_LENGTH (melody3), 1); // Toque Oh Susanna! } else if (currtouched ==3075) {// playTune C # A # B C # (melody4, MELODY_LENGTH (melody4), 1); // Tocar Frere Jacques} else {... playTune () é usado para tocar uma melodia, que é uma série de "notas"
void playTune (Nota * m, int mSize, int speedUp) {noTone (TONE_PIN); // Comece com uma folha em branco para (int thisNote =0; thisNote Vamos dar uma olhada em uma melodia - ela consiste em uma série de notas. Cada nota tem uma frequência e uma duração. =
typedef struct Nota {frequência interna; duração da flutuação; } Observação; // Esta melodia está tocando todas as notas da oitava de C até B e de volta para CNote melody2 [] ={{NOTE_C, NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_D, NOTE_WHOLE}, {NOTE_DS, NOTE_WHOLE} , {NOTE_E, NOTE_WHOLE}, {NOTE_F, NOTE_WHOLE}, {NOTE_FS, NOTE_WHOLE}, {NOTE_G, NOTE_WHOLE}, {NOTE_GS, NOTE_WHOLE}, {NOTE_A, NOTE_WHOLE}, {NOTE_AS, NOTE_WHOLE}, {NOTE_B, NOTE_WHOLE}, { NOTE_AS, NOTE_WHOLE}, {NOTE_A, NOTE_WHOLE}, {NOTE_GS, NOTE_WHOLE}, {NOTE_G, NOTE_WHOLE}, {NOTE_FS, NOTE_WHOLE}, {NOTE_F, NOTE_WHOLE}, {NOTE_E, NOTE_WHOLE}, {NOTE_DS, NOTE_WHOLE}, {NOTE_DS, NOTE_WHOLE}, NOTE_WHOLE}, {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}}; É aqui que # define em pitches.he noteDurations.h é útil. Você pode usá-los em vez das frequências e durações reais. Por exemplo, use NOTE_C para tocar um tom C e use NOTE_WHOLE para tocá-lo como uma nota inteira (NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH são algumas outras durações de nota). Você também pode usar a macro DOTTED () para especificar uma nota "pontilhada" - como DOTTED (NOTE_QUARTER).
[Nota:Uma nota pontilhada é uma nota cuja duração é estendida por outra nota de metade de sua duração - por exemplo, uma meia nota pontilhada é equivalente a 3/4 de uma nota inteira (1/2 nota mais 1/2 de 1/2 nota). ]
Isso permitirá que você pegue qualquer partitura e transcreva-a para sua matriz melódica!
Na demo, transcrevi "Twinkle Twinkle Little Star", "Frere Jacques / Brother John" e "Oh Susanna!" então você tem algo para brincar (sem trocadilhos ?! 😜) - todas essas músicas cabem em uma oitava, que é a restrição do nosso teclado que tentei seguir. É claro que, ao tocar uma música secreta, você não está sujeito a esse limite e pode usar várias oitavas. "Oh Susanna!" também é um pouco mais complexo, usando semínimas, semínimas e colcheias e também semínimas e semínimas "pontilhadas" - espero que isso ajude você a ter uma boa noção de como transcrever outras músicas facilmente.
Vamos vê-lo em ação, certo? 😊
Etapa 5 - Indo além!
Aqui estão algumas ideias para levar o projeto ainda mais longe!
1. Crie seus próprios jingles / melodias (ou transcreva os existentes) e atribua suas próprias "Chaves Secretas" para ativá-los!
2. Adicione um segundo Piezo para obter sons polifônicos de 2 níveis! A biblioteca de tons usa Timer2 para enviar uma onda quadrada para a campainha piezoelétrica para reproduzir um tom. O Arduino Uno tem 3 temporizadores, embora o temporizador 0 seja especial e usado para coisas como millis () e pwm. Isso ainda nos deixa Timer1 para usar. A biblioteca NewTone é uma reescrita mais otimizada da biblioteca de tons, que usa Timer1. Você pode, portanto, ter dois tons ao mesmo tempo, um usando tom e outro usando NewTone, por exemplo.
3. Adicione um botão extra ou dois para adicionar funcionalidade adicional - como usar o botão pressionado para estender a oitava para a mais alta ou mais baixa. Ao pressionar esses botões em conjunto com suas teclas de toque capacitivas, você pode ter um alcance maior em seu teclado!
Você consegue pensar em mais alguma coisa? Escreva um comentário abaixo para nos avisar! 😊 Sinta-se à vontade para fazer qualquer pergunta que você possa ter! 😊
Feliz fabricação! 😊
Código
ProtoStax_CapacitiveTouch_Piano_Demo
Demonstração para ProtoStax Piano com ProtoStax para Arduino Enclosure, Adafruit 12 x Capacitive Touch Shield para Arduino - MPR121, Piezo Buzzer e Arduino https://github.com/protostax/ProtoStax_CapacitiveTouch_Piano_Demo.gitPeças personalizadas e gabinetes
Modelo para cortar teclas de piano para ProtoStax Capacitive Touch Piano e para fazer furos na placa superior
Esquemas
Processo de manufatura