Pelúcia Musical

Pelúcia Musical com Sensor de Toque

Que tal transformar uma pelúcia comum em uma pequena caixa musical interativa?

Neste projeto vamos utilizar uma BlackBoard Edge H, um buzzer passivo, um LED e um sensor de toque capacitivo construído com um resistor de 1 M?(1 megaohm) e uma superfície metálica utilizada como eletrodo.

Diferentemente de um botăo convencional, o sensor năo precisa possuir nenhuma peça mecânica aparente. O eletrodo pode ficar escondido atrás do tecido da pelúcia e, quando essa regiăo for tocada, o ESP32 detectará a alteraçăo provocada pela proximidade do dedo.

A cada novo toque, o buzzer toca uma única nota musical e o LED acende durante a execuçăo dessa nota. Ao soltar e tocar novamente, o programa avança para a próxima nota da música.

Lista de materiais

1x BlackBoard Edge H
1x Buzzer Passivo 5 V
1x LED 5 mm
1x Kit Resistor 500
1x resistor de 1 M? para o sensor capacitivo
1x resistor de 230? para o LED (ou 220? utilizando o Kit Resistor 500)
1x Mini Protoboard 170 Pontos
1x conjunto de Jumpers Macho-Fęmea
1x pequena superfície metálica para funcionar como eletrodo
1x pelúcia

Como funciona o sensor de toque

O sensor utilizado neste projeto é construído utilizando dois GPIOs da BlackBoard Edge H, um resistor de 1 M? e um eletrodo metálico.

O GPIO 13 funciona como SEND, enviando o sinal elétrico, enquanto o GPIO 14 funciona como RECEIVE.

O programa mede o tempo que o circuito leva para mudar o estado do pino RECEIVE. Quando uma pessoa toca no eletrodo, a capacitância do conjunto é alterada e consequentemente o tempo medido também muda.

Durante a inicializaçăo, o programa aprende automaticamente os valores correspondentes ao sensor livre e ao sensor tocado.

Importante frizar que nesse caso nao estou considerando uma bateria ligada ao Edge, e sim um cabo UBS que ficaria ligado nele o tempo todo. inclusive quando gravar o codigo pela primeira vez, teste a calibraçăo. Ela ocorre no incio da ativacao do codigo e voce pode acompanhar as orientaçőes pelo terminal.

Mapa completo das ligaçőes

GPIO 13 -> SEND do sensor capacitivo
GPIO 14 -> RECEIVE e eletrodo do sensor
GPIO 27 -> LED com resistor de 230? ou 220?
GPIO 4 -> Buzzer passivo

Mapa de ligaçőes da Pelúcia Musical — Mapeamento das ligaçőes da Pelúcia Musical

O resistor de 1 M? é instalado entre os GPIOs 13 e 14. O eletrodo utilizado como área de toque também é conectado ao GPIO 14.

Calibraçăo automática

Sempre que a BlackBoard Edge H é ligada, o programa realiza uma calibraçăo automática do sensor.

Inicialmente o sistema aguarda 3 segundos, permitindo que o Monitor Serial seja aberto.

Durante a primeira etapa será exibida a mensagem:

NAO TOQUE NO SENSOR

Durante 5 segundos o programa mede o comportamento do sensor sem nenhum contato.

Ao terminar essa etapa, o LED pisca tręs vezes.

Depois será exibida:

AGORA TOQUE NO SENSOR

O usuário deve tocar no eletrodo e manter o dedo durante os 3 segundos da mediçăo.

Durante todo o processo de calibraçăo o buzzer permanece desligado.

Funcionamento

Depois da calibraçăo, o programa aguarda 3 segundos e toca duas notas, indicando que o jogo musical está pronto.

Cada novo toque executa somente uma nota.

TOCAR -> toca uma nota e acende o LED

SOLTAR

TOCAR -> toca a próxima nota e acende o LED

Manter o dedo sobre o sensor năo faz com que várias notas sejam executadas. É necessário soltar e tocar novamente.

