Como Criar um Piano Musical com ESP32 Usando o DAC Interno e Sensores TTP223

Aprenda a construir um piano musical com ESP32 utilizando o DAC interno e sete sensores de toque capacitivo TTP223. Um projeto prático para entender geração de áudio, notas musicais e o funcionamento do DAC do ESP32.

Introdução

Você sabia que o ESP32 consegue gerar áudio sem utilizar um módulo de som externo?

Isso é possível graças ao DAC (Digital-to-Analog Converter), um periférico interno presente em alguns microcontroladores. Neste projeto vamos utilizá-lo para construir um pequeno piano eletrônico usando sete sensores de toque capacitivo TTP223.

Além de criar um projeto divertido, este exemplo é excelente para entender como um microcontrolador transforma números digitais em sinais elétricos analógicos.

---

O que é um DAC?

DAC significa Digital-to-Analog Converter, ou Conversor Digital-Analógico.

Sua principal função é transformar um valor digital (0 e 1) produzido pelo microcontrolador em uma tensão analógica.

Imagine que o microcontrolador "pensa" apenas em números.

Por exemplo:

Valor Digital	Tensão aproximada
0	0 V
64	0,82 V
128	1,65 V
192	2,47 V
255	3,30 V

No caso do ESP32, o DAC possui 8 bits de resolução, permitindo gerar 256 níveis diferentes de tensão.

Isso significa que o microcontrolador consegue variar continuamente a tensão entre aproximadamente 0 V e 3,3 V.

Essa tensão pode ser utilizada para diversas aplicações, como:

• geração de áudio;
• instrumentos musicais;
• sintetizadores;
• sinais de teste;
• controle de equipamentos analógicos;
• geração de formas de onda.

---

Como o DAC gera uma nota musical?

Quando ouvimos uma nota musical, na verdade estamos ouvindo uma vibração.

Por exemplo:

• Dó (C4) = 262 Hz
• Ré (D4) = 294 Hz
• Lá (A4) = 440 Hz

O número em Hertz representa quantas vezes por segundo a onda se repete.

Se o DAC produzir uma onda de 440 ciclos por segundo, ouviremos a nota Lá.

Quanto maior a frequência, mais agudo será o som.

Quanto menor a frequência, mais grave será o som.

---

Onde o DAC é utilizado?

O DAC está presente em diversos equipamentos eletrônicos:

• caixas de som Bluetooth;
• celulares;
• televisores;
• placas de som;
• sintetizadores musicais;
• equipamentos médicos;
• instrumentos de medição;
• osciloscópios;
• automação industrial.

Sempre que um equipamento precisa transformar dados digitais em um sinal analógico, existe um DAC trabalhando nos bastidores.

---

Quais microcontroladores possuem DAC?

Nem todos os microcontroladores possuem DAC interno.

A tabela abaixo mostra alguns exemplos.

Microcontrolador	DAC Interno
Arduino Uno (ATmega328P)	❌ Não
Arduino Nano	❌ Não
Arduino Mega	❌ Não
ESP8266	❌ Não
ESP32	✅ Sim (2 canais de 8 bits)
ESP32-S2	✅ Sim
ESP32-S3	❌ Não possui DAC analógico interno
ESP32-C3	❌ Não
ESP32-C6	❌ Não
STM32 (alguns modelos)	✅ Sim
RP2040 (Raspberry Pi Pico)	❌ Não

Ter um DAC interno reduz o custo do projeto, pois elimina a necessidade de um conversor digital-analógico externo para aplicações simples.

---

O Sensor Capacitivo TTP223

O TTP223 é um sensor de toque capacitivo muito utilizado em projetos eletrônicos.

Em vez de utilizar um botão mecânico, ele detecta a aproximação do dedo.

Quando tocamos na área metálica do sensor, ocorre uma pequena alteração na capacitância elétrica.

O circuito interno identifica essa mudança e altera sua saída digital.

Assim:

Sem toque

Saída = LOW

Com toque

Saída = HIGH

Para o ESP32, o TTP223 funciona exatamente como um botão digital.

Isso torna sua utilização extremamente simples.

---

Vantagens do TTP223

• não possui desgaste mecânico;
• funcionamento silencioso;
• alta durabilidade;
• fácil ligação;
• baixo consumo de energia;
• excelente para interfaces modernas.

Neste projeto, cada TTP223 representa uma tecla do piano.

---

Como funciona o DAC do ESP32?

O DAC interno do ESP32 converte valores digitais de 8 bits em níveis de tensão analógicos. Essa conversão permite gerar ondas senoidais e frequências correspondentes às notas musicais Dó, Ré, Mi, Fá, Sol, Lá e Si, tornando o ESP32 uma excelente plataforma para projetos de áudio e síntese sonora.

O ESP32 clássico possui dois canais DAC:

• GPIO25 (DAC1)
• GPIO26 (DAC2)

Cada canal possui resolução de 8 bits.

Isso significa que o DAC pode gerar 256 níveis diferentes de tensão.

Quando enviamos um valor ao DAC, ele produz uma tensão correspondente entre aproximadamente 0 V e 3,3 V.

Entretanto, neste projeto utilizamos a biblioteca DacESP32, que faz um trabalho ainda mais interessante.

Em vez de apenas gerar uma tensão fixa, ela cria uma sequência muito rápida de valores digitais.

Essa sequência forma uma onda periódica na saída do DAC.

Se a onda for gerada a:

• 262 vezes por segundo → ouvimos um Dó.
• 294 vezes por segundo → ouvimos um Ré.
• 440 vezes por segundo → ouvimos um Lá.

Na prática, o DAC está produzindo um sinal elétrico oscilante que faz o alto-falante vibrar exatamente naquela frequência.

---

DAC do ESP32 × tone() do Arduino

Muitos iniciantes acreditam que a função tone() do Arduino utiliza um DAC.

Na verdade, isso não acontece.

Arduino Uno

A função tone() apenas liga e desliga rapidamente um pino digital.

O resultado é uma onda quadrada.

O pino continua sendo totalmente digital.

Não existe geração de tensão analógica.

5V
 ┌───┐     ┌───┐
 │   │     │   │
 │   │     │   │
 └───┴─────┴───┴──

---

ESP32 utilizando DAC

No ESP32, a biblioteca envia diversos níveis de tensão ao DAC.

Assim, o microcontrolador gera um sinal analógico.

Dependendo da biblioteca utilizada, esse sinal pode representar uma senoide, uma triangular, uma dente de serra ou outras formas de onda.

Isso aproxima muito mais o funcionamento de um sintetizador eletrônico.

Em resumo:

Arduino tone()	ESP32 DAC
Apenas alterna HIGH e LOW	Gera níveis analógicos de tensão
Pino digital	Saída analógica
Não possui DAC	Utiliza DAC interno
Som mais simples	Muito mais flexível

---

Entendendo o código do Piano

Esquema completo de montagem do piano musical com ESP32. O projeto utiliza o DAC interno no GPIO25 para gerar as notas musicais, sete sensores capacitivos TTP223 como teclas, um amplificador de áudio PAM8403 e um alto-falante de 4 Ω/3 W para reproduzir o som.

O programa foi desenvolvido utilizando arrays (vetores).

Essa técnica evita repetir o mesmo código sete vezes.

---

/*****************************************************************************************

 * Projeto : Piano Musical com DAC Interno do ESP32 e Sensores TTP223

 * Autor   : RodRobot

 * Site    : www.rodrobot.com

 *

 * Descrição

 * ---------------------------------------------------------------------------------------

 * Este projeto demonstra como utilizar o DAC (Conversor Digital-Analógico)

 * interno do ESP32 para gerar notas musicais.

 *

 * Cada sensor capacitivo TTP223 funciona como uma tecla do piano.

 * Ao tocar em um sensor, o ESP32 gera uma onda na frequência da nota

 * correspondente utilizando o DAC interno no GPIO25.

 *

 * Neste exemplo é utilizada uma técnica chamada Arrays (Vetores),

 * permitindo adicionar ou remover notas facilmente.

 *

 * Ligações

 * ---------------------------------------------------------------------------------------

 * DAC

 * GPIO25 ----> Amplificador PAM8403 ou Caixa Amplificada

 *

 * Sensores TTP223

 * GPIO18 ----> DO

 * GPIO19 ----> RE

 * GPIO21 ----> MI

 * GPIO22 ----> FA

 * GPIO23 ----> SOL

 * GPIO32 ----> LA

 * GPIO33 ----> SI

 *

 * Todos os módulos

 * VCC --------> 3.3V

 * GND --------> GND

 *****************************************************************************************/

#include <DacESP32.h>

DacESP32 dac(25);                                  // DAC1 no GPIO25

//======================= Pinos dos Sensores =======================

const byte pinos[] =

{

  18,      // DO

  19,      // RE

  21,      // MI

  22,      // FA

  23,      // SOL

  32,      // LA

  33       // SI

};

//======================== Nome das Notas ==========================

const char *nomes[] =

{

  "DO",

  "RE",

  "MI",

  "FA",

  "SOL",

  "LA",

  "SI"

};

//===================== Frequências Musicais =======================

const int frequencias[] =

{

  262,     // DO

  294,     // RE

  330,     // MI

  349,     // FA

  392,     // SOL

  440,     // LA

  494      // SI

};

// Quantidade de notas

const byte TOTAL_NOTAS = sizeof(pinos) / sizeof(pinos[0]);

//==================================================================

void setup()

{

  Serial.begin(115200);                           // Inicializa Serial

  // Configura todos os pinos como entrada

  for (byte i = 0; i < TOTAL_NOTAS; i++)

  {

    pinMode(pinos[i], INPUT);

  }

  Serial.println();

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

  Serial.println(" Piano Musical com ESP32");

  Serial.println(" DAC Interno + Sensores TTP223");

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

}

//==================================================================

void loop()

{

  // Percorre todas as notas

  for (byte i = 0; i < TOTAL_NOTAS; i++)

  {

    if (digitalRead(pinos[i]))

    {

      tocarNota(nomes[i], frequencias[i]);        // Toca a nota

      while (digitalRead(pinos[i]));              // Aguarda soltar

      dac.disable();                              // Desliga o DAC

      delay(10);

    }

  }

}

//==================================================================

// Gera a nota musical

//==================================================================

void tocarNota(const char *nome, int frequencia)

{

  Serial.print("Nota: ");

  Serial.print(nome);

  Serial.print("   Frequência: ");

  Serial.print(frequencia);

  Serial.println(" Hz");

  dac.outputCW(frequencia);                       // Gera a frequência

}

---

Vetor de pinos

const byte pinos[] =
{
  18,  // DO
  19,  // RE
  21,  // MI
  22,  // FA
  23,  // SOL
  32,  // LA
  33   // SI
};

Cada posição representa um sensor TTP223.

---

Vetor dos nomes

const char *nomes[] =
{
  "DO",
  "RE",
  "MI",
  "FA",
  "SOL",
  "LA",
  "SI"
};

Esse vetor é utilizado apenas para mostrar a nota no Monitor Serial.

---

Vetor das frequências

const int frequencias[] =
{
  262,
  294,
  330,
  349,
  392,
  440,
  494
};

Cada frequência corresponde a uma nota musical da quarta oitava.

---

Configurando os sensores

No setup(), utilizamos um laço for para configurar todos os sensores como entrada.

for(byte i=0;i<TOTAL_NOTAS;i++)
{
    pinMode(pinos[i], INPUT);
}

Isso elimina a necessidade de escrever sete comandos pinMode().

---

Verificando qual tecla foi pressionada

Dentro da função loop() utilizamos outro for.

for(byte i=0;i<TOTAL_NOTAS;i++)

O programa verifica cada sensor.

Se algum deles estiver em nível alto (HIGH), significa que houve um toque.

Então executa:

tocarNota(nomes[i], frequencias[i]);

Observe que o índice i acessa simultaneamente:

• o pino correspondente;
• o nome da nota;
• sua frequência.

Essa é uma das grandes vantagens dos arrays.

---

Gerando a nota

A função

dac.outputCW(frequencia);

faz a biblioteca configurar o DAC para produzir uma onda contínua naquela frequência.

Enquanto o dedo permanece sobre o sensor, a nota continua sendo reproduzida.

Quando o usuário retira o dedo, executamos:

dac.disable();

Isso interrompe imediatamente a geração do sinal analógico.

---

Conclusão

Este projeto vai muito além de um simples piano eletrônico. Ele apresenta, de forma prática, conceitos fundamentais da eletrônica e da programação embarcada, como entradas digitais, sensores capacitivos, geração de frequências e conversão digital-analógica.

O uso do DAC interno do ESP32 permite compreender como um microcontrolador pode produzir sinais elétricos analógicos sem a necessidade de circuitos externos, enquanto o TTP223 mostra uma alternativa moderna aos botões mecânicos tradicionais.

Além disso, a organização do código com arrays (vetores) torna o programa mais limpo, reutilizável e fácil de expandir. Se você desejar adicionar mais notas, outras oitavas ou até criar um sintetizador musical mais completo, bastará incluir novos elementos nos vetores, sem alterar a estrutura principal do programa.

Esse tipo de projeto demonstra como recursos internos do ESP32 podem ser explorados para criar aplicações criativas, didáticas e de baixo custo, servindo como uma excelente base para estudos mais avançados em áudio digital, processamento de sinais e sistemas embarcados.

---

🔧 Acompanhe o RodRobot

Projetos maker com ESP32, Arduino, eletrônica e programação.

📖 Blog RodRobot 💻 GitHub ▶ YouTube videos 🎵 TikTok 📸 Instagram

RodRobot – Projetos maker, eletrônica e programação na prática.