Construa um Piano Portátil de Toque Capacitivo com Arduino – Guia Passo a Passo

Componentes e Materiais

• Gabinete ProtoStax para Arduino (1 unidade)
• Shield Capacitivo Adafruit 12x para Arduino - MPR121 (1 unidade)
• Buzzer Piezo Adafruit PS1240 (1 unidade)
• Arduino UNO (1 unidade)
• Fita de Cobre com Adesivo Condutivo (1 unidade)
• Kit Fios de Conexão 22 AWG (1 unidade)

Sobre o Projeto

Neste projeto, explico como construir um piano portátil de toque capacitivo com:

• um Arduino,
• um Shield Capacitivo para Arduino usando o MPR121,
• um buzzer piezo,
• fita de cobre com adesivo condutivo (cortada no formato de teclas de piano),

tudo encerrado em um gabinete acrílico transparente (ProtoStax para Arduino) com as teclas capacitivas coladas na superfície superior. Resulta em um piano compacto para levar e tocar, além de programar novas músicas!

Para detecção de toque capacitivo, uso o Adafruit 12x Capacitive Touch Shield com MPR121, junto com a biblioteca Adafruit_MPR121 que facilita detectar e responder toques em até 12 superfícies condutivas diferentes.

Espere! Existem 12 semitons em uma oitava - C, C#, D, D#, E, F, F#, G, G#, A, A#, B. Perfeito! Seria ótimo se o MPR121 tivesse 13 entradas para ir do C ao C da oitava superior, mas ainda há muitas músicas possíveis! (Abaixo sugiro como expandir a faixa de oitavas).

Além disso, você pode programar suas próprias sequências de toque ("Chaves Secretas" ou combinações) para tocar músicas aleatórias com quantas oitavas quiser (limitado apenas pelo seu ouvido ou pelo piezo/alto-falante).

Para saída, uso a biblioteca tone do Arduino para tocar som no buzzer piezo. Também pode usar alto-falante – lembre-se de usar resistor para limitar a corrente ao que o pino do Arduino fornece.

Para as teclas, uso fita de cobre com adesivo condutivo. É importante que tenha adesivo condutivo pois você colará a fita no fio conectado ao shield.

Por fim, o gabinete. Alguns sabem que criei um sistema de gabinetes empilháveis e modulares chamado ProtoStax. Era uma necessidade pessoal: queria um gabinete que suportasse diferentes estágios de prototipagem, oferecendo proteção e acesso aberto no início, com capacidade de adicionar paredes laterais e tampa depois, além de empilhar múltiplas unidades lado a lado ou uma sobre a outra, expandindo com as necessidades.

Uso o ProtoStax para Arduino, gabinete acrílico transparente para Arduino – compatível com Uno/Leonardo e Mega/Due – empilhável, modular, com pés de borracha para elevar e proteger a mesa. A tampa superior atua como teclado do piano touch – onde você cola a fita de cobre condutiva! No final, terá um piano touch portátil para carregar, exibir e tocar! 😊

Passo 1 - Monte o Arduino na Base do Gabinete

Primeiro, monte o Arduino (Uno no exemplo) na base do gabinete. Isso dá proteção com acesso total para configurar. Quando pronto para fechar, adicione paredes laterais e tampa superior e prenda com parafusos.

Monte o Arduino na base, adicione pés e hardware para configuração Platform Configuration. Veja passos no slideshow (legendas numeradas explicam cada passo).

Passo 2 - Prepare o Shield MPR121 para o Arduino

Cortei 12 pedaços de fio 22 AWG e soldei no Shield MPR121. O shield Adafruit tem dois furos grandes por entrada para garras jacaré, e um menor entre eles para fio 22 AWG.

O shield também expõe todos os pinos via furos próximos aos headers. Soldei também o Buzzer Piezo PS1240, uma perna no pino 12 e outra no GND.

Descasquei as pontas livres dos fios. Usei padrão de 6 cores repetidas para 12 entradas, colorindo para manter ordem na montagem.

Passo 3 - Prepare o Gabinete

Insira o shield no Arduino na base. Adicione elementos de reforço superiores e paredes laterais nos slots.

Modifiquei a tampa original do ProtoStax adicionando 12 furos para passar os fios das entradas do shield. Usei cortadora a laser para furos no modelo de teclas, mas pode usar furadeira (use fita adesiva no acrílico antes). Furo de 1/8" é suficiente.

Insira cuidadosamente os fios do shield nos furos da tampa – fio do canal 0 no furo mais à esquerda, progressivamente até canal 11 à direita. Adicione espaçadores superiores abaixo da tampa e parafuse para fechar.

Empurre os fios para trás até que apenas as partes metálicas fiquem para fora.

Corte pedaços da fita de cobre condutivo no formato de teclas de piano (veja modelo abaixo). Cole cuidadosamente nas posições correspondentes na tampa, garantindo que a fita cubra o fio que sobressai do furo.

Modelo para teclas de piano e furos (imprima em papel A4/Letter tamanho real):