Depois de cada nota existem 10 segundos para realizar o próximo toque.

Caso esse tempo seja ultrapassado, o buzzer reproduz um som de erro e o jogo é interrompido.

Para reiniciar, mantenha o sensor tocado durante 3 segundos. O LED piscará tręs vezes. Depois, solte o sensor. O sistema tocará novamente as duas notas de início e voltará para a primeira nota da música.

Código

Carregue o código abaixo na BlackBoard Edge H utilizando a Arduino IDE.

Abra o Monitor Serial em 115200 baud para acompanhar o mapeamento dos pinos, a calibraçăo, os valores do sensor, as notas executadas e o estado atual do jogo.

/*******************************************************************************
 * PROJETO: SENSOR CAPACITIVO MUSICAL - ESP32
 *
 * MUSICA: CAI, CAI, BALAO
 *
 * Feito por: Alexandre Ferreira
 * by Clio
 *
 * ============================================================================
 * OBJETIVO
 * ============================================================================
 *
 * Utilizar um sensor capacitivo como uma "tecla musical".
 *
 * Cada novo toque no sensor:
 *
 *   -> toca UMA nota da musica;
 *   -> acende o LED durante a nota;
 *   -> depois espera o aluno soltar o sensor;
 *   -> um novo toque toca a proxima nota.
 *
 *
 * ============================================================================
 * SEQUENCIA AO LIGAR
 * ============================================================================
 *
 * 1. ESP32 liga.
 *
 * 2. Aguarda 3 segundos.
 *
 * 3. CALIBRACAO SEM TOQUE:
 *
 *      NAO TOCAR NO SENSOR
 *
 *      durante 5 segundos.
 *
 * 4. LED pisca 3 vezes.
 *
 * 5. CALIBRACAO COM TOQUE:
 *
 *      TOCAR E MANTER O DEDO
 *
 *      durante 3 segundos.
 *
 * 6. Calibracao terminada.
 *
 * 7. Aguarda 3 segundos.
 *
 * 8. Toca DUAS notas da musica indicando:
 *
 *      JOGO INICIADO
 *
 *
 * IMPORTANTE:
 *
 * Durante TODA a calibracao:
 *
 *      BUZZER = DESLIGADO
 *
 *
 * ============================================================================
 * DURANTE O JOGO
 * ============================================================================
 *
 * Cada toque:
 *
 *      LED acende
 *      +
 *      BUZZER toca UMA nota
 *
 * depois:
 *
 *      LED apaga
 *      +
 *      BUZZER para
 *
 *
 * Manter o dedo encostado NAO toca varias notas.
 *
 * E necessario:
 *
 *      TOCAR
 *        |
 *      SOLTAR
 *        |
 *      TOCAR
 *
 * para avancar para a proxima nota.
 *
 *
 * ============================================================================
 * TEMPO LIMITE
 * ============================================================================
 *
 * Depois de cada nota o aluno tem:
 *
 *      10 segundos
 *
 * para tocar novamente.
 *
 * Se passar esse tempo:
 *
 *      -> toca SOM DE ERRO;
 *      -> jogo para;
 *      -> musica para.
 *
 *
 * ============================================================================
 * COMO REINICIAR DEPOIS DO ERRO
 * ============================================================================
 *
 * O aluno deve:
 *
 *      TOCAR
 *        |
 *        v
 *      MANTER POR 3 SEGUNDOS
 *        |
 *        v
 *      LED PISCA 3 VEZES
 *        |
 *        v
 *      SOLTAR O SENSOR
 *        |
 *        v
 *      TOCA 2 NOTAS DE AVISO
 *        |
 *        v
 *      JOGO REINICIA
 *
 *
 * As duas notas de aviso NAO contam como notas da musica.
 *
 * A primeira nota real da musica somente sera tocada
 * quando o aluno tocar novamente.
 *
 *
 * ============================================================================
 * FILTRO DO SENSOR
 * ============================================================================
 *
 * Cada leitura utilizada pelo programa e formada pela MEDIA
 * de 5 pequenas amostras.
 *
 * Alem disso, para confirmar que o dedo foi retirado:
 *
 *      precisamos de 5 leituras consecutivas SEM TOQUE.
 *
 * Isso evita falsos negativos.
 *
 *
 * ============================================================================
 * MAPEAMENTO DE PINOS
 * ============================================================================
 *
 * GPIO 13 -> SEND
 * GPIO 14 -> RECEIVE / ELETRODO
 * GPIO 27 -> LED
 * GPIO  4 -> BUZZER PASSIVO
 *
 * SENSOR:
 *
 * GPIO 13
 *    |
 *   1 MOhm
 *    |
 *    +---------- GPIO 14
 *    |
 * ELETRODO
 *
 * LED:
 *
 * GPIO 27 -> resistor -> LED -> GND
 *
 * BUZZER PASSIVO:
 *
 * GPIO 4 -> positivo do buzzer
 * GND    -> negativo do buzzer
 *
 *******************************************************************************/


// ============================================================================
// 1. PINOS
// ============================================================================

const uint8_t SEND_PIN    = 13;
const uint8_t RECEIVE_PIN = 14;
const uint8_t LED_PIN     = 27;
const uint8_t BUZZER_PIN  = 4;


// ============================================================================
// 2. CONFIGURACOES DO SENSOR
// ============================================================================

const uint8_t AMOSTRAS_POR_LEITURA = 5;

const uint8_t LEITURAS_PARA_CONFIRMAR_SOLTURA = 5;

const unsigned long TEMPO_SEM_TOQUE = 5000;

const unsigned long TEMPO_COM_TOQUE = 3000;

const unsigned long TIMEOUT_SENSOR_US = 5000;


// ============================================================================
// 3. CONFIGURACOES DO JOGO
// ============================================================================

const unsigned long TEMPO_LIMITE_JOGO = 10000;

const unsigned long TEMPO_TOQUE_REINICIO = 3000;

const unsigned long DURACAO_NOTA = 300;

const unsigned long INTERVALO_NOTAS_AVISO = 120;

const uint8_t QUANTIDADE_PISCADAS = 3;

const unsigned long TEMPO_PISCADA = 200;


// ============================================================================
// 4. NOTAS MUSICAIS
// ============================================================================

const uint16_t NOTA_DO4  = 262;
const uint16_t NOTA_RE4  = 294;
const uint16_t NOTA_MI4  = 330;
const uint16_t NOTA_FA4  = 349;
const uint16_t NOTA_SOL4 = 392;
const uint16_t NOTA_LA4  = 440;


// ============================================================================
// 5. MUSICA - CAI, CAI, BALAO
// ============================================================================

const uint16_t musica[] = {

  NOTA_SOL4,
  NOTA_SOL4,
  NOTA_FA4,
  NOTA_MI4,

  NOTA_SOL4,
  NOTA_SOL4,
  NOTA_FA4,
  NOTA_MI4,

  NOTA_SOL4,
  NOTA_LA4,
  NOTA_SOL4,
  NOTA_FA4,
  NOTA_MI4,
  NOTA_RE4,

  NOTA_RE4,
  NOTA_MI4,
  NOTA_FA4,

  NOTA_RE4,
  NOTA_MI4,
  NOTA_FA4,

  NOTA_RE4,
  NOTA_MI4,
  NOTA_FA4,

  NOTA_SOL4,
  NOTA_LA4,
  NOTA_SOL4,
  NOTA_FA4,
  NOTA_MI4,
  NOTA_RE4,
  NOTA_DO4
};


const char *nomeNotas[] = {

  "SOL",
  "SOL",
  "FA",
  "MI",

  "SOL",
  "SOL",
  "FA",
  "MI",

  "SOL",
  "LA",
  "SOL",
  "FA",
  "MI",
  "RE",

  "RE",
  "MI",
  "FA",

  "RE",
  "MI",
  "FA",

  "RE",
  "MI",
  "FA",

  "SOL",
  "LA",
  "SOL",
  "FA",
  "MI",
  "RE",
  "DO"
};


const uint8_t TOTAL_NOTAS =
  sizeof(musica) / sizeof(musica[0]);


// ============================================================================
// 6. ESTADOS DO JOGO
// ============================================================================

enum EstadoJogo {

  JOGANDO,

  ERRO_AGUARDANDO_3_SEGUNDOS,

  ERRO_AGUARDANDO_SOLTAR
};


EstadoJogo estadoJogo = JOGANDO;


// ============================================================================
// 7. VARIAVEIS DO SENSOR
// ============================================================================

unsigned long valorSensor = 0;

unsigned long valorSemToque = 0;

unsigned long valorComToque = 0;

unsigned long limiar = 0;

bool toqueAumentaValor = true;

bool sensorTocado = false;

bool sensorTocadoAnterior = false;

uint8_t contadorSemToque = 0;


// ============================================================================
// 8. VARIAVEIS DA MUSICA
// ============================================================================

uint8_t indiceNota = 0;

unsigned long momentoUltimaNota = 0;


// ============================================================================
// 9. VARIAVEIS DO REINICIO
// ============================================================================

unsigned long inicioToqueReinicio = 0;

bool contandoReinicio = false;


// ============================================================================
// 10. MONITOR SERIAL
// ============================================================================

unsigned long ultimoSerial = 0;

const unsigned long INTERVALO_SERIAL = 250;


// ============================================================================
// 11. SETUP
// ============================================================================

void setup() {

  pinMode(SEND_PIN, OUTPUT);

  pinMode(RECEIVE_PIN, INPUT);

  pinMode(LED_PIN, OUTPUT);

  pinMode(BUZZER_PIN, OUTPUT);


  digitalWrite(SEND_PIN, LOW);

  digitalWrite(LED_PIN, LOW);

  noTone(BUZZER_PIN);


  Serial.begin(115200);


  /*
   * Damos 3 segundos antes de qualquer calibracao.
   *
   * Isso permite abrir o Monitor Serial.
   */

  delay(3000);


  Serial.println();

  Serial.println("==================================================");

  Serial.println(" SENSOR CAPACITIVO MUSICAL - ESP32");

  Serial.println("==================================================");

  Serial.println();

  Serial.println("Feito por Alexandre Ferreira");

  Serial.println("by Clio");

  Serial.println();

  Serial.println("MAPEAMENTO DE PINOS:");

  Serial.println();

  Serial.println("GPIO 13 -> SEND");

  Serial.println("GPIO 14 -> RECEIVE / ELETRODO");

  Serial.println("GPIO 27 -> LED");

  Serial.println("GPIO  4 -> BUZZER PASSIVO");

  Serial.println();

  Serial.println("Musica: Cai, Cai, Balao");

  Serial.println();

  Serial.println("==================================================");


  calibrarSensor();


  Serial.println();

  Serial.println("Calibracao terminada.");

  Serial.println();

  Serial.println("O jogo iniciara em 3 segundos...");


  noTone(BUZZER_PIN);

  digitalWrite(LED_PIN, LOW);


  delay(3000);


  tocarAvisoInicio();


  indiceNota = 0;

  estadoJogo = JOGANDO;

  momentoUltimaNota = millis();


  Serial.println();

  Serial.println("==================================================");

  Serial.println(" JOGO INICIADO!");

  Serial.println("==================================================");

  Serial.println();

  Serial.println("Cada toque toca UMA nota.");

  Serial.println();

  Serial.println("Voce possui 10 segundos para o proximo toque.");

  Serial.println();
}


// ============================================================================
// 12. LOOP PRINCIPAL
// ============================================================================

void loop() {

  sensorTocadoAnterior = sensorTocado;


  valorSensor =
    lerSensorCapacitivo(AMOSTRAS_POR_LEITURA);


  bool leituraBrutaToque =
    verificarToque(valorSensor);


  atualizarEstadoSensor(leituraBrutaToque);


  bool novoToque =
    (!sensorTocadoAnterior && sensorTocado);


  bool sensorSoltou =
    (sensorTocadoAnterior && !sensorTocado);


  // --------------------------------------------------------------------------
  // JOGO NORMAL
  // --------------------------------------------------------------------------

  if (estadoJogo == JOGANDO) {

    if (novoToque) {

      tocarProximaNota();
    }


    if ((millis() - momentoUltimaNota) >= TEMPO_LIMITE_JOGO) {

      entrarEstadoErro();
    }
  }


  // --------------------------------------------------------------------------
  // ERRO - ESPERA TOQUE DE 3 SEGUNDOS
  // --------------------------------------------------------------------------

  else if (estadoJogo == ERRO_AGUARDANDO_3_SEGUNDOS) {

    if (sensorTocado) {

      if (!contandoReinicio) {

        contandoReinicio = true;

        inicioToqueReinicio = millis();


        Serial.println();

        Serial.println("Toque detectado.");

        Serial.println("Mantenha por 3 segundos para reiniciar.");
      }


      if ((millis() - inicioToqueReinicio) >= TEMPO_TOQUE_REINICIO) {

        contandoReinicio = false;


        Serial.println();

        Serial.println("==================================================");

        Serial.println(" REINICIO CONFIRMADO");

        Serial.println("==================================================");

        Serial.println();

        Serial.println("LED piscara 3 vezes.");

        Serial.println();

        Serial.println("Depois SOLTE o sensor.");


        piscarLed(3);


        estadoJogo = ERRO_AGUARDANDO_SOLTAR;
      }
    }


    else {

      if (contandoReinicio) {

        contandoReinicio = false;


        Serial.println();

        Serial.println("Toque menor que 3 segundos.");

        Serial.println("Reinicio cancelado.");
      }
    }
  }


  // --------------------------------------------------------------------------
  // REINICIO CONFIRMADO - ESPERA SOLTAR
  // --------------------------------------------------------------------------

  else if (estadoJogo == ERRO_AGUARDANDO_SOLTAR) {

    if (sensorSoltou || !sensorTocado) {

      Serial.println();

      Serial.println("Sensor liberado.");

      Serial.println();

      Serial.println("Reiniciando jogo...");


      tocarAvisoInicio();


      indiceNota = 0;


      estadoJogo = JOGANDO;


      momentoUltimaNota = millis();


      Serial.println();

      Serial.println("==================================================");

      Serial.println(" JOGO REINICIADO!");

      Serial.println("==================================================");

      Serial.println();

      Serial.println("Toque novamente para tocar a primeira nota.");

      Serial.println();
    }
  }


  mostrarMonitorSerial();
}


// ============================================================================
// 13. ATUALIZAR ESTADO FILTRADO DO SENSOR
// ============================================================================

void atualizarEstadoSensor(bool leituraIndicaToque) {

  if (!sensorTocado) {

    if (leituraIndicaToque) {

      sensorTocado = true;

      contadorSemToque = 0;
    }
  }


  else {

    if (leituraIndicaToque) {

      contadorSemToque = 0;
    }


    else {

      contadorSemToque++;


      if (contadorSemToque >= LEITURAS_PARA_CONFIRMAR_SOLTURA) {

        sensorTocado = false;

        contadorSemToque = 0;
      }
    }
  }
}


// ============================================================================
// 14. TOCAR PROXIMA NOTA DA MUSICA
// ============================================================================

void tocarProximaNota() {

  uint16_t frequencia = musica[indiceNota];


  Serial.println();

  Serial.println("--------------------------------------------");

  Serial.print("Nota ");

  Serial.print(indiceNota + 1);

  Serial.print("/");

  Serial.print(TOTAL_NOTAS);

  Serial.print(" -> ");

  Serial.print(nomeNotas[indiceNota]);

  Serial.print(" - ");

  Serial.print(frequencia);

  Serial.println(" Hz");


  digitalWrite(LED_PIN, HIGH);


  tone(BUZZER_PIN, frequencia);


  delay(DURACAO_NOTA);


  noTone(BUZZER_PIN);


  digitalWrite(LED_PIN, LOW);


  indiceNota++;


  if (indiceNota >= TOTAL_NOTAS) {

    indiceNota = 0;


    Serial.println();

    Serial.println("MUSICA CONCLUIDA.");

    Serial.println("O proximo toque inicia a musica novamente.");
  }


  momentoUltimaNota = millis();
}


// ============================================================================
// 15. AVISO SONORO DE INICIO
// ============================================================================

void tocarAvisoInicio() {

  Serial.println();

  Serial.println("AVISO SONORO: jogo pronto.");


  tocarNotaAviso(musica[0]);


  delay(INTERVALO_NOTAS_AVISO);


  tocarNotaAviso(musica[1]);
}


// ============================================================================
// 16. TOCAR UMA NOTA DE AVISO
// ============================================================================

void tocarNotaAviso(uint16_t frequencia) {

  digitalWrite(LED_PIN, HIGH);


  tone(BUZZER_PIN, frequencia);


  delay(DURACAO_NOTA);


  noTone(BUZZER_PIN);


  digitalWrite(LED_PIN, LOW);
}


// ============================================================================
// 17. ENTRAR NO ESTADO DE ERRO
// ============================================================================

void entrarEstadoErro() {

  noTone(BUZZER_PIN);

  digitalWrite(LED_PIN, LOW);


  estadoJogo = ERRO_AGUARDANDO_3_SEGUNDOS;

  contandoReinicio = false;


  Serial.println();

  Serial.println("==================================================");

  Serial.println(" ERRO - TEMPO ESGOTADO");

  Serial.println("==================================================");

  Serial.println();

  Serial.println("Passaram 10 segundos sem um novo toque.");

  Serial.println();

  Serial.println("JOGO PARADO.");

  Serial.println();


  tocarSomErro();


  Serial.println();

  Serial.println("PARA REINICIAR:");

  Serial.println();

  Serial.println("Toque no sensor e mantenha por 3 segundos.");

  Serial.println();
}


// ============================================================================
// 18. SOM DE ERRO
// ============================================================================

void tocarSomErro() {

  tone(BUZZER_PIN, 220);

  delay(250);

  noTone(BUZZER_PIN);


  delay(100);


  tone(BUZZER_PIN, 150);

  delay(500);

  noTone(BUZZER_PIN);
}


// ============================================================================
// 19. CALIBRACAO DO SENSOR
// ============================================================================

void calibrarSensor() {

  /*
   * Durante TODA a calibracao:
   *
   * BUZZER = MUDO
   */

  noTone(BUZZER_PIN);

  digitalWrite(LED_PIN, LOW);


  // --------------------------------------------------------------------------
  // ETAPA 1 - SEM TOQUE
  // --------------------------------------------------------------------------

  Serial.println();

  Serial.println("==================================================");

  Serial.println(" CALIBRACAO - ETAPA 1");

  Serial.println("==================================================");

  Serial.println();

  Serial.println("       NAO TOQUE NO SENSOR!");

  Serial.println();

  Serial.println("Mantenha o eletrodo completamente livre.");

  Serial.println();

  Serial.println("Medindo durante 5 segundos...");

  Serial.println();


  valorSemToque =
    medirMediaDurante(TEMPO_SEM_TOQUE);


  Serial.println();

  Serial.print("Media SEM TOQUE = ");

  Serial.println(valorSemToque);


  // --------------------------------------------------------------------------
  // AVISO ENTRE AS CALIBRACOES
  // --------------------------------------------------------------------------

  Serial.println();

  Serial.println("Primeira etapa concluida.");

  Serial.println();

  Serial.println("LED piscara 3 vezes.");

  Serial.println();


  piscarLed(3);


  // --------------------------------------------------------------------------
  // ETAPA 2 - COM TOQUE
  // --------------------------------------------------------------------------

  Serial.println();

  Serial.println("==================================================");

  Serial.println(" CALIBRACAO - ETAPA 2");

  Serial.println("==================================================");

  Serial.println();

  Serial.println("       AGORA TOQUE NO SENSOR!");

  Serial.println();

  Serial.println("Coloque o dedo no eletrodo.");

  Serial.println();

  Serial.println("Mantenha o dedo durante toda a medicao.");

  Serial.println();


  Serial.println("Medicao inicia em:");

  Serial.println();

  Serial.println("2...");

  delay(1000);

  Serial.println("1...");

  delay(1000);


  Serial.println();

  Serial.println("MEDINDO COM TOQUE DURANTE 3 SEGUNDOS...");

  Serial.println();


  valorComToque =
    medirMediaDurante(TEMPO_COM_TOQUE);


  // --------------------------------------------------------------------------
  // DESCOBRIR DIRECAO DO SENSOR
  // --------------------------------------------------------------------------

  if (valorComToque > valorSemToque) {

    toqueAumentaValor = true;

  }

  else {

    toqueAumentaValor = false;
  }


  // --------------------------------------------------------------------------
  // CALCULAR LIMIAR
  // --------------------------------------------------------------------------

  limiar =
    (valorSemToque + valorComToque) / 2;


  // --------------------------------------------------------------------------
  // DIFERENCA ENTRE OS ESTADOS
  // --------------------------------------------------------------------------

  unsigned long diferenca;


  if (valorComToque > valorSemToque) {

    diferenca =
      valorComToque - valorSemToque;

  }

  else {

    diferenca =
      valorSemToque - valorComToque;
  }


  // --------------------------------------------------------------------------
  // RESULTADOS
  // --------------------------------------------------------------------------

  Serial.println();

  Serial.println("==================================================");

  Serial.println(" CALIBRACAO CONCLUIDA");

  Serial.println("==================================================");

  Serial.println();


  Serial.print("SEM TOQUE : ");

  Serial.println(valorSemToque);


  Serial.print("COM TOQUE : ");

  Serial.println(valorComToque);


  Serial.print("LIMIAR    : ");

  Serial.println(limiar);


  Serial.print("DIFERENCA : ");

  Serial.println(diferenca);


  Serial.println();


  if (toqueAumentaValor) {

    Serial.println("O toque AUMENTA a leitura.");

  }

  else {

    Serial.println("O toque DIMINUI a leitura.");
  }


  if (diferenca < 3) {

    Serial.println();

    Serial.println("*** ATENCAO ***");

    Serial.println();

    Serial.println("A diferenca entre os dois estados ficou pequena.");

    Serial.println("Verifique:");

    Serial.println("- resistor de 1 MOhm;");

    Serial.println("- eletrodo;");

    Serial.println("- fios;");

    Serial.println("- conexoes.");
  }


  sensorTocado = false;

  sensorTocadoAnterior = false;

  contadorSemToque = 0;


  noTone(BUZZER_PIN);

  digitalWrite(LED_PIN, LOW);
}


// ============================================================================
// 20. LEITURA CAPACITIVA
// ============================================================================

unsigned long lerSensorCapacitivo(uint8_t quantidadeAmostras) {

  uint64_t soma = 0;


  for (uint8_t i = 0;
       i < quantidadeAmostras;
       i++) {


    digitalWrite(SEND_PIN, LOW);


    pinMode(RECEIVE_PIN, OUTPUT);

    digitalWrite(RECEIVE_PIN, LOW);


    delayMicroseconds(100);


    pinMode(RECEIVE_PIN, INPUT);


    unsigned long inicio = micros();


    digitalWrite(SEND_PIN, HIGH);


    while (digitalRead(RECEIVE_PIN) == LOW) {

      if ((micros() - inicio) >= TIMEOUT_SENSOR_US) {

        break;
      }
    }


    unsigned long tempo =
      micros() - inicio;


    if (tempo > TIMEOUT_SENSOR_US) {

      tempo = TIMEOUT_SENSOR_US;
    }


    soma += tempo;


    digitalWrite(SEND_PIN, LOW);
  }


  return
    (unsigned long)(soma / quantidadeAmostras);
}


// ============================================================================
// 21. VERIFICAR TOQUE
// ============================================================================

bool verificarToque(unsigned long valor) {

  if (toqueAumentaValor) {

    return valor > limiar;

  }

  else {

    return valor < limiar;
  }
}


// ============================================================================
// 22. MEDIA DURANTE A CALIBRACAO
// ============================================================================

unsigned long medirMediaDurante(unsigned long tempoMedicao) {

  uint64_t soma = 0;

  unsigned long quantidadeLeituras = 0;


  unsigned long inicio = millis();

  unsigned long ultimoRelatorio = millis();


  while ((millis() - inicio) < tempoMedicao) {


    unsigned long leitura =
      lerSensorCapacitivo(AMOSTRAS_POR_LEITURA);


    soma += leitura;

    quantidadeLeituras++;


    if ((millis() - ultimoRelatorio) >= 1000) {

      Serial.print("Leitura atual: ");

      Serial.println(leitura);


      ultimoRelatorio = millis();
    }


    delay(2);
  }


  if (quantidadeLeituras == 0) {

    return 0;
  }


  return
    (unsigned long)(soma / quantidadeLeituras);
}


// ============================================================================
// 23. PISCAR LED
// ============================================================================

void piscarLed(uint8_t quantidade) {

  noTone(BUZZER_PIN);


  for (uint8_t i = 0;
       i < quantidade;
       i++) {


    digitalWrite(LED_PIN, HIGH);

    delay(TEMPO_PISCADA);


    digitalWrite(LED_PIN, LOW);

    delay(TEMPO_PISCADA);
  }
}


// ============================================================================
// 24. MONITOR SERIAL
// ============================================================================

void mostrarMonitorSerial() {

  if ((millis() - ultimoSerial) < INTERVALO_SERIAL) {

    return;
  }


  Serial.print("Sensor: ");

  Serial.print(valorSensor);


  Serial.print(" | Limiar: ");

  Serial.print(limiar);


  Serial.print(" | Estado sensor: ");


  if (sensorTocado) {

    Serial.print("TOCADO");

  }

  else {

    Serial.print("LIVRE");
  }


  Serial.print(" | Soltura: ");

  Serial.print(contadorSemToque);

  Serial.print("/");

  Serial.print(LEITURAS_PARA_CONFIRMAR_SOLTURA);


  Serial.print(" | Jogo: ");


  if (estadoJogo == JOGANDO) {

    Serial.print("JOGANDO");

  }

  else if (estadoJogo == ERRO_AGUARDANDO_3_SEGUNDOS) {

    Serial.print("ERRO - AGUARDANDO 3s");

  }

  else {

    Serial.print("REINICIO - AGUARDANDO SOLTAR");
  }


  Serial.print(" | Proxima nota: ");

  Serial.print(indiceNota + 1);

  Serial.print("/");

  Serial.println(TOTAL_NOTAS);


  ultimoSerial = millis();
}

Boas práticas

Faça toda a montagem e os primeiros testes na Mini Protoboard antes de colocar os componentes dentro da pelúcia.
Utilize um resistor de 1M? entre os GPIOs 13 e 14.
Utilize um resistor de 230? em série com o LED. Caso utilize o Kit Resistor 500, o resistor de 220? também pode ser utilizado.
Năo toque no eletrodo durante a primeira etapa da calibraçăo.
Durante a segunda etapa, mantenha o dedo no eletrodo durante todo o período solicitado.
Evite fios excessivamente longos entre a BlackBoard Edge H e o eletrodo, pois eles também influenciam a capacitância do circuito.
Utilize um buzzer passivo para permitir a reproduçăo de diferentes frequęncias e notas musicais.
Proteja a BlackBoard Edge H, as soldas e as conexőes antes de colocá-las dentro da pelúcia.
Antes de fechar definitivamente a pelúcia, teste várias vezes a calibraçăo, todas as notas, o timeout de 10 segundos e o procedimento de reinício por toque de 3 segundos.