Resultado final (poderia melhorar a aplicação da fita, era minha primeira vez! 😊):

Passo 4 - Código de Demonstração

Primeiro instale a biblioteca Adafruit_MPR121. Depois compile e carregue o sketch de exemplo, que transforma sua criação em piano touch, com combinações secretas para tocar jingles.

Combinações Secretas:

• Pressione C E G B → "Twinkle Twinkle Little Stars"
• Pressione C D E F G → Escala subindo e descendo
• Pressione C D A B → "Oh Susanna!"
• Pressione C C# A# B → "Frere Jacques/Brother John"

Também facilitei transcrever suas próprias músicas da partitura.

Estrutura do Código (3 partes):

1. Obter dados de toque do MPR121 via biblioteca Adafruit_MPR121.
2. Decidir o que fazer: tocar tom correspondente como piano, ou detectar multi-toques e tocar jingle secreto – ambos usando biblioteca tone nativa.
3. Programar músicas, incluindo como adicionar as suas.

Parte Capacitiva do Código:

Adafruit_MPR121 cap = Adafruit_MPR121();

void setup() {
  // Endereço padrão 0x5A, se ligado a 3.3V é 0x5B, SDA 0x5C, SCL 0x5D
  if (!cap.begin(0x5A)) {
    Serial.println("MPR121 not found, check wiring?");
    while (1);
  }
}

void loop() {
  currtouched = cap.touched();
  
  // Se tocado e não estava tocado antes, toque o tom correspondente!
  if ((currtouched & _BV(i)) && !(lasttouched & _BV(i))) {
    tone(TONE_PIN, scale[i]);
  }
  
  // Se estava tocado e agora não está, e nenhum botão pressionado, pare o tom
  // Permite transições suaves deslizando o dedo nas teclas
  // Permite sustain de uma nota: toque uma tecla e mantenha, pressione outra e tocará, mas não para até soltar a primeira – como pedal sustain!
  if (!(currtouched & _BV(i)) && (lasttouched & _BV(i)) && !currtouched) {
    noTone(TONE_PIN);
  }
}

Tratamento de Multi-toques para Músicas Secretas:

if (currtouched == 2193) { // C E G B
  playTune(melody, MELODY_LENGTH(melody), 2); // Twinkle Twinkle
}
else if (currtouched == 181) { // C D E F G
  playTune(melody2, MELODY_LENGTH(melody2), 48); // Escala
}
else if (currtouched == 2565) { // C D A B
  playTune(melody3, MELODY_LENGTH(melody3), 1); // Oh Susanna!
}
else if (currtouched == 3075) { // C C# A# B
  playTune(melody4, MELODY_LENGTH(melody4), 1); // Frere Jacques
}

Função playTune():

void playTune(Note *m, int mSize, int speedUp) {
  noTone(TONE_PIN);
  for (int thisNote = 0; thisNote < mSize; thisNote++) {
    int noteDuration = 1000.0 * m[thisNote].duration / speedUp;
    tone(TONE_PIN, m[thisNote].frequency, noteDuration);
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    noTone(TONE_PIN);
  }
  delay(100);
}

Estrutura de Nota e Exemplo de Melodia:

typedef struct Note {
  int frequency;
  float duration;
} Note;

Note 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_D, NOTE_WHOLE},
  {NOTE_CS, NOTE_WHOLE}, {NOTE_C, NOTE_WHOLE}
};

Use pitches.h e noteDurations.h para frequências e durações (NOTE_C, NOTE_WHOLE, NOTE_HALF, NOTE_QUARTER, NOTE_EIGHTH, DOTTED()). Isso permite transcrever qualquer partitura para seu array de melodia!

No demo, transcrevi "Twinkle Twinkle Little Star", "Frere Jacques" e "Oh Susanna!" – todas cabem em uma oitava. "Oh Susanna!" usa notas pontuadas, ótimo para aprender.

Passo 5 - Levando Mais Longe!

Ideias para expandir:

1. Crie seus próprios jingles/músicas e atribua "Chaves Secretas" para ativá-los!
2. Adicione segundo Piezo para sons polifônicos de 2 níveis! A biblioteca tone usa Timer2. Arduino Uno tem 3 timers (Timer0 especial para millis()/PWM). Timer1 livre. Biblioteca NewTone é reescrita otimizada usando Timer1. Pode ter dois tons simultâneos: um com tone, outro com NewTone.
3. Adicione botões extras para funcionalidades – ex: estender oitava para cima/baixo. Pressionando botões junto com teclas capacitivas, amplia a faixa do teclado!

Pensou em mais? Comente abaixo! Perguntas são bem-vindas! 😊

Feliz criação! 😊

Código

ProtoStax_CapacitiveTouch_Piano_Demo

Demo para Piano ProtoStax com Gabinete ProtoStax, Shield Adafruit MPR121, Buzzer Piezo e Arduino
GitHub

Peças Personalizadas e Gabinetes

Modelo para cortar teclas de piano e furar a tampa superior:

Esquemático

Diagrama de conexões: